

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Slurm-REST-API auf PCS AWS
<a name="slurm-rest-api"></a>

AWS PCS bietet verwalteten Support für die native REST-API von Slurm und stellt eine HTTP-Schnittstelle für die `slurmrestd` programmatische Cluster-Interaktion bereit. Sie können Jobs einreichen, den Clusterstatus überwachen und Ressourcen über Standard-HTTP-Anfragen verwalten, ohne direkten Shell-Zugriff auf Ihren Cluster zu benötigen.

## Häufige Anwendungsfälle
<a name="slurm-rest-api-use-cases"></a>

Die Slurm-REST-API unterstützt verschiedene Integrationsszenarien:
+ **Integration von Webanwendungen**: Erstellen Sie benutzerdefinierte Frontends und Webanwendungen, die Jobs direkt einreichen und verwalten.
+ **Jupyter Notebook-Integration**: Ermöglicht Forschern, Jobs von Notebook-Umgebungen aus einzureichen, ohne ihren Entwicklungsworkflow zu verlassen.
+ **Integration von Partnerlösungen**: Connect HPC-Tools und Workflow-Manager von Drittanbietern mit Ihren AWS PCS-Clustern.
+ **Programmatisches Clustermanagement**: Automatisieren Sie die Workflows für die Auftragsübergabe, Überwachung und Ressourcenverwaltung.
+ **Workflows für die Datenverarbeitung in der Forschung**: Support Sie akademische und Unternehmensforschungsumgebungen, die ein API-gesteuertes Auftragsmanagement erfordern.

## Anforderungen und Einschränkungen
<a name="slurm-rest-api-requirements"></a>

Bevor Sie die Slurm-REST-API verwenden, überprüfen Sie diese Details:
+ Ihr Cluster muss Slurm Version 25.05 oder höher verwenden.
+ Auf den API-Endpunkt kann nur über eine private IP-Adresse innerhalb der VPC Ihres Clusters zugegriffen werden.
+ Ihre Cluster-Sicherheitsgruppe muss HTTP-Verkehr auf Port 6820 zulassen.
+ Für die Authentifizierung sind JWT-Token mit bestimmten Benutzeridentitätsansprüchen erforderlich.

Zu den aktuellen Einschränkungen gehören:
+ Von generierte Token `scontrol token` werden nicht unterstützt.
+ `X-SLURM-USER-NAME`Die Imitation von Headern ist nicht verfügbar.
+ Für einige Funktionen muss die Slurm-Accounting-Funktion aktiviert sein.
+ Nicht kompatibel mit dem Slurm-CLI-Filter-Plugin-Mechanismus.
+ Verbindungen zum REST-API-Endpunkt sind nicht mit TLS verschlüsselt.

**Topics**
+ [Häufige Anwendungsfälle](#slurm-rest-api-use-cases)
+ [Anforderungen und Einschränkungen](#slurm-rest-api-requirements)
+ [Aktivierung der Slurm-REST-API auf PCS AWS](slurm-rest-api-enable.md)
+ [Authentifizierung mit der Slurm-REST-API in PCS AWS](slurm-rest-api-authenticate.md)
+ [Verwendung der Slurm-REST-API für die Auftragsverwaltung in PCS AWS](slurm-rest-api-use.md)
+ [Häufig gestellte Fragen zur Slurm-REST-API in AWS PCS](slurm-rest-api-faq.md)

# Aktivierung der Slurm-REST-API auf PCS AWS
<a name="slurm-rest-api-enable"></a>

Aktivieren Sie die Slurm-REST-API für den Zugriff auf die HTTP-Schnittstelle Ihres Clusters für die programmatische Auftragsverwaltung und -überwachung. Sie können diese Funktion während der Clustererstellung aktivieren oder einen vorhandenen Cluster aktualisieren, der die Anforderungen erfüllt.

## Voraussetzungen
<a name="slurm-rest-api-enable-prerequisites"></a>

Bevor Sie die Slurm-REST-API aktivieren, stellen Sie sicher, dass Sie über Folgendes verfügen:
+ **Cluster-Version**: Slurm-Version 25.05 oder höher.
+ **Sicherheitsgruppe**: Regeln, die HTTP-Verkehr auf Port 6820 von Ihren gewünschten Quellen zulassen.

## Verfahren
<a name="slurm-rest-api-enable-procedure"></a>

**Um die Slurm-REST-API auf einem neuen Cluster zu aktivieren**

------
#### [ AWS-Managementkonsole ]

1. Öffnen Sie die AWS PCS-Konsole unter. [https://console.aws.amazon.com/pcs/](https://console.aws.amazon.com/pcs/)

1. Wählen Sie **Cluster erstellen**.

1. Wählen Sie unter **Cluster-Details** die Slurm-Version 25.05 oder höher aus.

1. Konfigurieren Sie die anderen Cluster-Einstellungen nach Bedarf.

1. Stellen Sie im Abschnitt **Scheduler-Konfiguration** die **REST-API** auf **Aktiviert** ein.

1. Konfigurieren Sie Ihre Cluster-Sicherheitsgruppe so, dass HTTP-Verkehr auf Port 6820 von Ihren gewünschten Quellen zugelassen wird.

1. Schließen Sie den Vorgang zur Clustererstellung ab.

------
#### [ AWS CLI ]

1. Fügen Sie bei der Erstellung Ihres Clusters eine Slurm-REST-Konfiguration hinzu.

   ```
   aws pcs create-cluster --region region \
       --cluster-name my-cluster \
       --scheduler type=SLURM, version=25.05 \
       --size SMALL \
       --networking subnetIds=subnet-ExampleId1,securityGroupIds=sg-ExampleId1 \
       --slurm-configuration slurmRest='{mode=STANDARD}'
   ```

1. Konfigurieren Sie Ihre Cluster-Sicherheitsgruppe so, dass HTTP-Verkehr auf Port 6820 von Ihren gewünschten Quellen aus zugelassen wird.

------

**Um die Slurm-REST-API auf einem vorhandenen Cluster zu aktivieren**

------
#### [ AWS-Managementkonsole ]

1. Öffnen Sie die AWS PCS-Konsole unter. [https://console.aws.amazon.com/pcs/](https://console.aws.amazon.com/pcs/)

1. Wählen Sie Ihren Cluster aus der Liste aus.

1. Stellen Sie in den Cluster-Details sicher, dass Ihr Cluster Slurm Version 25.05 oder höher verwendet.

1. **Wählen Sie Cluster bearbeiten.**

1. Stellen Sie im Abschnitt **Scheduler-Konfiguration** die **REST-API** auf **Aktiviert** ein.

1. Wählen Sie **Cluster aktualisieren**, um die Änderungen zu übernehmen.

1. Konfigurieren Sie Ihre Cluster-Sicherheitsgruppe so, dass HTTP-Verkehr auf Port 6820 von Ihren gewünschten Quellen zugelassen wird.

------
#### [ AWS CLI ]

1. Aktualisieren Sie Ihren Cluster mit einer Slurm-REST-Konfiguration, wie in diesem Beispiel.

   ```
   aws pcs update-cluster --cluster-identifier my-cluster \
       --slurm-configuration 'slurmRest={mode=STANDARD}'
   ```

1. Konfigurieren Sie Ihre Cluster-Sicherheitsgruppe so, dass HTTP-Verkehr auf Port 6820 aus Ihren gewünschten Quellen zugelassen wird.

------

## Was passiert nach der Aktivierung
<a name="slurm-rest-api-enable-results"></a>

Wenn Sie die REST-API aktivieren, führt AWS PCS automatisch:
+ Generiert einen JWT-Signaturschlüssel und speichert ihn in AWS Secrets Manager.
+ Macht den API-Endpunkt `https://<clusterPrivateIpAddress>:6820` in Ihrer VPC verfügbar.
+ Aktualisiert Ihre Cluster-Konfiguration, sodass die REST-API-Endpunktdetails angezeigt werden.

Sie können sich jetzt authentifizieren und die REST-API für die Auftragsverwaltung und Clustervorgänge verwenden.

# Authentifizierung mit der Slurm-REST-API in PCS AWS
<a name="slurm-rest-api-authenticate"></a>

Die Slurm-REST-API in AWS PCS verwendet die JSON-Web-Token-Authentifizierung (JWT), um einen sicheren Zugriff auf Ihre Cluster-Ressourcen zu gewährleisten. AWS PCS stellt einen verwalteten Signaturschlüssel bereit, der in AWS Secrets Manager gespeichert ist und den Sie verwenden, um JWT-Token zu generieren, die bestimmte Benutzeridentitätsansprüche enthalten.

## Voraussetzungen
<a name="slurm-rest-api-authenticate-prerequisites"></a>

Bevor Sie sich mit der Slurm-REST-API authentifizieren, stellen Sie sicher, dass Sie über Folgendes verfügen:
+ **Cluster-Konfiguration**: AWS PCS-Cluster mit Slurm 25.05\$1 und aktivierter REST-API.
+ **AWS-Berechtigungen**: Zugriff auf AWS Secrets Manager für den JWT-Signaturschlüssel.
+ **Benutzerinformationen**: Benutzername, POSIX-Benutzer-ID und eine oder mehrere POSIX-Gruppen IDs für Ihr Cluster-Konto.
+ **Netzwerkzugriff**: Konnektivität innerhalb der VPC Ihres Clusters mit einer Sicherheitsgruppe, die Port 6820 zulässt.

## Verfahren
<a name="slurm-rest-api-authenticate-procedure"></a>

**Um die Adresse des Slurm-REST-API-Endpunkts abzurufen**

------
#### [ AWS-Managementkonsole ]

1. Öffnen Sie die AWS PCS-Konsole unter. [https://console.aws.amazon.com/pcs/](https://console.aws.amazon.com/pcs/)

1. Wählen Sie Ihren Cluster aus der Liste aus.

1. Suchen Sie in den Cluster-Konfigurationsdetails den Abschnitt **Endpoints**.

1. Notieren Sie sich die private IP-Adresse und den Port für die **Slurm-REST-API (slurmrestd**).

1. Sie können API-Aufrufe tätigen, indem Sie ordnungsgemäß formatierte HTTP-Anfragen an diese Adresse senden.

------
#### [ AWS CLI ]

1. Fragen Sie Ihren Clusterstatus mit `aws pcs get-cluster` ab. Suchen Sie in dem `endpoints` Feld in der Antwort nach dem `SLURMRESTD` Endpunkt. Ein Beispiel:

   ```
   "endpoints": [
         {
             "type": "SLURMCTLD",
             "privateIpAddress": "192.0.2.1",
             "port": "6817"
         },
         {
             "type": "SLURMRESTD",
             "privateIpAddress": "192.0.2.1",
             "port": "6820"
         }
     ]
   ```

1. Sie können API-Aufrufe tätigen, indem Sie ordnungsgemäß formatierte HTTP-Anfragen an senden `http://<privateIpAddress>:<port>/`

------

**Um den JWT-Signaturschlüssel abzurufen**

1. Öffnen Sie die AWS PCS-Konsole unter. [https://console.aws.amazon.com/pcs/](https://console.aws.amazon.com/pcs/)

1. Wählen Sie Ihren Cluster aus der Liste aus.

1. Suchen Sie in den Cluster-Konfigurationsdetails den Abschnitt **Scheduler-Authentifizierung**.

1. Notieren Sie sich den ARN und die Version des **JSON-Web-Token-Schlüssels (JWT)**.

1. Verwenden Sie den AWS CLI , um den Signaturschlüssel von Secrets Manager abzurufen:

   ```
   aws secretsmanager get-secret-value --secret-id arn:aws:secretsmanager:region:account:secret:name --version-id version
   ```

**Um ein JWT-Token zu generieren**

1. Erstellen Sie ein JWT mit den folgenden erforderlichen Ansprüchen:
   + `exp`— Ablaufzeit in Sekunden seit 1970 für das JWT
   + `iat`— Aktuelle Zeit in Sekunden seit 1970
   + `sun`— Der Benutzername für die Authentifizierung
   + `uid`— Die POSIX-Benutzer-ID
   + `gid`— Die POSIX-Gruppen-ID
   + `id`— Zusätzliche POSIX-Identitätseigenschaften
     + `gecos`— Feld für Benutzerkommentare, das häufig verwendet wird, um einen für Menschen lesbaren Namen zu speichern
     + `dir`— Heimatverzeichnis des Benutzers
     + `shell`— Standard-Shell des Benutzers
     + `gids`— Liste der zusätzlichen POSIX-Gruppen, in denen IDs sich der Benutzer befindet

1. Signieren Sie das JWT mit dem Signaturschlüssel, den Sie von Secrets Manager abgerufen haben.

1. Legen Sie eine angemessene Ablaufzeit für das Token fest.

**Anmerkung**  
Als Alternative zum `sun` Antrag können Sie eine der folgenden Angaben machen:  
`username`
Ein benutzerdefinierter Feldname, den Sie über das `userclaimfield` definieren `AuthAltParameters Slurm custom settings`
Ein `name` Feld innerhalb des `id` Antrags

**Um API-Anfragen zu authentifizieren**

1. Fügen Sie das JWT-Token mithilfe einer der folgenden Methoden in Ihre HTTP-Anfragen ein:
   + **Trägertoken — Header** hinzufügen `Authorization: Bearer <jwt>`
   + **Slurm-Header — Header** hinzufügen `X-SLURM-USER-TOKEN: <jwt>`

1. Stellen Sie HTTP-Anfragen an den REST-API-Endpunkt:

   Hier ist ein Beispiel für den Zugriff auf die `/ping` API mithilfe von Curl und dem `Authorized: Bearer` Header.

   ```
   curl -X GET -H "Authorization: Bearer <jwt>" \
         http://<privateIpAddress>:6820/slurm/v0.0.43/ping
   ```

## Beispiel für eine JWT-Generierung
<a name="slurm-rest-api-authenticate-example"></a>

Rufen Sie den JWT-Signaturschlüssel des AWS PCS-Clusters ab und speichern Sie ihn als lokale Datei. Ersetzen Sie Werte für **aws-region**, **secret-arn** und **secret version** durch Werte, die für Ihren Cluster geeignet sind.

```
#!/bin/bash
SECRET_KEY=$(aws secretsmanager get-secret-value \
  --region aws-region \
  --secret-id secret-arn \
  --version-stage secret-version \
  --query 'SecretString' \
  --output text)
echo "$SECRET_KEY" | base64 --decode > jwt.key
```

Dieses Python-Beispiel zeigt, wie der Signaturschlüssel verwendet wird, um ein JWT-Token zu generieren:

```
#!/usr/bin/env python3

import sys
import os
import pprint
import json
import time
from datetime import datetime, timedelta, timezone
from jwt import JWT
from jwt.jwa import HS256
from jwt.jwk import jwk_from_dict
from jwt.utils import b64decode,b64encode
if len(sys.argv) != 3:
    sys.exit("Usage: gen_jwt.py [jwt_key_file] [expiration_time_seconds]")
SIGNING_KEY = sys.argv[1]
EXPIRATION_TIME = int(sys.argv[2])
with open(SIGNING_KEY, "rb") as f:
    priv_key = f.read()
signing_key = jwk_from_dict({
    'kty': 'oct',
    'k': b64encode(priv_key)
})
message = {
    "exp": int(time.time() + EXPIRATION_TIME),
    "iat": int(time.time()),
    "sun": "ec2-user",
    "uid": 1000,
    "gid": 1000,
    "id": {
        "gecos": "EC2 User",
        "dir": "/home/ec2-user",
        "gids": [1000],
        "shell": "/bin/bash"
    }
}
a = JWT()
compact_jws = a.encode(message, signing_key, alg='HS256')
print(compact_jws)
```

Das Skript druckt ein JWT auf den Bildschirm.

```
abcdefgtjwttoken...
```

# Verwendung der Slurm-REST-API für die Auftragsverwaltung in PCS AWS
<a name="slurm-rest-api-use"></a>

## Überblick über die Slurm-REST-API
<a name="slurm-rest-api-use-overview"></a>

Die Slurm-REST-API bietet programmatischen Zugriff auf Cluster-Management-Funktionen über HTTP-Anfragen. Wenn Sie diese Hauptmerkmale verstehen, können Sie die API mit AWS PCS effektiv nutzen:
+ **Zugriffsprotokoll**: Die API verwendet HTTP (nicht HTTPS) für die Kommunikation innerhalb des privaten Netzwerks Ihres Clusters.
+ **Verbindungsdetails**: Greifen Sie über die private IP-Adresse Ihres Clusters und den `slurmrestd` Port (normalerweise 6820) auf die API zu. Das vollständige Basis-URL-Format ist`http://<privateIpAddress>:6820`.
+ **API-Versionierung**: Die API-Version entspricht Ihrer Slurm-Installation. **Verwenden Sie für Slurm 25.05 Version v0.0.43.** Die Versionsnummer ändert sich mit jeder Slurm-Version. Die derzeit unterstützten API-Versionen finden Sie in den [Slurm-Versionshinweisen](https://slurm.schedmd.com/release_notes.html).
+ **URL-Struktur**: Die URL-Struktur für die Slurm-REST-API lautet. `http://<privateIpAddress>:<port>/<api-version>/<endpoint>` Detaillierte Nutzungsinformationen für REST-API-Endpunkte finden Sie in der [Slurm-Dokumentation](https://slurm.schedmd.com/rest_api.html).

## Voraussetzungen
<a name="slurm-rest-api-use-prerequisites"></a>

Bevor Sie die Slurm-REST-API verwenden, stellen Sie sicher, dass Sie über Folgendes verfügen:
+ **Cluster-Konfiguration**: AWS PCS-Cluster mit Slurm 25.05\$1 und aktivierter REST-API.
+ **Authentifizierung**: Gültiges JWT-Token mit korrekten Angaben zur Benutzeridentität.
+ **Netzwerkzugriff**: Konnektivität innerhalb der VPC Ihres Clusters mit einer Sicherheitsgruppe, die Port 6820 zulässt.

## Verfahren
<a name="slurm-rest-api-use-procedure"></a>

**Um einen Job mit der REST-API einzureichen**

1. Erstellen Sie eine Anfrage zur Einreichung eines Jobs mit den erforderlichen Parametern:

   ```
   {
     "job": {
       "name": "my-job",
       "partition": "compute",
       "nodes": 1,
       "tasks": 1,
       "script": "#!/bin/bash\necho 'Hello from Slurm REST API'"
     }
   }
   ```

1. Reichen Sie den Job mit einer HTTP-POST-Anfrage ein:

   ```
   curl -X POST \
     -H "Authorization: Bearer <jwt>" \
     -H "Content-Type: application/json" \
     -d '<job-json>' \
     https://<privateIpAddress>:6820/slurm/v0.0.43/job/submit
   ```

1. Notieren Sie sich die in der Antwort zurückgegebene Job-ID zu Überwachungszwecken.

**Um den Jobstatus zu überwachen**

1. Informationen zu einem bestimmten Job abrufen:

   ```
   curl -X GET -H "Authorization: Bearer <jwt>" \
       https://<privateIpAddress>:6820/slurm/v0.0.43/job/<job-id>
   ```

1. Listet alle Jobs für den authentifizierten Benutzer auf:

   ```
   curl -X GET -H "Authorization: Bearer <jwt>" \
       https://<privateIpAddress>:6820/slurm/v0.0.43/jobs
   ```

**So brechen Sie einen Auftrag ab**
+ Senden Sie eine DELETE-Anfrage, um einen bestimmten Job zu stornieren:

  ```
  curl -X DELETE -H "Authorization: Bearer <jwt>" \
      https://<privateIpAddress>:6820/slurm/v0.0.43/job/<job-id>
  ```

# Häufig gestellte Fragen zur Slurm-REST-API in AWS PCS
<a name="slurm-rest-api-faq"></a>

In diesem Abschnitt werden häufig gestellte Fragen zur Slurm-REST-API in AWS PCS beantwortet.

**Was ist die Slurm-REST-API?**  
Die Slurm-REST-API ist eine HTTP-Schnittstelle, die es Ihnen ermöglicht, programmgesteuert mit dem Slurm-Workload-Manager zu interagieren. Sie können Standard-HTTP-Methoden wie GET, POST und DELETE verwenden, um Jobs zu senden, den Clusterstatus zu überwachen und Ressourcen zu verwalten, ohne dass Sie über die Befehlszeile auf den Cluster zugreifen müssen.

**Kann ich Tokens verwenden, die von generiert wurden? `scontrol token`**  
Nein, die `scontrol token` Standardausgabe ist nicht mit AWS PCS kompatibel. Die PCS Slurm REST-API benötigt erweiterte JWT-Token, die spezifische Identitätsansprüche enthalten, darunter username (`sun`), POSIX-Benutzer-ID (`uid`) und group IDs (). `gids` Bei Standard-Slurm-Token fehlen diese erforderlichen Ansprüche und sie werden von der API abgelehnt.

**Kann ich von außerhalb meiner VPC auf die API zugreifen?**  
Nein, auf den REST-API-Endpunkt kann nur von Ihrer VPC aus über die private IP-Adresse des Slurm-Controllers zugegriffen werden. Um den externen Zugriff zu ermöglichen, implementieren Sie AWS Dienste wie Application Load Balancer mit VPC Link, API Gateway oder richten Sie VPC-Peering- oder VPN-Verbindungen für sichere Konnektivität ein.

**Warum verwendet die API HTTP statt HTTPS?**  
Die Slurm-REST-API soll ein interner Endpunkt innerhalb des privaten Netzwerks Ihres Clusters sein. Für Produktionsbereitstellungen, die eine Verschlüsselung erfordern, können Sie die SSL/TLS Terminierung auf einer höheren Ebene in Ihrer Architektur implementieren, z. B. über ein API-Gateway, einen Load Balancer oder einen Reverse-Proxy.

**Wie kontrolliere ich den Zugriff auf die REST-API?**  
Konfigurieren Sie die Sicherheitsgruppenregeln Ihres Clusters, um den Zugriff auf Port 6820 auf dem Slurm-Controller einzuschränken. Legen Sie Regeln für eingehenden Datenverkehr fest, um Verbindungen nur von vertrauenswürdigen IP-Bereichen oder bestimmten Quellen innerhalb Ihrer VPC zuzulassen und unbefugten Zugriff auf den API-Endpunkt zu blockieren.

**Wie rotiere ich den JWT-Signaturschlüssel?**  
Versetzen Sie Ihren Cluster in den Wartungsmodus ohne aktive Instances und initiieren Sie dann die Schlüsselrotation über AWS Secrets Manager. Aktivieren Sie nach Abschluss der Rotation die Warteschlangen erneut. Alle vorhandenen JWT-Token werden ungültig und müssen mit dem neuen Signaturschlüssel von Secrets Manager neu generiert werden.

**Muss die Slurm-Buchhaltung aktiviert sein, um die REST-API verwenden zu können?**  
Nein, die Slurm-Buchhaltung ist für grundlegende REST-API-Operationen wie die Einreichung und Überwachung von Jobs nicht erforderlich. Für den gesamten `/slurmdb` Endpunkt muss die Buchhaltung jedoch aktiv sein.

**Welche Tools von Drittanbietern funktionieren mit der AWS PCS-REST-API?**  
Viele bestehende Slurm-REST-API-Clients sollten mit AWS PCS funktionieren, einschließlich Slurm Exporter für Prometheus und benutzerdefinierten Anwendungen SlurmWeb, die dem Standard-Slurm-REST-API-Format folgen. Tools, die auf die Authentifizierung angewiesen sind, müssen jedoch geändert werden, damit sie mit `scontrol token` den PCS JWT-Anforderungen funktionieren. AWS 

**Fallen zusätzliche Kosten für die Nutzung der REST-API an?**  
Nein, es fallen keine zusätzlichen Gebühren für die Aktivierung oder Nutzung der Slurm-REST-API-Funktion an. Sie zahlen wie gewohnt nur für die zugrunde liegenden Cluster-Ressourcen.

**Wie kann ich Fehler bei der REST-API beheben?**  
+ **Probleme mit der Netzwerkkonnektivität**

  Wenn Sie den API-Endpunkt nicht erreichen können, werden bei HTTP-Anfragen an den Cluster-Controller Verbindungstimeouts oder Fehler „Verbindung verweigert“ angezeigt.

  **Was zu tun** ist: Stellen Sie sicher, dass sich Ihr Client in derselben VPC befindet oder über ein ordnungsgemäßes Netzwerk-Routing verfügt, und stellen Sie sicher, dass Ihre Sicherheitsgruppe HTTP-Verkehr auf Port 6820 von Ihrer Quell-IP oder Ihrem Quellsubnetz zulässt.
+ **Probleme mit der Slurm-REST-Authentifizierung**

  Wenn Ihr JWT-Token ungültig, abgelaufen oder falsch signiert ist, geben API-Anfragen im Fehlerfeld der Antwort „Protokollauthentifizierungsfehler“ zurück.

  Beispiel für eine Fehlermeldung:

  ```
  {
  "errors": [
      {
      "description": "Batch job submission failed",
      "error_number": 1007,
      "error": "Protocol authentication error",
      "source": "slurm_submit_batch_job()"
      }
    ]
  }
  ```

  **Was zu tun ist: Vergewissern** Sie sich, dass Ihr JWT-Token richtig formatiert, nicht abgelaufen und mit dem richtigen Schlüssel von Secrets Manager signiert ist. Stellen Sie sicher, dass das Token korrekt formatiert ist und die erforderlichen Ansprüche enthält und dass Sie das richtige Authentifizierungs-Header-Format verwenden.
+ **Job kann nach dem Absenden nicht ausgeführt werden**

  Wenn Ihr JWT-Token gültig ist, aber eine falsche interne Struktur oder einen falschen Inhalt enthält, sind Jobs möglicherweise in den Status pausiert (`PD`) mit einem Ursachencode übergegangen. `JobAdminHead` Verwenden Sie`scontrol show job <job-id>`, um den Job zu überprüfen — Sie werden sehen`JobState=PENDING, Reason=JobHeldAdmin`, und. `SystemComment=slurm_cred_create failure, holding job`

  **Was zu tun** ist: Die Hauptursache können falsche Werte in JWT sein. Stellen Sie sicher, dass das Token ordnungsgemäß strukturiert ist und die erforderlichen Ansprüche gemäß der PCS-Dokumentation enthält.
+ **Probleme mit Zugriffsrechten für Arbeitsverzeichnisse**

  Wenn die in Ihrem JWT angegebene Benutzeridentität keine Schreibberechtigungen für das Arbeitsverzeichnis des Jobs hat, schlägt der Job mit Berechtigungsfehlern fehl, ähnlich wie bei der Verwendung `sbatch --chdir` mit einem Verzeichnis, auf das nicht zugegriffen werden kann.

  **Was zu tun** ist: Stellen Sie sicher, dass der in Ihrem JWT-Token angegebene Benutzer über die entsprechenden Berechtigungen für das Arbeitsverzeichnis des Jobs verfügt.