Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Authentification avec l'API REST de Slurm sur PCS AWS
L'API REST de Slurm dans AWS PCS utilise l'authentification JSON Web Token (JWT) pour garantir un accès sécurisé aux ressources de votre cluster. AWS PCS fournit une clé de signature gérée stockée dans AWS Secrets Manager, que vous utilisez pour générer des jetons JWT contenant des revendications d'identité utilisateur spécifiques.
## Conditions préalables
Avant de vous authentifier avec l'API REST de Slurm, assurez-vous d'avoir :
+ **Configuration du cluster** : cluster AWS PCS avec Slurm 25.05\$1 et API REST activée.
+ **Autorisations AWS** : accès à AWS Secrets Manager pour la clé de signature JWT.
+ **Informations utilisateur** : nom d'utilisateur, ID utilisateur POSIX et un ou plusieurs groupes POSIX IDs pour votre compte de cluster.
+ **Accès réseau** : connectivité au sein du VPC de votre cluster avec le groupe de sécurité autorisant le port 6820.
## Procédure
**Pour récupérer l'adresse du point de terminaison de l'API REST Slurm**
------
#### [ AWS Management Console ]
1. Ouvrez la console AWS PCS à l'adresse [https://console.aws.amazon.com/pcs/](https://console.aws.amazon.com/pcs/).
1. Choisissez votre cluster dans la liste.
1. Dans les détails de configuration du cluster, recherchez la section **Endpoints**.
1. Notez l'adresse IP privée et le port de l'**API REST de Slurm (slurmrestd**).
1. Vous pouvez effectuer des appels d'API en envoyant des requêtes HTTP correctement formatées à cette adresse.
------
#### [ AWS CLI ]
1. Demandez l'état de votre cluster avec`aws pcs get-cluster`. Recherchez le `SLURMRESTD` point final dans le `endpoints` champ de la réponse. Voici un exemple :
```
"endpoints": [
{
"type": "SLURMCTLD",
"privateIpAddress": "192.0.2.1",
"port": "6817"
},
{
"type": "SLURMRESTD",
"privateIpAddress": "192.0.2.1",
"port": "6820"
}
]
```
1. Vous pouvez effectuer des appels d'API en envoyant des requêtes HTTP correctement formatées à `http://:/`
------
**Pour récupérer la clé de signature JWT**
1. Ouvrez la console AWS PCS à l'adresse [https://console.aws.amazon.com/pcs/](https://console.aws.amazon.com/pcs/).
1. Choisissez votre cluster dans la liste.
1. Dans les détails de configuration du cluster, recherchez la section **Authentification du planificateur**.
1. Notez l'ARN et la version de la **clé JSON Web Token (JWT)**.
1. Utilisez le AWS CLI pour récupérer la clé de signature depuis Secrets Manager :
```
aws secretsmanager get-secret-value --secret-id arn:aws:secretsmanager:region:account:secret:name --version-id version
```
**Pour générer un jeton JWT**
1. Créez un JWT avec les revendications requises suivantes :
+ `exp`— Délai d'expiration en secondes depuis 1970 pour le JWT
+ `iat`— Heure actuelle en secondes depuis 1970
+ `sun`— Le nom d'utilisateur pour l'authentification
+ `uid`— L'ID utilisateur POSIX
+ `gid`— L'identifiant du groupe POSIX
+ `id`— Propriétés d'identité POSIX supplémentaires
+ `gecos`— Champ de commentaire utilisateur, souvent utilisé pour stocker un nom lisible par l'homme
+ `dir`— Répertoire personnel de l'utilisateur
+ `shell`— Shell par défaut de l'utilisateur
+ `gids`— Liste des groupes POSIX supplémentaires auxquels IDs appartient l'utilisateur
1. Signez le JWT à l'aide de la clé de signature récupérée dans Secrets Manager.
1. Définissez une date d'expiration appropriée pour le jeton.
**Note**
Comme alternative à la `sun` réclamation, vous pouvez fournir l'un des documents suivants :
`username`
Un nom de champ personnalisé que vous définissez via `userclaimfield` le `AuthAltParameters Slurm custom settings`
Un `name` champ dans la `id` réclamation
**Pour authentifier les demandes d'API**
1. Incluez le jeton JWT dans vos requêtes HTTP en utilisant l'une des méthodes suivantes :
+ **jeton porteur** — Ajouter un en-tête `Authorization: Bearer `
+ En-tête **Slurm — Ajouter un en-tête** `X-SLURM-USER-TOKEN: `
1. Envoyez des requêtes HTTP au point de terminaison de l'API REST :
Voici un exemple d'accès à l'`/ping`API à l'aide de curl et de l'`Authorized: Bearer`en-tête.
```
curl -X GET -H "Authorization: Bearer " \
http://:6820/slurm/v0.0.43/ping
```
## Exemple de génération JWT
Récupérez la clé de signature JWT du cluster AWS PCS et stockez-la dans un fichier local. Remplacez les valeurs pour **aws-region****,** secret-arn **et secret** version par des valeurs adaptées à votre cluster.
```
#!/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
```
Cet exemple Python illustre comment utiliser la clé de signature pour générer un jeton JWT :
```
#!/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)
```
Le script imprimera un JWT à l'écran.
```
abcdefgtjwttoken...
```