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.
# Authentifizierung mit der Slurm-REST-API in PCS AWS
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
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
**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://:/`
------
**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 `
+ **Slurm-Header — Header** hinzufügen `X-SLURM-USER-TOKEN: `
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 " \
http://:6820/slurm/v0.0.43/ping
```
## Beispiel für eine JWT-Generierung
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...
```