Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Tutorial su come usare AWS ParallelCluster
I seguenti tutorial mostrano come iniziare a usare la AWS ParallelCluster versione 3 e forniscono indicazioni sulle migliori pratiche per alcune attività comuni.
Quando si utilizza l'interfaccia a riga di AWS ParallelCluster comando (CLI) o l'API, si pagano solo le AWS risorse create quando si creano o si aggiornano AWS ParallelCluster immagini e cluster. Per ulteriori informazioni, consulta [AWS servizi usati da AWS ParallelCluster](aws-services-v3.md).
**Topics**
+ [
# Esecuzione del tuo primo lavoro su AWS ParallelCluster
](tutorials-running-your-first-job-on-version-3.md)
+ [
# Creazione di un' AWS ParallelCluster AMI personalizzata
](building-custom-ami-v3.md)
+ [
# Integrazione di Active Directory
](tutorials_05_multi-user-ad.md)
+ [
# Configurazione della crittografia dello storage condiviso con una chiave AWS KMS
](tutorials_04_encrypted_kms_fs-v3.md)
+ [
# Esecuzione di processi in un cluster in modalità coda multipla
](multi-queue-tutorial-v3.md)
+ [
# Utilizzo dell' AWS ParallelCluster API
](tutorials_06_API_use.md)
+ [
# Creazione di un cluster con Slurm contabilità
](tutorials_07_slurm-accounting-v3.md)
+ [
# Creazione di un cluster con un cluster esterno Slurmdbd contabilità
](external-slurmdb-accounting.md)
+ [
# Ripristino a una versione precedente del documento AWS Systems Manager
](tutorials_08_ssm-document-version-rev-v3.md)
+ [
# Creazione di un cluster con CloudFormation
](tutorials_09_cfn-custom-resource-v3.md)
+ [
# Implementa l' ParallelCluster API con Terraform
](tutorial-deploy-terraform.md)
+ [
# Creare un cluster con Terraform
](tutorial-create-cluster-terraform.md)
+ [
# Creazione di un'AMI personalizzata con Terraform
](tutorial-create-ami-terraform.md)
+ [
# AWS ParallelCluster Integrazione dell'interfaccia utente con Identity Center
](tutorials_10_pcui-aws-ic-integration-v3.md)
+ [Esecuzione di lavori containerizzati con Pyxis](tutorials_11_running-containerized-jobs-with-pyxis.md)
+ [
# Creazione di un cluster con un Lustre abilitato per EFA FSx
](tutorial-efa-enabled-fsx-lustre.md)
+ [
# Supporta Nvidia-IMEX con istanza p6e-gb200
](support-nvidia-imex-p6e-gb200-instance.md)
+ [
# Personalizza le interfacce di rete dei nodi di calcolo con sostituzioni dei modelli di avvio
](tutorial-network-customization-v3.md)
# Esecuzione del tuo primo lavoro su AWS ParallelCluster
Questo tutorial ti spiega come eseguire il tuo primo lavoro in Hello World su AWS ParallelCluster
Quando si utilizza l'interfaccia a riga di AWS ParallelCluster comando (CLI) o l'API, si pagano solo le AWS risorse create quando si creano o si aggiornano AWS ParallelCluster immagini e cluster. Per ulteriori informazioni, consulta [AWS servizi usati da AWS ParallelCluster](aws-services-v3.md).
**Prerequisiti**
+ AWS ParallelCluster [è](install-v3-parallelcluster.md) installato.
+ AWS CLI [è installato e configurato.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Hai una coppia di [chiavi Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Hai un ruolo IAM con le [autorizzazioni](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) necessarie per eseguire la [`pcluster`](pcluster-v3.md) CLI.
## Verifica dell'installazione
Innanzitutto, verifichiamo che AWS ParallelCluster sia installato e configurato correttamente, inclusa la dipendenza Node.js.
```
$ node --version
v16.8.0
$ pcluster version
{
"version": "3.15.0"
}
```
Ciò restituisce la versione in esecuzione di. AWS ParallelCluster
## Creazione del primo cluster
Verrà ora creato il tuo primo cluster. Poiché il carico di lavoro per questo tutorial non ha elevati requisiti di prestazioni, possiamo utilizzare la dimensione dell'istanza predefinita di `t2.micro`. (Per carichi di lavoro di produzione, scegli la dimensione dell’istanza più adatta alle tue esigenze.) Chiamiamo il tuo cluster`hello-world`.
```
$ pcluster create-cluster \
--cluster-name hello-world \
--cluster-configuration hello-world.yaml
```
**Nota**
La modalità Regione AWS di utilizzo deve essere specificata per la maggior parte dei `pcluster` comandi. Se non è specificato nella variabile di `AWS_DEFAULT_REGION` ambiente o nell'`region`impostazione nella `[default]` sezione del `~/.aws/config` file, il `--region` parametro deve essere fornito nella riga di `pcluster` comando.
Se l'output mostra un messaggio sulla configurazione, devi eseguire quanto segue per configurare AWS ParallelCluster:
```
$ pcluster configure --config hello-world.yaml
```
Se il [`pcluster create-cluster`](pcluster.create-cluster-v3.md) comando ha esito positivo, viene visualizzato un output simile al seguente:
```
{
"cluster": {
"clusterName": "hello-world",
"cloudformationStackStatus": "CREATE_IN_PROGRESS",
"cloudformationStackArn": "arn:aws:cloudformation:xxx:stack/xxx",
"region": "...",
"version": "...",
"clusterStatus": "CREATE_IN_PROGRESS"
}
}
```
È possibile monitorare la creazione del cluster utilizzando:
```
$ pcluster describe-cluster --cluster-name hello-world
```
I `clusterStatus` report "`CREATE_IN_PROGRESS`" durante la creazione del cluster. Le `clusterStatus` transizioni a "`CREATE_COMPLETE`" quando il cluster viene creato correttamente. L'output ci fornisce anche la fine `privateIpAddress` del `publicIpAddress` nostro nodo principale.
## Accedere al nodo principale
Usa il tuo file pem OpenSSH per accedere al tuo nodo principale.
```
$ pcluster ssh --cluster-name hello-world -i /path/to/keyfile.pem
```
Dopo aver effettuato l'accesso, esegui il comando `sinfo` per verificare che i nodi di calcolo siano impostati e configurati.
```
$ sinfo
PARTITION AVAIL TIMELIMIT NODES STATE NODELIST
queue1* up infinite 10 idle~ queue1-dy-queue1t2micro-[1-10]
```
L'output mostra che abbiamo una coda nel nostro cluster, con un massimo di dieci nodi.
## Esecuzione del primo lavoro con Slurm
Creiamo un processo che rimane in sospeso per alcuni secondi e che quindi fornisce in uscita il suo nome host. Crea un file denominato `hellojob.sh`, con i seguenti contenuti:
```
#!/bin/bash
sleep 30
echo "Hello World from $(hostname)"
```
Quindi, invia il processo utilizzando `sbatch` e verifica che sia in esecuzione.
```
$ sbatch hellojob.sh
Submitted batch job 2
```
Puoi ora visualizzare la coda e verificare lo stato del processo. Il provisioning di una nuova istanza Amazon EC2 viene avviato in background. Puoi monitorare lo stato delle istanze del cluster con il comando. `sinfo`
```
$ squeue
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)
2 queue1 hellojob ec2-user CF 3:30 1 queue1-dy-queue1t2micro-1
```
L'output mostra che il lavoro è stato inviato a`queue1`. Attendi 30 secondi per il completamento del processo, quindi esegui nuovamente `squeue`.
```
$ squeue
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)
```
Ora che non ci sono processi in coda, puoi verificare l'output nella directory corrente.
```
$ ls -l
total 8
-rw-rw-r-- 1 ec2-user ec2-user 57 Sep 1 14:25 hellojob.sh
-rw-rw-r-- 1 ec2-user ec2-user 43 Sep 1 14:30 slurm-2.out
```
Nell'output, vediamo un file `out` "». Possiamo vedere il risultato del nostro lavoro:
```
$ cat slurm-2.out
Hello World from queue1-dy-queue1t2micro-1
```
L'output mostra anche che il processo è stato eseguito correttamente sull'istanza `queue1-dy-queue1t2micro-1`.
Nel cluster appena creato, solo la home directory è condivisa tra tutti i nodi del cluster.
Per ulteriori informazioni sulla creazione e l'utilizzo dei cluster, consulta[Best practice](best-practices-v3.md).
Se l'applicazione richiede software, librerie o dati condivisi, considera le seguenti opzioni:
+ Crea un'AMI personalizzata AWS ParallelCluster abilitata che includa il tuo software come descritto in[Creazione di un' AWS ParallelCluster AMI personalizzata](building-custom-ami-v3.md).
+ Utilizzate l'[StorageSettings](SharedStorage-v3.md)opzione nel file di AWS ParallelCluster configurazione per specificare un file system condiviso e archiviate il software installato nella posizione di montaggio specificata.
+ [Azioni bootstrap personalizzate](custom-bootstrap-actions-v3.md)Utilizzatelo per automatizzare la procedura di bootstrap di ogni nodo del cluster.
# Creazione di un' AWS ParallelCluster AMI personalizzata
Quando si utilizza l'interfaccia a riga di AWS ParallelCluster comando (CLI) o l'API, si pagano solo le AWS risorse create quando si creano o si aggiornano AWS ParallelCluster immagini e cluster. Per ulteriori informazioni, consulta [AWS servizi usati da AWS ParallelCluster](aws-services-v3.md).
**Importante**
Se crei un'AMI personalizzata, devi ripetere i passaggi utilizzati per creare l'AMI personalizzata con ogni nuova AWS ParallelCluster versione.
Prima di continuare a leggere, ti consigliamo di rivedere prima la [Azioni bootstrap personalizzate](custom-bootstrap-actions-v3.md) sezione. Determina se le modifiche che desideri apportare possono essere scritte e supportate nelle versioni future AWS ParallelCluster .
Anche se la creazione di un'AMI personalizzata in generale non è l'ideale, esistono scenari specifici in cui AWS ParallelCluster è necessario creare un'AMI personalizzata per. Questo tutorial spiega come creare un'AMI personalizzata per questi scenari.
**Prerequisiti**
+ AWS ParallelCluster [è installato](install-v3-parallelcluster.md).
+ AWS CLI [è installato e configurato.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Hai una coppia di [chiavi Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Hai un ruolo IAM con le [autorizzazioni](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) necessarie per eseguire la [`pcluster`](pcluster-v3.md) CLI e creare immagini.
## Come personalizzare l' AWS ParallelCluster AMI
Esistono due modi per creare un' AWS ParallelCluster AMI personalizzata. Uno di questi due metodi consiste nel creare una nuova AMI utilizzando la AWS ParallelCluster CLI. Un altro metodo richiede di apportare modifiche manuali per creare una nuova AMI disponibile con il tuo Account AWS.
## Crea un' AWS ParallelCluster AMI personalizzata
Se disponi di un'AMI e di un software personalizzati, puoi aggiungere AWS ParallelCluster le modifiche necessarie. AWS ParallelCluster si affida al servizio EC2 Image Builder per creare progetti personalizzati. AMIs Per ulteriori informazioni, consultare la Guida per l'[utente di Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/what-is-image-builder.html).
Punti chiave:
+ Il processo dura circa 1 ora. Questo tempo può variare se ci sono altri [`Build`](Build-v3.md)/[`Components`](Build-v3.md#Build-v3-Components)da installare in fase di compilazione.
+ L'AMI è contrassegnata con le versioni dei componenti principali. Questi includono il kernel, lo scheduler e il driver [EFA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html). Un sottoinsieme delle versioni dei componenti è riportato anche nella descrizione dell'AMI.
+ A partire dalla AWS ParallelCluster versione 3.0.0, è possibile utilizzare un nuovo set di comandi CLI per gestire il ciclo di vita delle immagini. Sono inclusi [`build-image`](pcluster.build-image-v3.md), [`list-images`](pcluster.list-images-v3.md), [`describe-image`](pcluster.describe-image-v3.md) e [`delete-image`](pcluster.delete-image-v3.md).
+ Questo metodo è ripetibile. È possibile rieseguirlo per rimanere AMIs aggiornato (ad esempio, aggiornamenti del sistema operativo) e quindi utilizzarlo quando si aggiorna un cluster esistente.
**Nota**
Se si utilizza questo metodo nella partizione AWS cinese, è possibile che si verifichino errori di rete. Ad esempio, potresti visualizzare questi errori nel `pcluster build-image` comando quando scarica pacchetti da GitHub o da un archivio del sistema operativo. In tal caso, ti consigliamo di utilizzare uno dei seguenti metodi alternativi:
Segui l'[Modificare un AWS ParallelCluster AMI](#modify-an-aws-parallelcluster-ami-v3)approccio che ignora questo comando.
Crea l'immagine in un'altra partizione e regione, ad esempio`us-east-1`, e poi store/restore spostala nella regione della Cina. Per ulteriori informazioni, consulta [Archiviazione e ripristino di un’AMI utilizzando S3](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-store-restore.html) nella *Guida per l’utente di Amazon EC2*.
Fasi:
1. Configura Account AWS le tue credenziali in modo che il AWS ParallelCluster client possa effettuare chiamate alle operazioni AWS API per tuo conto. Per un elenco delle autorizzazioni richieste, consulta [AWS Identity and Access Management autorizzazioni in AWS ParallelCluster](iam-roles-in-parallelcluster-v3.md).
1. Crea un file di configurazione *dell'immagine di build* di base. Per fare ciò, specifica il [`InstanceType`](Build-v3.md#yaml-build-image-Build-InstanceType)file da utilizzare per creare l'immagine e il [`ParentImage`](Build-v3.md#yaml-build-image-Build-ParentImage). Questi vengono utilizzati come punto di partenza per creare l'AMI. Per ulteriori informazioni sui parametri di compilazione opzionali, consulta [Image Configuration](image-builder-configuration-file-v3.md).
```
Build:
InstanceType:
ParentImage:
```
1. Usa il comando CLI [`pcluster build-image`](pcluster.build-image-v3.md)per creare un' AWS ParallelCluster AMI a partire dall'AMI che fornisci come base.
```
$ pcluster build-image --image-id IMAGE_ID --image-configuration IMAGE_CONFIG.yaml --region REGION
{
"image": {
"imageId": "IMAGE_ID",
"imageBuildStatus": "BUILD_IN_PROGRESS",
"cloudformationStackStatus": "CREATE_IN_PROGRESS",
"cloudformationStackArn": "arn:aws:cloudformation:us-east-1:123456789012:stack/IMAGE_ID/abcd1234-ef56-gh78-ij90-1234abcd5678",
"region": "us-east-1",
"version": "3.15.0"
}
}
```
**avvertimento**
`pcluster build-image`utilizza il VPC predefinito. Se elimini il VPC predefinito utilizzando AWS Control Tower o AWS Landing Zone, l'ID della sottorete deve essere specificato nel file di configurazione dell'immagine. Per ulteriori informazioni, consulta [`SubnetId`](HeadNode-v3.md#yaml-HeadNode-Networking-SubnetId).
Per un elenco di altri parametri, consulta la pagina di riferimento dei [`pcluster build-image`](pcluster.build-image-v3.md)comandi. I risultati del comando precedente sono i seguenti:
+ Viene creato uno CloudFormation stack in base alla configurazione dell'immagine. Lo stack include tutte le risorse EC2 Image Builder necessarie per la compilazione.
+ Le risorse create includono i componenti ufficiali di Image Builder a cui è possibile aggiungere AWS ParallelCluster componenti Image Builder personalizzati. Per ulteriori informazioni, consulta [Creare un componente personalizzato con Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/create-component.html) nella Guida per l'utente di *EC2 Image Builder*.
+ EC2 Image Builder avvia un'istanza di build, AWS ParallelCluster applica il ricettario, AWS ParallelCluster installa lo stack software ed esegue le attività di configurazione necessarie. Il AWS ParallelCluster ricettario viene utilizzato per creare e avviare. AWS ParallelCluster
+ L'istanza viene interrotta e da essa viene creata una nuova AMI.
+ Un'altra istanza viene lanciata dall'AMI appena creata. Durante la fase di test, EC2 Image Builder esegue test definiti nei componenti di Image Builder.
+ Se la compilazione ha esito positivo, lo stack viene eliminato. Se la compilazione fallisce, lo stack viene mantenuto e disponibile per l'ispezione.
1. È possibile monitorare lo stato del processo di compilazione eseguendo il comando seguente. Una volta completata la build, puoi eseguirla per recuperare l'ID AMI fornito nella risposta.
```
$ pcluster describe-image --image-id IMAGE_ID --region REGION
# BEFORE COMPLETE
{
"imageConfiguration": {
"url": "https://parallelcluster-1234abcd5678efgh-v1-do-not-delete.s3.amazonaws.com/parallelcluster/3.15.0/images/IMAGE_ID-abcd1234efgh5678/configs/image-config.yaml?...",
},
"imageId": "IMAGE_ID",
"imagebuilderImageStatus": "BUILDING",
"imageBuildStatus": "BUILD_IN_PROGRESS",
"cloudformationStackStatus": "CREATE_IN_PROGRESS",
"cloudformationStackArn": "arn:aws:cloudformation:us-east-1:123456789012:stack/IMAGE_ID/abcd1234-ef56-gh78-ij90-1234abcd5678",
"region": "us-east-1",
"version": "3.15.0",
"cloudformationStackTags": [
{
"value": "3.15.0",
"key": "parallelcluster:version"
},
{
"value": "IMAGE_ID",
"key": "parallelcluster:image_name"
},
...
],
"imageBuildLogsArn": "arn:aws:logs:us-east-1:123456789012:log-group:/aws/imagebuilder/ParallelClusterImage-IMAGE_ID",
"cloudformationStackCreationTime": "2022-04-05T21:36:26.176Z"
}
# AFTER COMPLETE
{
"imageConfiguration": {
"url": "https://parallelcluster-1234abcd5678efgh-v1-do-not-delete.s3.us-east-1.amazonaws.com/parallelcluster/3.15.0/images/IMAGE_ID-abcd1234efgh5678/configs/image-config.yaml?Signature=..."
},
"imageId": "IMAGE_ID",
"imageBuildStatus": "BUILD_COMPLETE",
"region": "us-east-1",
"ec2AmiInfo": {
"amiName": "IMAGE_ID 2022-04-05T21-39-24.020Z",
"amiId": "ami-1234stuv5678wxyz",
"description": "AWS ParallelCluster AMI for alinux2, kernel-4.14.238-182.422.amzn2.x86_64, lustre-2.10.8-5.amzn2.x86_64, efa-1.13.0-1.amzn2.x86_64, dcv-2021.1.10598-1.el7.x86_64, slurm-20-11-8-1",
"state": "AVAILABLE",
"tags": [
{
"value": "2021.3.11591-1.el7.x86_64",
"key": "parallelcluster:dcv_version"
},
...
],
"architecture": "x86_64"
},
"version": "3.15.0"
}
```
1. Per creare il tuo cluster, inserisci l'ID AMI nel [`CustomAmi`](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-Image-CustomAmi)campo della configurazione del cluster.
**Risoluzione dei problemi e monitoraggio del processo di creazione di AMI**
La creazione dell'immagine viene completata in circa un'ora. È possibile monitorare il processo eseguendo il [`pcluster describe-image`](pcluster.describe-image-v3.md)comando o i comandi di recupero del registro.
```
$ pcluster describe-image --image-id IMAGE_ID --region REGION
```
Il [`build-image`](pcluster.build-image-v3.md)comando crea uno CloudFormation stack con tutte le risorse Amazon EC2 necessarie per creare l'immagine e avvia il processo EC2 Image Builder.
Dopo aver eseguito il [`build-image`](pcluster.build-image-v3.md)comando, è possibile recuperare CloudFormation gli eventi dello stack utilizzando. [`pcluster get-image-stack-events`](pcluster.get-image-stack-events-v3.md) Puoi filtrare i risultati con il `--query` parametro per vedere gli ultimi eventi. Per ulteriori informazioni, consulta [Filtraggio dell' AWS CLI output](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-filter.html) nella *Guida per l'AWS Command Line Interface utente*.
```
$ pcluster get-image-stack-events --image-id IMAGE_ID --region REGION --query "events[0]"
{
"eventId": "ParallelClusterImage-CREATE_IN_PROGRESS-2022-04-05T21:39:24.725Z",
"physicalResourceId": "arn:aws:imagebuilder:us-east-1:123456789012:image/parallelclusterimage-IMAGE_ID/3.15.0/1",
"resourceStatus": "CREATE_IN_PROGRESS",
"resourceStatusReason": "Resource creation Initiated",
"resourceProperties": "{\"InfrastructureConfigurationArn\":\"arn:aws:imagebuilder:us-east-1:123456789012:infrastructure-configuration/parallelclusterimage-abcd1234-ef56-gh78-ij90-1234abcd5678\",\"ImageRecipeArn\":\"arn:aws:imagebuilder:us-east-1:123456789012:image-recipe/parallelclusterimage-IMAGE_ID/3.15.0\",\"DistributionConfigurationArn\":\"arn:aws:imagebuilder:us-east-1:123456789012:distribution-configuration/parallelclusterimage-abcd1234-ef56-gh78-ij90-1234abcd5678\",\"Tags\":{\"parallelcluster:image_name\":\"IMAGE_ID\",\"parallelcluster:image_id\":\"IMAGE_ID\"}}",
"stackId": "arn:aws:cloudformation:us-east-1:123456789012:stack/IMAGE_ID/abcd1234-ef56-gh78-ij90-1234abcd5678",
"stackName": "IMAGE_ID",
"logicalResourceId": "ParallelClusterImage",
"resourceType": "AWS::ImageBuilder::Image",
"timestamp": "2022-04-05T21:39:24.725Z"
}
```
Dopo circa 15 minuti, gli eventi dello stack vengono visualizzati nella voce degli eventi di registro relativa alla creazione di Image Builder. È ora possibile elencare i flussi di log delle immagini e monitorare i passaggi di Image Builder [`pcluster list-image-log-streams`](pcluster.list-image-log-streams-v3.md)utilizzando [`pcluster get-image-log-events`](pcluster.get-image-log-events-v3.md)i comandi and.
```
$ pcluster list-image-log-streams --image-id IMAGE_ID --region REGION \
--query 'logStreams[*].logStreamName'
"3.15.0/1"
]
$ pcluster get-image-log-events --image-id IMAGE_ID --region REGION \
--log-stream-name 3.15.0/1 --limit 3
{
"nextToken": "f/36295977202298886557255241372854078762600452615936671762",
"prevToken": "b/36295977196879805474012299949460899222346900769983430672",
"events": [
{
"message": "ExecuteBash: FINISHED EXECUTION",
"timestamp": "2022-04-05T22:13:26.633Z"
},
{
"message": "Document arn:aws:imagebuilder:us-east-1:123456789012:component/parallelclusterimage-test-abcd1234-ef56-gh78-ij90-1234abcd5678/3.15.0/1",
"timestamp": "2022-04-05T22:13:26.741Z"
},
{
"message": "TOE has completed execution successfully",
"timestamp": "2022-04-05T22:13:26.819Z"
}
]
}
```
Continuate a controllare con il [`describe-image`](pcluster.describe-image-v3.md)comando finché non ne vedete lo stato. `BUILD_COMPLETE`
```
$ pcluster describe-image --image-id IMAGE_ID --region REGION
{
"imageConfiguration": {
"url": "https://parallelcluster-1234abcd5678efgh-v1-do-not-delete.s3.us-east-1.amazonaws.com/parallelcluster/3.15.0/images/IMAGE_ID-abcd1234efgh5678/configs/image-config.yaml?Signature=..."
},
"imageId": "IMAGE_ID",
"imageBuildStatus": "BUILD_COMPLETE",
"region": "us-east-1",
"ec2AmiInfo": {
"amiName": "IMAGE_ID 2022-04-05T21-39-24.020Z",
"amiId": "ami-1234stuv5678wxyz",
"description": "AWS ParallelCluster AMI for alinux2, kernel-4.14.238-182.422.amzn2.x86_64, lustre-2.10.8-5.amzn2.x86_64, efa-1.13.0-1.amzn2.x86_64, dcv-2021.1.10598-1.el7.x86_64, slurm-20-11-8-1",
"state": "AVAILABLE",
"tags": [
{
"value": "2021.3.11591-1.el7.x86_64",
"key": "parallelcluster:dcv_version"
},
...
],
"architecture": "x86_64"
},
"version": "3.15.0"
}
```
Se devi risolvere un problema di creazione di AMI personalizzate, crea un archivio dei log delle immagini come descritto nei passaggi seguenti.
È possibile archiviare i log in un bucket Amazon S3 o in un file locale, a seconda del parametro. `--output`
```
$ pcluster export-image-logs --image-id IMAGE_ID --region REGION \
--bucket BUCKET_NAME --bucket-prefix BUCKET_FOLDER
{
"url": "https://BUCKET_NAME.s3.us-east-1.amazonaws.com/BUCKET-FOLDER/IMAGE_ID-logs-202209071136.tar.gz?AWSAccessKeyId=..."
}
$ pcluster export-image-logs --image-id IMAGE_ID \
--region REGION --bucket BUCKET_NAME --bucket-prefix BUCKET_FOLDER --output-file /tmp/archive.tar.gz
{
"path": "/tmp/archive.tar.gz"
}
```
L'archivio contiene i CloudWatch Logs Streams relativi al processo CloudFormation di Image Builder e agli eventi dello stack. L'esecuzione del comando potrebbe richiedere alcuni minuti.
**Gestione personalizzata AMIs**
A partire dalla AWS ParallelCluster versione 3.0.0, è stato aggiunto un nuovo set di comandi nella CLI per creare, monitorare e gestire il ciclo di vita dell'immagine. [Per ulteriori informazioni sui comandi, consulta i comandi di pcluster.](pcluster-v3.md)
## Modificare un AWS ParallelCluster AMI
Questo metodo consiste nel modificare un' AWS ParallelCluster AMI ufficiale aggiungendovi delle personalizzazioni. La base AWS ParallelCluster AMIs viene aggiornata con nuove versioni. Questi AMIs hanno tutti i componenti necessari AWS ParallelCluster per funzionare una volta installati e configurati. Puoi iniziare con uno di questi come base.
Punti chiave:
+ Questo metodo è più veloce del [`build-image`](pcluster.build-image-v3.md)comando. Tuttavia, si tratta di un processo manuale e non ripetibile automaticamente.
+ Con questo metodo, non è possibile accedere ai comandi di recupero dei log e di gestione del ciclo di vita delle immagini disponibili tramite la CLI.
Fasi:
------
#### [ New Amazon EC2 console ]
1. Trova l'AMI che corrisponde allo specifico Regione AWS che usi. Per trovarlo, usa il [`pcluster list-official-images`](pcluster.list-official-images-v3.md)comando con il `--region` parametro per selezionare i `--architecture` parametri Regione AWS `--os` e i parametri specifici da filtrare per l'AMI desiderata con il sistema operativo e l'architettura che desideri utilizzare. Dall'output, recupera l'ID immagine Amazon EC2.
1. Accedi Console di gestione AWS e apri la console Amazon EC2 all'indirizzo. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. Nel riquadro di navigazione, scegli **Immagini**, quindi **AMIs**. Cerca l'ID immagine EC2 recuperato, seleziona l'AMI e scegli **Launch instance from AMI**.
1. Scorri verso il basso e scegli il tipo di **istanza**.
1. Scegli la tua **coppia di chiavi** e **Launch Instance**.
1. Accedi alla tua istanza utilizzando l'utente del sistema operativo e la tua SSH chiave.
1. Personalizza manualmente l'istanza per soddisfare le tue esigenze.
1. Esegui il comando seguente per preparare l'istanza per la creazione di AMI.
```
sudo /usr/local/sbin/ami_cleanup.sh
```
1. Dalla console, scegli **Instance state** e **Stop instance**.
Passa a **Istanze**, scegli la nuova istanza, seleziona **Stato dell'istanza** e **Arresta istanza**.
1. [Crea una nuova AMI dall'istanza utilizzando la console Amazon EC2 o AWS CLI create-image.](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-image.html)
**Dalla console Amazon EC2**
1. Nel riquadro di navigazione scegliere **Instances (Istanze)**.
1. Scegli l'istanza che hai creato e modificato.
1. In **Azioni**, scegli **Immagine**, quindi **Crea immagine**.
1. Scegliere **Create Image (Crea immagine)**.
1. Inserisci il nuovo ID AMI nel [`CustomAmi`](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-Image-CustomAmi)campo della configurazione del cluster e crea un cluster.
------
#### [ Old Amazon EC2 console ]
1. Trova l' AWS ParallelCluster AMI che corrisponde allo specifico Regione AWS che usi. Per trovarlo puoi usare il [`pcluster list-official-images`](pcluster.list-official-images-v3.md)comando con il `--region` parametro per selezionare i parametri specifici Regione AWS `--os` e `--architecture` i parametri da filtrare per l'AMI desiderata con il sistema operativo e l'architettura che desideri utilizzare. Dall'output puoi recuperare l'ID immagine di Amazon EC2.
1. Accedi Console di gestione AWS e apri la console Amazon EC2 all'indirizzo. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. Nel riquadro di navigazione, scegli **Immagini**, quindi **AMIs**. **Imposta il filtro per **le immagini pubbliche** e cerca l'ID immagine EC2 recuperato, seleziona l'AMI e scegli Avvia.**
1. Scegli il tipo di istanza e seleziona **Avanti: Configura i dettagli dell'istanza** o **Rivedi e avvia per avviare** l'istanza.
1. Scegli **Launch**, seleziona la tua **coppia di chiavi** e **Launch Instances.**
1. Accedere a un'istanza utilizzando l'utente del sistema operativo e la chiave SSH. Per ulteriori informazioni, accedi a **Istanze**, seleziona la nuova istanza e **Connect**.
1. Personalizza manualmente l'istanza per soddisfare le tue esigenze.
1. Eseguire il comando seguente per preparare l'istanza per la creazione di AMI:
```
sudo /usr/local/sbin/ami_cleanup.sh
```
1. **Dalla console Amazon EC2, scegli **Istanze** nel riquadro di navigazione, seleziona la tua nuova istanza e scegli **Actions**, **Instance State** e Stop.**
1. [Crea una nuova AMI dall'istanza utilizzando la console Amazon EC2 o AWS CLI create-image.](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-image.html)
**Dalla console Amazon EC2**
1. Nel riquadro di navigazione scegliere **Instances (Istanze)**.
1. Scegli l'istanza che hai creato e modificato.
1. In **Azioni**, scegliete **Immagine**, quindi **Crea immagine**.
1. Scegliere **Create Image (Crea immagine)**.
1. Inserisci il nuovo ID AMI nel [`CustomAmi`](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-Image-CustomAmi)campo della configurazione del cluster e crea un cluster.
------
# Integrazione di Active Directory
In questo tutorial, crei un ambiente multiutente. Questo ambiente include un AWS ParallelCluster file integrato con un AWS Managed Microsoft AD (Active Directory) in`corp.example.com`. Si configura un `Admin` utente per gestire la directory, un `ReadOnly` utente per leggere la directory e un `user000` utente per accedere al cluster. Puoi utilizzare il percorso automatico o il percorso manuale per creare le risorse di rete, un'Active Directory (AD) e l'istanza Amazon EC2 che usi per configurare l'AD. Indipendentemente dal percorso, l'infrastruttura creata è preconfigurata per AWS ParallelCluster l'integrazione utilizzando uno dei seguenti metodi:
+ LDAPS con verifica del certificato (consigliato come opzione più sicura)
+ LDAPS senza verifica del certificato
+ LDAP
LDAP di per sé *non* fornisce la crittografia. Per garantire la trasmissione sicura di informazioni potenzialmente sensibili, consigliamo vivamente di utilizzare LDAPS (LDAP su TLS/SSL) per i cluster integrati con. ADs *Per ulteriori informazioni, consulta [Abilitare l'utilizzo di LDAPS lato server nella Guida all'](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_ldap_server_side.html)amministrazione. AWS Managed Microsoft AD Directory Service *
Dopo aver creato queste risorse, procedi con la configurazione e la creazione del cluster integrato con Active Directory (AD). Dopo aver creato il cluster, accedi come utente che hai creato. Per ulteriori informazioni sulla configurazione creata in questo tutorial, consulta [Accesso di più utenti ai cluster](multi-user-v3.md) la sezione relativa alla [`DirectoryService`](DirectoryService-v3.md)configurazione.
Questo tutorial spiega come creare un ambiente che supporti l'accesso di più utenti ai cluster. Questo tutorial non spiega come creare e utilizzare un Directory Service AD. I passaggi da seguire per configurarne uno AWS Managed Microsoft AD in questo tutorial sono forniti solo a scopo di test. *Non vengono* forniti per sostituire la documentazione ufficiale e le best practice disponibili in [Simple AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/directory_simple_ad.html) nella *Directory Service Administration Guide*. [AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/directory_microsoft_ad.html)
**Nota**
Le password degli utenti delle directory scadono in base alle definizioni delle proprietà delle policy relative alle password delle directory. Per reimpostare le password delle directory con AWS ParallelCluster, vedere. [Come reimpostare una password utente e le password scadute](troubleshooting-v3-multi-user.md#troubleshooting-v3-multi-user-reset-passwd)
**Nota**
Gli indirizzi IP dei controller di dominio delle directory possono cambiare a causa delle modifiche dei controller di dominio e della manutenzione delle directory. Se si è scelto il metodo di creazione rapida automatizzata per creare l'infrastruttura di directory, è necessario allineare manualmente il sistema di bilanciamento del carico davanti ai controller delle directory quando gli indirizzi IP delle directory cambiano. Se si utilizza il metodo di creazione rapida, gli indirizzi IP delle directory non vengono allineati automaticamente ai sistemi di bilanciamento del carico.
Quando si utilizza l'interfaccia a riga di AWS ParallelCluster comando (CLI) o l'API, si pagano solo le AWS risorse create quando si creano o si aggiornano AWS ParallelCluster immagini e cluster. Per ulteriori informazioni, consulta [AWS servizi usati da AWS ParallelCluster](aws-services-v3.md).
**Prerequisiti**
+ AWS ParallelCluster [è](install-v3-parallelcluster.md) installato.
+ AWS CLI [è installato e configurato.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Hai una coppia di [chiavi Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Hai un ruolo IAM con le [autorizzazioni](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) necessarie per eseguire la [`pcluster`](pcluster-v3.md) CLI.
Man mano che segui il tutorial, sostituisci`inputs highlighted in red`, ad esempio `region-id` e`d-abcdef01234567890`, con i tuoi nomi e. IDs Sostituisci `0123456789012` con il tuo Account AWS numero.
# Crea l'infrastruttura AD
Scegli la scheda *Automatizzata* per creare l'infrastruttura Active Directory (AD) con un modello di creazione CloudFormation rapida.
Scegli la scheda *Manuale* per creare manualmente l'infrastruttura AD.
## Automatizzata
1. Accedi alla Console di gestione AWS.
1. Apri [CloudFormation Quick Create (region us-east-1](https://us-east-1.console.aws.amazon.com/cloudformation/home?region=us-east-1#/stacks/create/review?stackName=pcluster-ad&templateURL=https://us-east-1-aws-parallelcluster.s3.amazonaws.com/templates/1-click/ad-integration.yaml)) per creare le seguenti risorse nella console: CloudFormation
+ Un VPC con due sottoreti e routing per l'accesso pubblico, se non viene specificato alcun VPC.
+ Un AWS Managed Microsoft AD.
+ Un'istanza Amazon EC2 aggiunta all'AD che puoi utilizzare per gestire la directory.
1. Nella sezione **Parametri della pagina **Quick create stack**, inserisci le password per i seguenti parametri**:
+ **AdminPassword**
+ **ReadOnlyPassword**
+ **UserPassword**
Prendi nota delle password. Le userai più avanti in questo tutorial.
1. In **DomainName**, immetti **corp.example.com**.
1. Per **Keypair**, inserisci il nome di una coppia di chiavi Amazon EC2.
1. Seleziona le caselle per confermare ciascuna delle funzionalità di accesso nella parte inferiore della pagina.
1. Seleziona **Crea stack**.
1. Dopo che lo CloudFormation stack ha raggiunto lo `CREATE_COMPLETE` stato, scegli la scheda **Output** dello stack. Prendi nota dei nomi delle risorse di output e IDs perché devi usarli nei passaggi successivi. Gli output forniscono le informazioni necessarie per creare il cluster.
![\[Un diagramma che mostra gli output dello stack creati in. Console di gestione AWS\]](http://docs.aws.amazon.com/it_it/parallelcluster/latest/ug/images/ad-cfn.png)
1. Per completare gli esercizi[(Facoltativo) Gestisci utenti e gruppi AD](tutorials_05_multi-user-ad-step2.md), è necessario l'ID della directory. Scegli **Risorse** e scorri verso il basso per prendere nota dell'ID della directory.
1. Continua su [(Facoltativo) Gestisci utenti e gruppi AD](tutorials_05_multi-user-ad-step2.md) o[Creazione del cluster](tutorials_05_multi-user-ad-step3.md).
## Manuale
Crea un VPC per il servizio di directory con due sottoreti in diverse zone di disponibilità e un. AWS Managed Microsoft AD
### Crea l'AD
**Nota**
La directory e il nome di dominio sono`corp.example.com`. Il nome breve è`CORP`.
Cambia la `Admin` password nello script.
La creazione di Active Directory (AD) richiede almeno 15 minuti.
Usa il seguente script Python per creare il VPC, le sottoreti e le risorse AD nel tuo locale. Regione AWS Salva questo file con nome ed eseguilo`ad.py`.
```
import boto3
import time
from pprint import pprint
vpc_name = "PclusterVPC"
ad_domain = "corp.example.com"
admin_password = "asdfASDF1234"
ec2 = boto3.client("ec2")
ds = boto3.client("ds")
region = boto3.Session().region_name
# Create the VPC, Subnets, IGW, Routes
vpc = ec2.create_vpc(CidrBlock="10.0.0.0/16")["Vpc"]
vpc_id = vpc["VpcId"]
time.sleep(30)
ec2.create_tags(Resources=[vpc_id], Tags=[{"Key": "Name", "Value": vpc_name}])
subnet1 = ec2.create_subnet(VpcId=vpc_id, CidrBlock="10.0.0.0/17", AvailabilityZone=f"{region}a")["Subnet"]
subnet1_id = subnet1["SubnetId"]
time.sleep(30)
ec2.create_tags(Resources=[subnet1_id], Tags=[{"Key": "Name", "Value": f"{vpc_name}/subnet1"}])
ec2.modify_subnet_attribute(SubnetId=subnet1_id, MapPublicIpOnLaunch={"Value": True})
subnet2 = ec2.create_subnet(VpcId=vpc_id, CidrBlock="10.0.128.0/17", AvailabilityZone=f"{region}b")["Subnet"]
subnet2_id = subnet2["SubnetId"]
time.sleep(30)
ec2.create_tags(Resources=[subnet2_id], Tags=[{"Key": "Name", "Value": f"{vpc_name}/subnet2"}])
ec2.modify_subnet_attribute(SubnetId=subnet2_id, MapPublicIpOnLaunch={"Value": True})
igw = ec2.create_internet_gateway()["InternetGateway"]
ec2.attach_internet_gateway(InternetGatewayId=igw["InternetGatewayId"], VpcId=vpc_id)
route_table = ec2.describe_route_tables(Filters=[{"Name": "vpc-id", "Values": [vpc_id]}])["RouteTables"][0]
ec2.create_route(RouteTableId=route_table["RouteTableId"], DestinationCidrBlock="0.0.0.0/0", GatewayId=igw["InternetGatewayId"])
ec2.modify_vpc_attribute(VpcId=vpc_id, EnableDnsSupport={"Value": True})
ec2.modify_vpc_attribute(VpcId=vpc_id, EnableDnsHostnames={"Value": True})
# Create the Active Directory
ad = ds.create_microsoft_ad(
Name=ad_domain,
Password=admin_password,
Description="ParallelCluster AD",
VpcSettings={"VpcId": vpc_id, "SubnetIds": [subnet1_id, subnet2_id]},
Edition="Standard",
)
directory_id = ad["DirectoryId"]
# Wait for completion
print("Waiting for the directory to be created...")
directories = ds.describe_directories(DirectoryIds=[directory_id])["DirectoryDescriptions"]
directory = directories[0]
while directory["Stage"] in {"Requested", "Creating"}:
time.sleep(3)
directories = ds.describe_directories(DirectoryIds=[directory_id])["DirectoryDescriptions"]
directory = directories[0]
dns_ip_addrs = directory["DnsIpAddrs"]
pprint({"directory_id": directory_id,
"vpc_id": vpc_id,
"subnet1_id": subnet1_id,
"subnet2_id": subnet2_id,
"dns_ip_addrs": dns_ip_addrs})
```
Di seguito è riportato un esempio di output dallo script Python.
```
{
"directory_id": "d-abcdef01234567890",
"dns_ip_addrs": ["192.0.2.254", "203.0.113.237"],
"subnet1_id": "subnet-021345abcdef6789",
"subnet2_id": "subnet-1234567890abcdef0",
"vpc_id": "vpc-021345abcdef6789"
}
```
Prendi nota dei nomi delle risorse di output e IDs. Li usi nei passaggi successivi.
Una volta completato lo script, vai al passaggio successivo.
### Creazione di un'istanza Amazon EC2
------
#### [ New Amazon EC2 console ]
1. Accedi alla Console di gestione AWS.
1. Se non hai un ruolo con le politiche elencate nel passaggio 4 allegato, apri la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). Altrimenti, vai al passaggio 5.
1. Crea la `ResetUserPassword` policy, sostituendo il contenuto evidenziato in rosso con il tuo Regione AWS ID, ID account e ID di directory dall'output dello script che hai eseguito per creare l'AD.
ResetUserPassword
```
{
"Statement": [
{
"Action": [
"ds:ResetUserPassword"
],
"Resource": "arn:aws:ds:region-id:123456789012:directory/d-abcdef01234567890",
"Effect": "Allow"
}
]
}
```
1. Crea un ruolo IAM con le seguenti politiche allegate.
+ AWS politica gestita [Amazon SSMManaged InstanceCore](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore)
+ AWS politica gestita [Amazon SSMDirectory ServiceAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSSMDirectoryServiceAccess)
+ ResetUserPassword politica
1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Nella **dashboard di Amazon EC2**, scegli **Launch** Instance.
1. In **Immagini dell'applicazione e del sistema operativo**, seleziona un'AMI Amazon Linux 2 recente.
1. Per **tipo di esempio**, scegli t2.micro.
1. Per **Coppia di chiavi**, scegli una coppia di chiavi.
1. Per **Impostazioni di rete**, scegli **Modifica**.
1. Per **VPC**, seleziona la directory VPC.
1. Scorri verso il basso e seleziona Dettagli **avanzati**.
1. In **Dettagli avanzati**, **Domain join directory**, scegli**corp.example.com**.
1. Per il **profilo IAM Instance**, scegli il ruolo che hai creato nella fase 1 o un ruolo con le policy elencate nel passaggio 4 allegate.
1. In **Riepilogo** scegli **Launch instance**.
1. Prendi nota dell'ID dell'istanza (ad esempio, i-1234567890abcdef0) e attendi che l'istanza finisca di essere avviata.
1. Dopo l'avvio dell'istanza, procedi con il passaggio successivo.
------
#### [ Old Amazon EC2 console ]
1. Accedi alla Console di gestione AWS.
1. Se non ricopri un ruolo con le politiche elencate nel passaggio 4 allegato, apri la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). Altrimenti, vai al passaggio 5.
1. Crea la `ResetUserPassword` politica. Sostituisci il contenuto evidenziato in rosso con il tuo Regione AWS Account AWS ID, ID e l'ID di directory dall'output dello script che hai eseguito per creare Active Directory (AD).
ResetUserPassword
```
{
"Statement": [
{
"Action": [
"ds:ResetUserPassword"
],
"Resource": "arn:aws:ds:region-id:123456789012:directory/d-abcdef01234567890",
"Effect": "Allow"
}
]
}
```
1. Crea un ruolo IAM con le seguenti politiche allegate.
+ AWS politica gestita [Amazon SSMManaged InstanceCore](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore)
+ AWS politica gestita [Amazon SSMDirectory ServiceAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSSMDirectoryServiceAccess)
+ Policy ResetUserPassword
1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Nella **dashboard di Amazon EC2**, scegli **Launch** Instance.
1. In **Immagini dell'applicazione e del sistema operativo**, seleziona un'AMI Amazon Linux 2 recente.
1. In **Instance type (Tipo di istanza)** selezionare t2.micro.
1. Per **Coppia di chiavi**, scegli una coppia di chiavi.
1. In **Impostazioni di rete** scegli **Modifica**.
1. In **Impostazioni di rete**, **VPC**, seleziona la directory VPC.
1. Scorri verso il basso e seleziona Dettagli **avanzati**.
1. In **Dettagli avanzati**, **Domain join directory**, scegli**corp.example.com**.
1. In **Dettagli avanzati**, **Profilo dell'istanza**, scegli il ruolo creato nel passaggio 1 o un ruolo con le politiche elencate nel passaggio 4 allegate.
1. In **Riepilogo** scegli **Launch instance**.
1. Prendi nota dell'ID dell'istanza (ad esempioi-1234567890abcdef0) e attendi che l'istanza finisca di essere avviata.
1. Dopo l'avvio dell'istanza, vai al passaggio successivo.
------
### Unisci la tua istanza all'AD
1.
**Connettiti alla tua istanza e unisciti al regno AD come`admin`.**
Esegui i seguenti comandi per connetterti all'istanza.
```
$ INSTANCE_ID="i-1234567890abcdef0"
```
```
$ PUBLIC_IP=$(aws ec2 describe-instances \
--instance-ids $INSTANCE_ID \
--query "Reservations[0].Instances[0].PublicIpAddress" \
--output text)
```
```
$ ssh -i ~/.ssh/keys/keypair.pem ec2-user@$PUBLIC_IP
```
1.
**Installa il software necessario ed entra a far parte del regno.**
```
$ sudo yum -y install sssd realmd oddjob oddjob-mkhomedir adcli samba-common samba-common-tools krb5-workstation openldap-clients policycoreutils-python
```
1.
**Sostituisci la password dell'amministratore con la tua `admin` password.**
```
$ ADMIN_PW="asdfASDF1234"
```
```
$ echo $ADMIN_PW | sudo realm join -U Admin corp.example.com
Password for Admin:
```
Se la procedura precedente ha avuto successo, sei entrato a far parte del regno e puoi procedere al passaggio successivo.
### Aggiungi utenti all'AD
1.
**Crea il ReadOnlyUser e un altro utente.**
In questo passaggio, si utilizzano gli strumenti [adcli](https://www.mankier.com/package/adcli) e [openldap-clients installati](https://www.mankier.com/package/openldap-clients) in un passaggio precedente.
```
$ echo $ADMIN_PW | adcli create-user -x -U Admin --domain=corp.example.com --display-name=ReadOnlyUser ReadOnlyUser
```
```
$ echo $ADMIN_PW | adcli create-user -x -U Admin --domain=corp.example.com --display-name=user000 user000
```
1. **Verifica che gli utenti siano stati creati:**
Gli indirizzi IP DNS della directory sono output dello script Python.
```
$ DIRECTORY_IP="192.0.2.254"
```
```
$ ldapsearch -x -h $DIRECTORY_IP -D Admin -w $ADMIN_PW -b "cn=ReadOnlyUser,ou=Users,ou=CORP,dc=corp,dc=example,dc=com"
```
```
$ ldapsearch -x -h $DIRECTORY_IP -D Admin -w $ADMIN_PW -b "cn=user000,ou=Users,ou=CORP,dc=corp,dc=example,dc=com"
```
Per impostazione predefinita, quando si crea un utente con`ad-cli`, l'utente è disabilitato.
1.
****Reimposta e attiva le password degli utenti dal computer locale:****
Esci dalla tua istanza Amazon EC2.
**Nota**
`ro-p@ssw0rd`è la password di`ReadOnlyUser`, recuperata da. Gestione dei segreti AWS
`user-p@ssw0rd`è la password di un utente del cluster fornita quando ci si connette (`ssh`) al cluster.
`directory-id`È un output dello script Python.
```
$ DIRECTORY_ID="d-abcdef01234567890"
```
```
$ aws ds reset-user-password \
--directory-id $DIRECTORY_ID \
--user-name "ReadOnlyUser" \
--new-password "ro-p@ssw0rd" \
--region "region-id"
```
```
$ aws ds reset-user-password \
--directory-id $DIRECTORY_ID \
--user-name "user000" \
--new-password "user-p@ssw0rd" \
--region "region-id"
```
1. **Aggiungi la password a un segreto di Secrets Manager.**
Ora che hai creato `ReadOnlyUser` e impostato la password, memorizzala in un luogo segreto da AWS ParallelCluster utilizzare per la convalida degli accessi.
Usa Secrets Manager per creare un nuovo segreto che contenga la password `ReadOnlyUser` come valore. Il formato del valore segreto deve essere solo testo semplice (non in formato JSON). Prendi nota dell'ARN segreto per le fasi future.
```
$ aws secretsmanager create-secret --name "ADSecretPassword" \
--region region_id \
--secret-string "ro-p@ssw0rd" \
--query ARN \
--output text
arn:aws:secretsmanager:region-id:123456789012:secret:ADSecretPassword-1234
```
### Configurazione LDAPS con verifica del certificato (consigliata)
Prendi nota della risorsa IDs. Li usi nei passaggi successivi.
1.
**Genera un certificato di dominio, localmente.**
```
$ PRIVATE_KEY="corp-example-com.key"
CERTIFICATE="corp-example-com.crt"
printf ".\n.\n.\n.\n.\ncorp.example.com\n.\n" | openssl req -x509 -sha256 -nodes -newkey rsa:2048 -keyout $PRIVATE_KEY -days 365 -out $CERTIFICATE
```
1.
**Archivia il certificato in Secrets Manager per renderlo recuperabile dall'interno del cluster in un secondo momento.**
```
$ aws secretsmanager create-secret --name example-cert \
--secret-string file://$CERTIFICATE \
--region region-id
{
"ARN": "arn:aws:secretsmanager:region-id:123456789012:secret:example-cert-123abc",
"Name": "example-cert",
"VersionId": "14866070-092a-4d5a-bcdd-9219d0566b9c"
}
```
1. Aggiungi la seguente policy al ruolo IAM che hai creato per aggiungere l'istanza Amazon EC2 al dominio AD.
`PutDomainCertificateSecrets`
```
{
"Statement": [
{
"Action": [
"secretsmanager:PutSecretValue"
],
"Resource": [
"arn:aws:secretsmanager:region-id:123456789012:secret:example-cert-123abc"
],
"Effect": "Allow"
}
]
}
```
1.
**Importa il certificato in AWS Certificate Manager (ACM).**
```
$ aws acm import-certificate --certificate fileb://$CERTIFICATE \
--private-key fileb://$PRIVATE_KEY \
--region region-id
{
"CertificateArn": "arn:aws:acm:region-id:123456789012:certificate/343db133-490f-4077-b8d4-3da5bfd89e72"
}
```
1.
**Crea e posiziona il load balancer davanti agli endpoint di Active Directory.**
```
$ aws elbv2 create-load-balancer --name CorpExampleCom-NLB \
--type network \
--scheme internal \
--subnets subnet-1234567890abcdef0 subnet-021345abcdef6789 \
--region region-id
{
"LoadBalancers": [
{
"LoadBalancerArn": "arn:aws:elasticloadbalancing:region-id:123456789012:loadbalancer/net/CorpExampleCom-NLB/3afe296bf4ba80d4",
"DNSName": "CorpExampleCom-NLB-3afe296bf4ba80d4.elb.region-id.amazonaws.com",
"CanonicalHostedZoneId": "Z2IFOLAFXWLO4F",
"CreatedTime": "2022-05-05T12:56:55.988000+00:00",
"LoadBalancerName": "CorpExampleCom-NLB",
"Scheme": "internal",
"VpcId": "vpc-021345abcdef6789",
"State": {
"Code": "provisioning"
},
"Type": "network",
"AvailabilityZones": [
{
"ZoneName": "region-idb",
"SubnetId": "subnet-021345abcdef6789",
"LoadBalancerAddresses": []
},
{
"ZoneName": "region-ida",
"SubnetId": "subnet-1234567890abcdef0",
"LoadBalancerAddresses": []
}
],
"IpAddressType": "ipv4"
}
]
}
```
1.
**Crea il gruppo target destinato agli endpoint di Active Directory.**
```
$ aws elbv2 create-target-group --name CorpExampleCom-Targets --protocol TCP \
--port 389 \
--target-type ip \
--vpc-id vpc-021345abcdef6789 \
--region region-id
{
"TargetGroups": [
{
"TargetGroupArn": "arn:aws:elasticloadbalancing:region-id:123456789012:targetgroup/CorpExampleCom-Targets/44577c583b695e81",
"TargetGroupName": "CorpExampleCom-Targets",
"Protocol": "TCP",
"Port": 389,
"VpcId": "vpc-021345abcdef6789",
"HealthCheckProtocol": "TCP",
"HealthCheckPort": "traffic-port",
"HealthCheckEnabled": true,
"HealthCheckIntervalSeconds": 30,
"HealthCheckTimeoutSeconds": 10,
"HealthyThresholdCount": 3,
"UnhealthyThresholdCount": 3,
"TargetType": "ip",
"IpAddressType": "ipv4"
}
]
}
```
1.
**Registra gli endpoint Active Directory (AD) nel gruppo target.**
```
$ aws elbv2 register-targets --target-group-arn arn:aws:elasticloadbalancing:region-id:123456789012:targetgroup/CorpExampleCom-Targets/44577c583b695e81 \
--targets Id=192.0.2.254,Port=389 Id=203.0.113.237,Port=389 \
--region region-id
```
1.
**Crea il listener LB con il certificato.**
```
$ aws elbv2 create-listener --load-balancer-arn arn:aws:elasticloadbalancing:region-id:123456789012:loadbalancer/net/CorpExampleCom-NLB/3afe296bf4ba80d4 \
--protocol TLS \
--port 636 \
--default-actions Type=forward,TargetGroupArn=arn:aws:elasticloadbalancing:region-id:123456789012:targetgroup/CorpExampleCom-Targets/44577c583b695e81 \
--ssl-policy ELBSecurityPolicy-TLS-1-2-2017-01 \
--certificates CertificateArn=arn:aws:acm:region-id:123456789012:certificate/343db133-490f-4077-b8d4-3da5bfd89e72 \
--region region-id
"Listeners": [
{
"ListenerArn": "arn:aws:elasticloadbalancing:region-id:123456789012:listener/net/CorpExampleCom-NLB/3afe296bf4ba80d4/a8f9d97318743d4b",
"LoadBalancerArn": "arn:aws:elasticloadbalancing:region-id:123456789012:loadbalancer/net/CorpExampleCom-NLB/3afe296bf4ba80d4",
"Port": 636,
"Protocol": "TLS",
"Certificates": [
{
"CertificateArn": "arn:aws:acm:region-id:123456789012:certificate/343db133-490f-4077-b8d4-3da5bfd89e72"
}
],
"SslPolicy": "ELBSecurityPolicy-TLS-1-2-2017-01",
"DefaultActions": [
{
"Type": "forward",
"TargetGroupArn": "arn:aws:elasticloadbalancing:region-id:123456789012:targetgroup/CorpExampleCom-Targets/44577c583b695e81",
"ForwardConfig": {
"TargetGroups": [
{
"TargetGroupArn": "arn:aws:elasticloadbalancing:region-id:123456789012:targetgroup/CorpExampleCom-Targets/44577c583b695e81"
}
]
}
}
]
}
]
}
```
1.
**Crea la zona ospitata per rendere il dominio individuabile all'interno del VPC del cluster.**
```
$ aws route53 create-hosted-zone --name corp.example.com \
--vpc VPCRegion=region-id,VPCId=vpc-021345abcdef6789 \
--caller-reference "ParallelCluster AD Tutorial"
{
"Location": "https://route53.amazonaws.com/2013-04-01/hostedzone/Z09020002B5MZQNXMSJUB",
"HostedZone": {
"Id": "/hostedzone/Z09020002B5MZQNXMSJUB",
"Name": "corp.example.com.",
"CallerReference": "ParallelCluster AD Tutorial",
"Config": {
"PrivateZone": true
},
"ResourceRecordSetCount": 2
},
"ChangeInfo": {
"Id": "/change/C05533343BF3IKSORW1TQ",
"Status": "PENDING",
"SubmittedAt": "2022-05-05T13:21:53.863000+00:00"
},
"VPC": {
"VPCRegion": "region-id",
"VPCId": "vpc-021345abcdef6789"
}
}
```
1.
**Crea un file denominato `recordset-change.json` con il seguente contenuto. `HostedZoneId`è l'ID canonico della zona ospitata del sistema di bilanciamento del carico.**
```
{
"Changes": [
{
"Action": "CREATE",
"ResourceRecordSet": {
"Name": "corp.example.com",
"Type": "A",
"Region": "region-id",
"SetIdentifier": "example-active-directory",
"AliasTarget": {
"HostedZoneId": "Z2IFOLAFXWLO4F",
"DNSName": "CorpExampleCom-NLB-3afe296bf4ba80d4.elb.region-id.amazonaws.com",
"EvaluateTargetHealth": true
}
}
}
]
}
```
1.
**Inviate la modifica del recordset alla zona ospitata, questa volta utilizzando l'ID della zona ospitata.**
```
$ aws route53 change-resource-record-sets --hosted-zone-id Z09020002B5MZQNXMSJUB \
--change-batch file://recordset-change.json
{
"ChangeInfo": {
"Id": "/change/C0137926I56R3GC7XW2Y",
"Status": "PENDING",
"SubmittedAt": "2022-05-05T13:40:36.553000+00:00"
}
}
```
1.
**Create un documento di policy `policy.json` con il seguente contenuto.**
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"secretsmanager:GetSecretValue"
],
"Resource": [
"arn:aws:secretsmanager:us-east-1:123456789012:secret:example-cert-abc123"
],
"Effect": "Allow"
}
]
}
```
------
1.
**Create un documento di policy denominato `policy.json` con il seguente contenuto.**
```
$ aws iam create-policy --policy-name ReadCertExample \
--policy-document file://policy.json
{
"Policy": {
"PolicyName": "ReadCertExample",
"PolicyId": "ANPAUUXUVBC42VZSI4LDY",
"Arn": "arn:aws:iam::123456789012:policy/ReadCertExample-efg456",
"Path": "/",
"DefaultVersionId": "v1",
"AttachmentCount": 0,
"PermissionsBoundaryUsageCount": 0,
"IsAttachable": true,
"CreateDate": "2022-05-05T13:42:18+00:00",
"UpdateDate": "2022-05-05T13:42:18+00:00"
}
}
```
1. Continua a seguire i passaggi indicati in [(Facoltativo) Gestisci utenti e gruppi AD](tutorials_05_multi-user-ad-step2.md) o[Creazione del cluster](tutorials_05_multi-user-ad-step3.md).
# (Facoltativo) Gestisci utenti e gruppi AD
In questa fase, gestisci utenti e gruppi da un'istanza Amazon EC2 Amazon Linux 2 aggiunta al dominio Active Delivery (AD).
Se hai seguito il percorso *automatizzato*, riavvia e accedi all'istanza unita AD creata come parte dell'automazione.
Se hai seguito il percorso *manuale*, riavvia e accedi all'istanza che hai creato e che hai aggiunto all'AD nei passaggi precedenti.
In questi passaggi, si utilizzano gli strumenti [adcli](https://www.mankier.com/package/adcli) e [openldap-clients](https://www.mankier.com/package/openldap-clients) installati nell'istanza come parte del passaggio precedente.
**Accedi a un'istanza Amazon EC2 che fa parte del dominio AD**
1. Dalla console Amazon EC2, seleziona l'istanza Amazon EC2 senza titolo creata nei passaggi precedenti. **Lo stato dell'istanza potrebbe essere Interrotto.**
1. Se lo stato dell'istanza è **Interrotto**, scegli **Stato dell'istanza** e quindi **Avvia istanza**.
1. Una volta superati i controlli di stato, seleziona l'istanza e scegli **Connect** e accedi SSH all'istanza.
**Gestisci utenti e gruppi quando accedi a un'istanza Amazon EC2 Amazon Linux 2 che fa parte di AD**
Quando `adcli` esegui i comandi con l'` -U "Admin"`opzione, ti viene richiesto di inserire la password AD. `Admin` Includi la `Admin` password AD come parte dei `ldapsearch` comandi.
1.
**Creare un utente.**
```
$ adcli create-user "clusteruser" --domain "corp.example.com" -U "Admin"
```
1.
**Imposta una password utente.**
```
$ aws --region "region-id" ds reset-user-password --directory-id "d-abcdef01234567890" --user-name "clusteruser" --new-password "new-p@ssw0rd"
```
1.
**Crea un gruppo.**
```
$ adcli create-group "clusterteam" --domain "corp.example.com" -U "Admin"
```
1.
**Aggiungi un utente a un gruppo.**
```
$ adcli add-member "clusterteam" "clusteruser" --domain "corp.example.com" -U "Admin"
```
1.
**Descrivi utenti e gruppi.**
Descrivi tutti gli utenti.
```
$ ldapsearch "(&(objectClass=user))" -x -h "192.0.2.254" -b "DC=corp,DC=example,DC=com" -D "CN=Admin,OU=Users,OU=CORP,DC=corp,DC=example,DC=com" -w "p@ssw0rd"
```
Descrivi un utente specifico.
```
$ ldapsearch "(&(objectClass=user)(cn=clusteruser))" -x -h "192.0.2.254" -b "DC=corp,DC=example,DC=com" -D "CN=Admin,OU=Users,OU=CORP,DC=corp,DC=example,DC=com" -w "p@ssw0rd"
```
Descrivi tutti gli utenti con uno schema di nomi.
```
$ ldapsearch "(&(objectClass=user)(cn=user*))" -x -h "192.0.2.254" -b "DC=corp,DC=example,DC=com" -D "CN=Admin,OU=Users,OU=CORP,DC=corp,DC=example,DC=com" -w "p@ssw0rd"
```
Descrivi tutti gli utenti che fanno parte di un gruppo specifico.
```
$ ldapsearch "(&(objectClass=user)(memberOf=CN=clusterteam,OU=Users,OU=CORP,DC=corp,DC=example,DC=com))" -x -h "192.0.2.254" -b "DC=corp,DC=example,DC=com" -D "CN=Admin,OU=Users,OU=CORP,DC=corp,DC=example,DC=com" -w "p@ssw0rd"
```
Descrivi tutti i gruppi
```
$ ldapsearch "objectClass=group" -x -h "192.0.2.254" -b "DC=corp,DC=example,DC=com" -D "CN=Admin,OU=Users,OU=CORP,DC=corp,DC=example,DC=com" -w "p@ssw0rd"
```
Descrivi un gruppo specifico
```
$ ldapsearch "(&(objectClass=group)(cn=clusterteam))" -x -h "192.0.2.254" -b "DC=corp,DC=example,DC=com" -D "CN=Admin,OU=Users,OU=CORP,DC=corp,DC=example,DC=com" -w "p@ssw0rd"
```
1.
**Rimuovi un utente da un gruppo.**
```
$ adcli remove-member "clusterteam" "clusteruser" --domain "corp.example.com" -U "Admin"
```
1.
**Elimina un utente.**
```
$ adcli delete-user "clusteruser" --domain "corp.example.com" -U "Admin"
```
1.
**Eliminare un gruppo.**
```
$ adcli delete-group "clusterteam" --domain "corp.example.com" -U "Admin"
```
# Creazione del cluster
Se non sei ancora uscito dall'istanza Amazon EC2, fallo ora.
L'ambiente è configurato per creare un cluster in grado di autenticare gli utenti tramite Active Directory (AD).
Crea una semplice configurazione del cluster e fornisci le impostazioni relative alla connessione ad AD. Per ulteriori informazioni, consulta la sezione [`DirectoryService`](DirectoryService-v3.md).
Scegli una delle seguenti configurazioni del cluster e copiala in un file denominato `ldaps_config.yaml``ldaps_nocert_config.yaml`, o`ldap_config.yaml`.
Ti consigliamo di scegliere la configurazione LDAPS con verifica del certificato. Se scegli questa configurazione, devi anche copiare lo script di bootstrap in un file denominato. `active-directory.head.post.sh` Inoltre, è necessario archiviarlo in un bucket Amazon S3 come indicato nel file di configurazione.
## LDAPS con configurazione di verifica del certificato (consigliato)
**Nota**
`KeyName`: Una delle tue coppie di chiavi Amazon EC2.
`SubnetId / SubnetIds`: Una delle sottoreti IDs fornite nell'output dello stack di creazione CloudFormation rapida (tutorial automatico) o dello script python (tutorial manuale).
`Region`: La regione in cui hai creato l'infrastruttura AD.
`DomainAddr`: Questo indirizzo IP è uno degli indirizzi DNS del servizio AD.
`PasswordSecretArn`: L'Amazon Resource Name (ARN) del segreto che contiene la password per. `DomainReadOnlyUser`
`BucketName`: il nome del bucket che contiene lo script di bootstrap.
`AdditionalPolicies`/`Policy`: L'Amazon Resource Name (ARN) della politica di certificazione del dominio di lettura. ReadCertExample
`CustomActions`/`OnNodeConfigured`/`Args`: L'Amazon Resource Name (ARN) segreto che contiene la politica di certificazione del dominio.
Per una migliore sicurezza, suggeriamo di utilizzare la `AllowedIps` configurazione`HeadNode`/`Ssh`/per limitare l'accesso SSH al nodo principale.
Si noti che il certificato specificato in `LdapTlsCaCert` deve essere accessibile a tutti i nodi del cluster.
**Requisiti rigidi**
Il certificato specificato in `LdapTlsCaCert` deve essere accessibile a tutti i nodi del cluster.
Un nodo senza accesso al certificato non sarà in grado di risolvere gli utenti dalla directory.
```
Region: region-id
Image:
Os: alinux2
HeadNode:
InstanceType: t2.micro
Networking:
SubnetId: subnet-abcdef01234567890
Ssh:
KeyName: keypair
Iam:
AdditionalIamPolicies:
- Policy: arn:aws:iam::123456789012:policy/ReadCertExample
S3Access:
- BucketName: amzn-s3-demo-bucket
EnableWriteAccess: false
KeyName: bootstrap/active-directory/active-directory.head.post.sh
CustomActions:
OnNodeConfigured:
Script: s3://amzn-s3-demo-bucket/bootstrap/active-directory/active-directory.head.post.sh
Args:
- arn:aws:secretsmanager:region-id:123456789012:secret:example-cert-123abc
- /opt/parallelcluster/shared/directory_service/domain-certificate.crt
Scheduling:
Scheduler: slurm
SlurmQueues:
- Name: queue0
ComputeResources:
- Name: queue0-t2-micro
InstanceType: t2.micro
MinCount: 1
MaxCount: 10
Networking:
SubnetIds:
- subnet-abcdef01234567890
DirectoryService:
DomainName: corp.example.com
DomainAddr: ldaps://corp.example.com
PasswordSecretArn: arn:aws:secretsmanager:region-id:123456789012:secret:ADSecretPassword-1234
DomainReadOnlyUser: cn=ReadOnlyUser,ou=Users,ou=CORP,dc=corp,dc=example,dc=com
LdapTlsCaCert: /opt/parallelcluster/shared/directory_service/domain-certificate.crt
LdapTlsReqCert: hard
```
**Script Bootstrap**
Dopo aver creato il file bootstrap e prima di caricarlo nel bucket S3, eseguilo per concedere l'autorizzazione `chmod +x active-directory.head.post.sh` all'esecuzione. AWS ParallelCluster
```
#!/bin/bash
set -e
CERTIFICATE_SECRET_ARN="$1"
CERTIFICATE_PATH="$2"
[[ -z $CERTIFICATE_SECRET_ARN ]] && echo "[ERROR] Missing CERTIFICATE_SECRET_ARN" && exit 1
[[ -z $CERTIFICATE_PATH ]] && echo "[ERROR] Missing CERTIFICATE_PATH" && exit 1
source /etc/parallelcluster/cfnconfig
REGION="${cfn_region:?}"
mkdir -p $(dirname $CERTIFICATE_PATH)
aws secretsmanager get-secret-value --region $REGION --secret-id $CERTIFICATE_SECRET_ARN --query SecretString --output text > $CERTIFICATE_PATH
```
## Configurazione LDAPS senza verifica del certificato
**Nota**
`KeyName`: Una delle tue coppie di chiavi Amazon EC2.
`SubnetId / SubnetIds`: Una delle sottoreti IDs presenti nell'output dello stack di creazione CloudFormation rapida (tutorial automatizzato) o dello script python (tutorial manuale).
`Region`: La regione in cui hai creato l'infrastruttura AD.
`DomainAddr`: Questo indirizzo IP è uno degli indirizzi DNS del servizio AD.
`PasswordSecretArn`: L'Amazon Resource Name (ARN) del segreto che contiene la password per. `DomainReadOnlyUser`
Per una migliore sicurezza, suggeriamo di utilizzare la AllowedIps configurazione HeadNode /Ssh/ per limitare l'accesso SSH al nodo principale.
```
Region: region-id
Image:
Os: alinux2
HeadNode:
InstanceType: t2.micro
Networking:
SubnetId: subnet-abcdef01234567890
Ssh:
KeyName: keypair
Scheduling:
Scheduler: slurm
SlurmQueues:
- Name: queue0
ComputeResources:
- Name: queue0-t2-micro
InstanceType: t2.micro
MinCount: 1
MaxCount: 10
Networking:
SubnetIds:
- subnet-abcdef01234567890
DirectoryService:
DomainName: corp.example.com
DomainAddr: ldaps://corp.example.com
PasswordSecretArn: arn:aws:secretsmanager:region-id:123456789012:secret:ADSecretPassword-1234
DomainReadOnlyUser: cn=ReadOnlyUser,ou=Users,ou=CORP,dc=corp,dc=example,dc=com
LdapTlsReqCert: never
```
## Configurazione LDAP
**Nota**
`KeyName`: Una delle tue coppie di chiavi Amazon EC2.
`SubnetId / SubnetIds`: Una delle sottoreti IDs fornite nell'output dello stack di creazione CloudFormation rapida (tutorial automatico) o dello script python (tutorial manuale).
`Region`: La regione in cui hai creato l'infrastruttura AD.
`DomainAddr`: Questo indirizzo IP è uno degli indirizzi DNS del servizio AD.
`PasswordSecretArn`: L'Amazon Resource Name (ARN) del segreto che contiene la password per. `DomainReadOnlyUser`
Per una migliore sicurezza, suggeriamo di utilizzare la AllowedIps configurazione HeadNode /Ssh/ per limitare l'accesso SSH al nodo principale.
```
Region: region-id
Image:
Os: alinux2
HeadNode:
InstanceType: t2.micro
Networking:
SubnetId: subnet-abcdef01234567890
Ssh:
KeyName: keypair
Scheduling:
Scheduler: slurm
SlurmQueues:
- Name: queue0
ComputeResources:
- Name: queue0-t2-micro
InstanceType: t2.micro
MinCount: 1
MaxCount: 10
Networking:
SubnetIds:
- subnet-abcdef01234567890
DirectoryService:
DomainName: dc=corp,dc=example,dc=com
DomainAddr: ldap://192.0.2.254,ldap://203.0.113.237
PasswordSecretArn: arn:aws:secretsmanager:region-id:123456789012:secret:ADSecretPassword-1234
DomainReadOnlyUser: cn=ReadOnlyUser,ou=Users,ou=CORP,dc=corp,dc=example,dc=com
AdditionalSssdConfigs:
ldap_auth_disable_tls_never_use_in_production: True
```
Crea un cluster con il seguente comando.
```
$ pcluster create-cluster --cluster-name "ad-cluster" --cluster-configuration "./ldaps_config.yaml"
{
"cluster": {
"clusterName": "pcluster",
"cloudformationStackStatus": "CREATE_IN_PROGRESS",
"cloudformationStackArn": "arn:aws:cloudformation:region-id:123456789012:stack/ad-cluster/1234567-abcd-0123-def0-abcdef0123456",
"region": "region-id",
"version": 3.15.0,
"clusterStatus": "CREATE_IN_PROGRESS"
}
}
```
# Connect al cluster come utente
È possibile determinare lo stato del cluster con i seguenti comandi.
```
$ pcluster describe-cluster -n ad-cluster --region "region-id" --query "clusterStatus"
```
L'output è il seguente.
```
"CREATE_IN_PROGRESS" / "CREATE_COMPLETE"
```
Quando lo stato viene raggiunto`"CREATE_COMPLETE"`, accedi con il nome utente e la password creati.
```
$ HEAD_NODE_IP=$(pcluster describe-cluster -n "ad-cluster" --region "region-id" --query headNode.publicIpAddress | xargs echo)
```
```
$ ssh user000@$HEAD_NODE_IP
```
È possibile accedere senza la password fornendo la SSH chiave creata per il nuovo utente all'indirizzo`/home/user000@HEAD_NODE_IP/.ssh/id_rsa`.
Se il `ssh` comando ha avuto esito positivo, la connessione al cluster è avvenuta correttamente come utente autenticato per l'utilizzo di Active Directory (AD).
# Eliminazione
1.
**Dal computer locale, elimina il cluster.**
```
$ pcluster delete-cluster --cluster-name "ad-cluster" --region "region-id"
{
"cluster": {
"clusterName": "ad-cluster",
"cloudformationStackStatus": "DELETE_IN_PROGRESS",
"cloudformationStackArn": "arn:aws:cloudformation:region-id:123456789012:stack/ad-cluster/1234567-abcd-0123-def0-abcdef0123456",
"region": "region-id",
"version": "3.15.0",
"clusterStatus": "DELETE_IN_PROGRESS"
}
}
```
1.
**Controlla lo stato di avanzamento del cluster da eliminare.**
```
$ pcluster describe-cluster --cluster-name "ad-cluster" --region "region-id" --query "clusterStatus"
"DELETE_IN_PROGRESS"
```
Dopo che il cluster è stato eliminato con successo, procedi al passaggio successivo.
## Automatizzato
**Eliminare le risorse di Active Directory**
1. Da [https://console.aws.amazon.com/cloudformation/](https://console.aws.amazon.com/cloudformation/).
1. Nel riquadro di navigazione selezionare **Stacks (Stack)**.
1. Dall'elenco degli stack, scegli lo stack AD (ad esempio,`pcluster-ad`).
1. Scegli **Elimina**.
## Manuale
1.
**Elimina l'istanza Amazon EC2.**
1. Da [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/), scegli **Istanze nel riquadro** di navigazione.
1. Dall'elenco delle istanze, scegli l'istanza che hai creato per aggiungere utenti alla directory.
1. Scegli **Stato dell'istanza**, quindi **Termina** istanza.
1.
**Elimina la zona ospitata.**
1. Crea un `recordset-delete.json` file con il seguente contenuto. In questo esempio, HostedZoneId è l'ID canonico della zona ospitata del load balancer.
```
{
"Changes": [
{
"Action": "DELETE",
"ResourceRecordSet": {
"Name": "corp.example.com",
"Type": "A",
"Region": "region-id",
"SetIdentifier": "pcluster-active-directory",
"AliasTarget": {
"HostedZoneId": "Z2IFOLAFXWLO4F",
"DNSName": "CorpExampleCom-NLB-3afe296bf4ba80d4.elb.region-id.amazonaws.com",
"EvaluateTargetHealth": true
}
}
}
]
}
```
1. Inviate la modifica del recordset alla zona ospitata utilizzando l'ID della zona ospitata.
```
$ aws route53 change-resource-record-sets --hosted-zone-id Z09020002B5MZQNXMSJUB \
--change-batch file://recordset-delete.json
{
"ChangeInfo": {
"Id": "/change/C04853642A0TH2TJ5NLNI",
"Status": "PENDING",
"SubmittedAt": "2022-05-05T14:25:51.046000+00:00"
}
}
```
1. Eliminare la zona ospitata.
```
$ aws route53 delete-hosted-zone --id Z09020002B5MZQNXMSJUB
{
"ChangeInfo": {
"Id": "/change/C0468051QFABTVHMDEG9",
"Status": "PENDING",
"SubmittedAt": "2022-05-05T14:26:13.814000+00:00"
}
}
```
1.
**Eliminare il listener LB.**
```
$ aws elbv2 delete-listener \
--listener-arn arn:aws:elasticloadbalancing:region-id:123456789012:listener/net/CorpExampleCom-NLB/3afe296bf4ba80d4/a8f9d97318743d4b --region region-id
```
1.
**Eliminare il gruppo target.**
```
$ aws elbv2 delete-target-group \
--target-group-arn arn:aws:elasticloadbalancing:region-id:123456789012:targetgroup/CorpExampleCom-Targets/44577c583b695e81 --region region-id
```
1.
**Eliminare il sistema di bilanciamento del carico.**
```
$ aws elbv2 delete-load-balancer \
--load-balancer-arn arn:aws:elasticloadbalancing:region-id:123456789012:loadbalancer/net/CorpExampleCom-NLB/3afe296bf4ba80d4 --region region-id
```
1.
**Eliminare la politica utilizzata dal cluster per leggere il certificato da Secrets Manager.**
```
$ aws iam delete-policy --policy-arn arn:aws:iam::123456789012:policy/ReadCertExample
```
1.
**Elimina il segreto che contiene il certificato di dominio.**
```
$ aws secretsmanager delete-secret \
--secret-id arn:aws:secretsmanager:region-id:123456789012:secret:example-cert-123abc \
--region region-id
{
"ARN": "arn:aws:secretsmanager:region-id:123456789012:secret:example-cert-123abc",
"Name": "example-cert",
"DeletionDate": "2022-06-04T16:27:36.183000+02:00"
}
```
1.
**Eliminare il certificato da ACM.**
```
$ aws acm delete-certificate \
--certificate-arn arn:aws:acm:region-id:123456789012:certificate/343db133-490f-4077-b8d4-3da5bfd89e72 --region region-id
```
1.
**Eliminare le risorse di Active Directory (AD).**
1. Ottieni la seguente risorsa IDs dall'output dello script `ad.py` python:
+ E ID
+ Sottorete AD IDs
+ E ID VPC
1. Eliminare la directory eseguendo il comando seguente.
```
$ aws ds delete-directory --directory-id d-abcdef0123456789 --region region-id
{
"DirectoryId": "d-abcdef0123456789"
}
```
1. Elenca i gruppi di sicurezza nel VPC.
```
$ aws ec2 describe-security-groups --filters '[{"Name":"vpc-id","Values":["vpc-07614ade95ebad1bc"]}]' --region region-id
```
1. Elimina il gruppo di sicurezza personalizzato.
```
$ aws ec2 delete-security-group --group-id sg-021345abcdef6789 --region region-id
```
1. Elimina le sottoreti.
```
$ aws ec2 delete-subnet --subnet-id subnet-1234567890abcdef --region region-id
```
```
$ aws ec2 delete-subnet --subnet-id subnet-021345abcdef6789 --region region-id
```
1. Descrivi Internet Gateway.
```
$ aws ec2 describe-internet-gateways \
--filters Name=attachment.vpc-id,Values=vpc-021345abcdef6789 \
--region region-id
{
"InternetGateways": [
{
"Attachments": [
{
"State": "available",
"VpcId": "vpc-021345abcdef6789"
}
],
"InternetGatewayId": "igw-1234567890abcdef",
"OwnerId": "123456789012",
"Tags": []
}
]
}
```
1. Scollegare il gateway Internet.
```
$ aws ec2 detach-internet-gateway \
--internet-gateway-id igw-1234567890abcdef \
--vpc-id vpc-021345abcdef6789 \
--region region-id
```
1. Eliminare il gateway Internet.
```
$ aws ec2 delete-internet-gateway \
--internet-gateway-id igw-1234567890abcdef \
--region region-id
```
1. Elimina il VPC.
```
$ aws ec2 delete-vpc \
--vpc-id vpc-021345abcdef6789 \
--region region-id
```
1. Eliminare il segreto che contiene la `ReadOnlyUser` password.
```
$ aws secretsmanager delete-secret \
--secret-id arn:aws:secretsmanager:region-id:123456789012:secret:ADSecretPassword-1234" \
--region region-id
```
# Configurazione della crittografia dello storage condiviso con una chiave AWS KMS
Scopri come configurare una AWS KMS chiave gestita dal cliente per crittografare e proteggere i dati nei sistemi di archiviazione di file in cluster per cui sono configurati. AWS ParallelCluster
Quando si utilizza l'interfaccia a riga di AWS ParallelCluster comando (CLI) o l'API, si pagano solo le AWS risorse create quando si creano o si aggiornano AWS ParallelCluster immagini e cluster. Per ulteriori informazioni, consulta [AWS servizi usati da AWS ParallelCluster](aws-services-v3.md).
AWS ParallelCluster supporta le seguenti opzioni di configurazione dello storage condiviso:
+ [`SharedStorage`](SharedStorage-v3.md) / [`EbsSettings`](SharedStorage-v3.md#SharedStorage-v3-EbsSettings) / [`KmsKeyId`](SharedStorage-v3.md#yaml-SharedStorage-EbsSettings-KmsKeyId)
+ [`SharedStorage`](SharedStorage-v3.md) / [`EfsSettings`](SharedStorage-v3.md#SharedStorage-v3-EfsSettings) / [`KmsKeyId`](SharedStorage-v3.md#yaml-SharedStorage-EfsSettings-KmsKeyId)
+ [`SharedStorage`](SharedStorage-v3.md) / [`FsxLustreSettings`](SharedStorage-v3.md#SharedStorage-v3-FsxLustreSettings) / [`KmsKeyId`](SharedStorage-v3.md#yaml-SharedStorage-FsxLustreSettings-KmsKeyId)
Puoi utilizzare queste opzioni per fornire una AWS KMS chiave gestita dal cliente per Amazon EBS, Amazon EFS e FSx per la crittografia del sistema di storage condiviso Lustre. Per utilizzarle, devi creare e configurare una policy IAM per quanto segue:
+ [`HeadNode`](HeadNode-v3.md) / [`Iam`](HeadNode-v3.md#HeadNode-v3-Iam) / [`AdditionalIamPolicies`](HeadNode-v3.md#yaml-HeadNode-Iam-AdditionalIamPolicies) / [`Policy`](HeadNode-v3.md#yaml-HeadNode-Iam-AdditionalIamPolicies-Policy)
+ [`Scheduler`](Scheduling-v3.md#yaml-Scheduling-Scheduler) / [`SlurmQueues`](Scheduling-v3.md#Scheduling-v3-SlurmQueues) / [`Iam`](Scheduling-v3.md#Scheduling-v3-SlurmQueues-Iam) / [`AdditionalIamPolicies`](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-Iam-AdditionalIamPolicies) / [`Policy`](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-Iam-AdditionalIamPolicies-Policy)
**Prerequisiti**
+ AWS ParallelCluster [è installato](install-v3-parallelcluster.md).
+ AWS CLI [è installato e configurato.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Hai una coppia di [chiavi Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Hai un ruolo IAM con le [autorizzazioni](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) necessarie per eseguire la [`pcluster`](pcluster-v3.md) CLI.
**Topics**
+ [
# Creare la policy
](creating-the-role-v3.md)
+ [
# Configura e crea il cluster
](creating-the-cluster-v3.md)
# Creare la policy
In questo tutorial, creerai una politica per configurare la crittografia dello storage condiviso con una AWS KMS chiave.
**Creazione di una policy.**
1. Vai alla console IAM: [https://console.aws.amazon.com/iam/home](https://console.aws.amazon.com/iam/home).
1. Seleziona **Policy**.
1. Scegli **Crea policy**.
1. Scegli la scheda **JSON** e incolla la seguente policy. Assicurati di sostituire tutte le occorrenze di `123456789012` con il tuo Account AWS ID e la chiave Amazon Resource Name (ARN) Regione AWS e con il tuo.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kms:DescribeKey",
"kms:ReEncrypt*",
"kms:CreateGrant",
"kms:Decrypt"
],
"Resource": [
"arn:aws:kms:us-east-1:123456789012:key/abcd1234-ef56-gh78-ij90-abcd1234efgh5678"
]
}
]
}
```
------
1. Per questo tutorial, assegna un nome alla politica`ParallelClusterKmsPolicy`, quindi scegli **Crea** politica.
1. Prendi nota della politica ARN. Ne hai bisogno per configurare il tuo cluster.
# Configura e crea il cluster
Di seguito è riportato un esempio di configurazione del cluster che include un file system condiviso di Amazon Elastic Block Store con crittografia.
```
Region: eu-west-1
Image:
Os: alinux2
HeadNode:
InstanceType: t2.micro
Networking:
SubnetId: subnet-abcdef01234567890
Ssh:
KeyName: my-ssh-key
Iam:
AdditionalIamPolicies:
- Policy: arn:aws:iam::123456789012:policy/ParallelClusterKmsPolicy
Scheduling:
Scheduler: slurm
SlurmQueues:
- Name: q1
ComputeResources:
- Name: t2micro
InstanceType: t2.micro
MinCount: 0
MaxCount: 10
Networking:
SubnetIds:
- subnet-abcdef01234567890
Iam:
AdditionalIamPolicies:
- Policy: arn:aws:iam::123456789012:policy/ParallelClusterKmsPolicy
SharedStorage:
- MountDir: /shared/ebs1
Name: shared-ebs1
StorageType: Ebs
EbsSettings:
Encrypted: True
KmsKeyId: abcd1234-ef56-gh78-ij90-abcd1234efgh5678
```
Sostituisci gli elementi in rosso con i tuoi valori. Quindi, crea un cluster che utilizza la tua AWS KMS chiave per crittografare i dati in Amazon EBS.
La configurazione è simile per Amazon EFS e FSx per i file system Lustre.
La `SharedStorage` configurazione di Amazon EFS è la seguente.
```
...
SharedStorage:
- MountDir: /shared/efs1
Name: shared-efs1
StorageType: Efs
EfsSettings:
Encrypted: True
KmsKeyId: abcd1234-ef56-gh78-ij90-abcd1234efgh5678
```
La `SharedStorage` configurazione di FSx for Lustre è la seguente.
```
...
SharedStorage:
- MountDir: /shared/fsx1
Name: shared-fsx1
StorageType: FsxLustre
FsxLustreSettings:
StorageCapacity: 1200
DeploymentType: PERSISTENT_1
PerUnitStorageThroughput: 200
KmsKeyId: abcd1234-ef56-gh78-ij90-abcd1234efgh5678
```
# Esecuzione di processi in un cluster in modalità coda multipla
Questo tutorial spiega come eseguire il primo lavoro "Hello World" in AWS ParallelCluster modalità [coda multipla](configuration-of-multiple-queues-v3.md).
Quando si utilizza l'interfaccia a riga di AWS ParallelCluster comando (CLI) o l'API, si pagano solo le AWS risorse create quando si creano o si aggiornano AWS ParallelCluster immagini e cluster. Per ulteriori informazioni, consulta [AWS servizi usati da AWS ParallelCluster](aws-services-v3.md).
**Prerequisiti**
+ AWS ParallelCluster [è](install-v3-parallelcluster.md) installato.
+ AWS CLI [è installato e configurato.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Hai una coppia di [chiavi Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Hai un ruolo IAM con le [autorizzazioni](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) necessarie per eseguire la [`pcluster`](pcluster-v3.md) CLI.
## Configura il tuo cluster
Innanzitutto, verifica che AWS ParallelCluster sia installato correttamente eseguendo il comando seguente.
```
$ pcluster version
```
Per ulteriori informazioni su `pcluster version`, consultare [`pcluster version`](pcluster.version-v3.md).
Questo comando restituisce la versione in esecuzione di AWS ParallelCluster.
Quindi, `pcluster configure` esegui per generare un file di configurazione di base. Segui tutte le istruzioni che seguono questo comando.
```
$ pcluster configure --config multi-queue-mode.yaml
```
Per ulteriori informazioni sul comando `pcluster configure`, consulta [`pcluster configure`](pcluster.configure-v3.md).
Dopo aver completato questo passaggio, viene visualizzato un file di configurazione di base denominato`multi-queue-mode.yaml`. Questo file contiene una configurazione di base del cluster.
Nel passaggio successivo, si modifica il nuovo file di configurazione e si avvia un cluster con più code.
**Nota**
Alcune istanze utilizzate in questo tutorial non sono idonee al livello gratuito.
Per questo tutorial, modifica il file di configurazione in modo che corrisponda alla configurazione seguente. Gli elementi evidenziati in rosso rappresentano i valori del file di configurazione. Mantieni i tuoi valori.
```
Region: region-id
Image:
Os: alinux2
HeadNode:
InstanceType: c5.xlarge
Networking:
SubnetId: subnet-abcdef01234567890
Ssh:
KeyName: yourkeypair
Scheduling:
Scheduler: slurm
SlurmQueues:
- Name: spot
ComputeResources:
- Name: c5xlarge
InstanceType: c5.xlarge
MinCount: 1
MaxCount: 10
- Name: t2micro
InstanceType: t2.micro
MinCount: 1
MaxCount: 10
Networking:
SubnetIds:
- subnet-abcdef01234567890
- Name: ondemand
ComputeResources:
- Name: c52xlarge
InstanceType: c5.2xlarge
MinCount: 0
MaxCount: 10
Networking:
SubnetIds:
- subnet-021345abcdef6789
```
## Creazione di un cluster
Crea un cluster denominato in `multi-queue-cluster` base al tuo file di configurazione.
```
$ pcluster create-cluster --cluster-name multi-queue-cluster --cluster-configuration multi-queue-mode.yaml
{
"cluster": {
"clusterName": "multi-queue-cluster",
"cloudformationStackStatus": "CREATE_IN_PROGRESS",
"cloudformationStackArn": "arn:aws:cloudformation:eu-west-1:123456789012:stack/multi-queue-cluster/1234567-abcd-0123-def0-abcdef0123456",
"region": "eu-west-1",
"version": "3.15.0",
"clusterStatus": "CREATE_IN_PROGRESS"
}
}
```
Per ulteriori informazioni sul comando `pcluster create-cluster`, consulta [`pcluster create-cluster`](pcluster.create-cluster-v3.md).
Per verificare lo stato del cluster, esegui il comando seguente.
```
$ pcluster list-clusters
{
"cluster": {
"clusterName": "multi-queue-cluster",
"cloudformationStackStatus": "CREATE_IN_PROGRESS",
"cloudformationStackArn": "arn:aws:cloudformation:eu-west-1:123456789012:stack/multi-queue-cluster/1234567-abcd-0123-def0-abcdef0123456",
"region": "eu-west-1",
"version": "3.15.0",
"clusterStatus": "CREATE_IN_PROGRESS"
}
}
```
Quando il cluster viene creato, il `clusterStatus` campo viene visualizzato`CREATE_COMPLETE`.
## Accedere al nodo principale
Usa il tuo file di chiave SSH privato per accedere al nodo principale.
```
$ pcluster ssh --cluster-name multi-queue-cluster -i ~/path/to/yourkeyfile.pem
```
Per ulteriori informazioni su `pcluster ssh`, consultare [`pcluster ssh`](pcluster.ssh-v3.md).
Dopo aver effettuato l'accesso, esegui il `sinfo` comando per verificare che le code dello scheduler siano impostate e configurate.
*Per maggiori informazioni in merito`sinfo`, consulta [sinfo](https://slurm.schedmd.com/sinfo.html) nella documentazione. Slurm*
```
$ sinfo
PARTITION AVAIL TIMELIMIT NODES STATE NODELIST
spot* up infinite 18 idle~ spot-dy-c5xlarge-[1-9],spot-dy-t2micro-[1-9]
spot* up infinite 2 idle spot-st-c5xlarge-1,spot-st-t2micro-1
ondemand up infinite 10 idle~ ondemand-dy-c52xlarge-[1-10]
```
L'output mostra che hai uno `t2.micro` e un nodo di `c5.xlarge` calcolo nello `idle` stato disponibile nel tuo cluster.
Gli altri nodi sono tutti nello stato di risparmio energetico, indicato dal `~` suffisso nello stato del nodo, senza istanze Amazon EC2 che li supportano. La coda predefinita è indicata da un `*` suffisso dopo il nome della coda. `spot`è la tua coda di lavoro predefinita.
## Esegue il lavoro in modalità coda multipla
Quindi, prova a eseguire un lavoro per dormire per qualche istante. Successivamente, il job restituisce il proprio nome host. Assicuratevi che questo script possa essere eseguito dall'utente corrente.
```
$ tee <
In questo tutorial, creerai e testerai l'API con [Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html) e un AWS ParallelCluster CloudFormation modello. Quindi, usi il client di esempio disponibile su GitHub per utilizzare l'API. Per ulteriori informazioni sull'uso dell'API, consulta [AWS ParallelCluster API](api-reference-v3.md).
Per ulteriori informazioni, consulta [Creare un componente personalizzato con Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/create-component.html) nella Guida per l'utente di *Image EC2 Builder*.
Quando si utilizza l'interfaccia a riga di AWS ParallelCluster comando (CLI) o l'API, si pagano solo le AWS risorse create quando si creano o si aggiornano AWS ParallelCluster immagini e cluster. Per ulteriori informazioni, consulta [AWS servizi usati da AWS ParallelCluster](aws-services-v3.md).
**Prerequisiti**
+ AWS CLI Viene [installato](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) e configurato nel tuo ambiente di elaborazione.
+ AWS ParallelCluster è installato in un ambiente virtuale. Per ulteriori informazioni, consulta [Installazione AWS ParallelCluster in un ambiente virtuale (scelta consigliata)](install-v3-virtual-environment.md).
+ Hai una [coppia di EC2 chiavi Amazon](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Hai un ruolo IAM con le [autorizzazioni](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) necessarie per eseguire la [`pcluster`](pcluster-v3.md) CLI.
## Fase 1: Crea l'API con Amazon API Gateway
**Rimani nella tua directory utente principale e attiva il tuo ambiente virtuale:**
1. Installa un utile processore a riga di comando JSON.
```
$ sudo yum groupinstall -y "Development Tools"
sudo yum install -y jq python3-devel
```
1. Esegui il comando seguente per ottenere la tua AWS ParallelCluster versione e assegnarla a una variabile di ambiente.
```
$ PCLUSTER_VERSION=$(pcluster version | jq -r '.version')
echo "export PCLUSTER_VERSION=${PCLUSTER_VERSION}" |tee -a ~/.bashrc
```
1. Crea una variabile di ambiente e assegnale il tuo ID regionale.
```
$ export AWS_DEFAULT_REGION="us-east-1"
echo "export AWS_DEFAULT_REGION=${AWS_DEFAULT_REGION}" |tee -a ~/.bashrc
```
1. Esegui i seguenti comandi per distribuire l'API.
```
API_STACK_NAME="pc-api-stack"
echo "export API_STACK_NAME=${API_STACK_NAME}" |tee -a ~/.bashrc
```
```
aws cloudformation create-stack \
--region ${AWS_DEFAULT_REGION} \
--stack-name ${API_STACK_NAME} \
--template-url https://${AWS_DEFAULT_REGION}-aws-parallelcluster.s3.${AWS_DEFAULT_REGION}.amazonaws.com/parallelcluster/${PCLUSTER_VERSION}/api/parallelcluster-api.yaml \
--capabilities CAPABILITY_NAMED_IAM CAPABILITY_AUTO_EXPAND \
--parameters ParameterKey=EnableIamAdminAccess,ParameterValue=true
{
"StackId": "arn:aws:cloudformation:us-east-1:123456789012:stack/my-api-stack/abcd1234-ef56-gh78-ei90-1234abcd5678"
}
```
Al termine del processo, procedi al passaggio successivo.
## Fase 2: Verifica l'API nella console Amazon API Gateway
1. Accedi alla Console di gestione AWS.
1. Accedi alla [console Amazon API Gateway](https://console.aws.amazon.com/apigateway/home).
1. Scegli la tua implementazione API.
![\[Console Amazon API Gateway con elenco dei gateway tra cui scegliere.\]](http://docs.aws.amazon.com/it_it/parallelcluster/latest/ug/images/gateway_choose.png)
1. Scegli **Stages** e seleziona una fase.
![\[Una visualizzazione da console delle fasi tra cui puoi scegliere. Puoi anche visualizzare l'URL fornito da API Gateway per la tua API.\]](http://docs.aws.amazon.com/it_it/parallelcluster/latest/ug/images/gateway_address.png)
1. Nota l'URL fornito da API Gateway per accedere o richiamare la tua API. È evidenziato in blu.
1. Scegli **Risorse** e seleziona **`GET`**sotto **`/clusters`**.
1. Scegli l'icona **TEST**, quindi scorri verso il basso e scegli l'icona **TEST**.
![\[Una visualizzazione da console delle risorse API e dei meccanismi di test.\]](http://docs.aws.amazon.com/it_it/parallelcluster/latest/ug/images/gateway_test.png)
`/clusters GET`Viene visualizzata la risposta al tuo messaggio.
![\[Una visualizzazione da console delle risorse API, dei meccanismi di test e della risposta alla richiesta di test.\]](http://docs.aws.amazon.com/it_it/parallelcluster/latest/ug/images/gateway.png)
## Fase 3: Preparare e testare un client di esempio per richiamare l'API
Clona il codice AWS ParallelCluster sorgente `api` nella directory e installa le librerie client Python. `cd`
1.
```
$ git clone -b v${PCLUSTER_VERSION} https://github.com/aws/aws-parallelcluster aws-parallelcluster-v${PCLUSTER_VERSION}
cd aws-parallelcluster-v${PCLUSTER_VERSION}/api
```
```
$ pip3 install client/src
```
1. Torna alla tua directory utente principale.
1. Esporta l'URL di base dell'API Gateway utilizzato dal client durante l'esecuzione.
```
$ export PCLUSTER_API_URL=$( aws cloudformation describe-stacks --stack-name ${API_STACK_NAME} --query 'Stacks[0].Outputs[?OutputKey==`ParallelClusterApiInvokeUrl`].OutputValue' --output text )
echo "export PCLUSTER_API_URL=${PCLUSTER_API_URL}" |tee -a ~/.bashrc
```
1. Esporta il nome di un cluster utilizzato dal client per creare un cluster.
```
$ export CLUSTER_NAME="test-api-cluster"
echo "export CLUSTER_NAME=${CLUSTER_NAME}" |tee -a ~/.bashrc
```
1. Esegui i seguenti comandi per memorizzare le credenziali utilizzate dal client di esempio per accedere all'API.
```
$ export PCLUSTER_API_USER_ROLE=$( aws cloudformation describe-stacks --stack-name ${API_STACK_NAME} --query 'Stacks[0].Outputs[?OutputKey==`ParallelClusterApiUserRole`].OutputValue' --output text )
echo "export PCLUSTER_API_USER_ROLE=${PCLUSTER_API_USER_ROLE}" |tee -a ~/.bashrc
```
## Passaggio 4: Copia lo script del codice del client ed esegui i test del cluster
1. Copia il seguente codice client di esempio `test_pcluster_client.py` nella tua directory utente principale. Il codice client richiede le seguenti operazioni:
+ Crea il cluster .
+ Descrivi il cluster.
+ Elenca i cluster.
+ Descrivi la flotta di elaborazione.
+ Descrivi le istanze del cluster.
```
# Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: MIT-0
#
# Permission is hereby granted, free of charge, to any person obtaining a copy of this
# software and associated documentation files (the "Software"), to deal in the Software
# without restriction, including without limitation the rights to use, copy, modify,
# merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
# permit persons to whom the Software is furnished to do so.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
# INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
# PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#
# Author: Evan F. Bollig (Github: bollig)
import time, datetime
import os
import pcluster_client
from pprint import pprint
from pcluster_client.api import (
cluster_compute_fleet_api,
cluster_instances_api,
cluster_operations_api
)
from pcluster_client.model.create_cluster_request_content import CreateClusterRequestContent
from pcluster_client.model.cluster_status import ClusterStatus
region=os.environ.get("AWS_DEFAULT_REGION")
# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = pcluster_client.Configuration(
host = os.environ.get("PCLUSTER_API_URL")
)
cluster_name=os.environ.get("CLUSTER_NAME")
# Enter a context with an instance of the API client
with pcluster_client.ApiClient(configuration) as api_client:
cluster_ops = cluster_operations_api.ClusterOperationsApi(api_client)
fleet_ops = cluster_compute_fleet_api.ClusterComputeFleetApi(api_client)
instance_ops = cluster_instances_api.ClusterInstancesApi(api_client)
# Create cluster
build_done = False
try:
with open('cluster-config.yaml', encoding="utf-8") as f:
body = CreateClusterRequestContent(cluster_name=cluster_name, cluster_configuration=f.read())
api_response = cluster_ops.create_cluster(body, region=region)
except pcluster_client.ApiException as e:
print("Exception when calling create_cluster: %s\n" % e)
build_done = True
time.sleep(60)
# Confirm cluster status with describe_cluster
while not build_done:
try:
api_response = cluster_ops.describe_cluster(cluster_name, region=region)
pprint(api_response)
if api_response.cluster_status == ClusterStatus('CREATE_IN_PROGRESS'):
print('. . . working . . .', end='', flush=True)
time.sleep(60)
elif api_response.cluster_status == ClusterStatus('CREATE_COMPLETE'):
print('READY!')
build_done = True
else:
print('ERROR!!!!')
build_done = True
except pcluster_client.ApiException as e:
print("Exception when calling describe_cluster: %s\n" % e)
# List clusters
try:
api_response = cluster_ops.list_clusters(region=region)
pprint(api_response)
except pcluster_client.ApiException as e:
print("Exception when calling list_clusters: %s\n" % e)
# DescribeComputeFleet
try:
api_response = fleet_ops.describe_compute_fleet(cluster_name, region=region)
pprint(api_response)
except pcluster_client.ApiException as e:
print("Exception when calling compute fleet: %s\n" % e)
# DescribeClusterInstances
try:
api_response = instance_ops.describe_cluster_instances(cluster_name, region=region)
pprint(api_response)
except pcluster_client.ApiException as e:
print("Exception when calling describe_cluster_instances: %s\n" % e)
```
1. Crea una configurazione del cluster.
```
$ pcluster configure --config cluster-config.yaml
```
1. La libreria API Client rileva automaticamente i dettagli di configurazione dalle variabili di ambiente (ad esempio`AWS_ACCESS_KEY_ID`,`AWS_SECRET_ACCESS_KEY`, or`AWS_SESSION_TOKEN`) o`$HOME/.aws`. Il comando seguente imposta il ruolo IAM corrente a quello designato. ParallelClusterApiUserRole
```
$ eval $(aws sts assume-role --role-arn ${PCLUSTER_API_USER_ROLE} --role-session-name ApiTestSession | jq -r '.Credentials | "export AWS_ACCESS_KEY_ID=\(.AccessKeyId)\nexport AWS_SECRET_ACCESS_KEY=\(.SecretAccessKey)\nexport AWS_SESSION_TOKEN=\(.SessionToken)\n"')
```
**Errore da tenere d'occhio:**
Se visualizzi un errore simile al seguente, significa che hai già dato per scontato che il ParallelClusterApiUserRole e il tuo sia `AWS_SESSION_TOKEN` scaduto.
```
An error occurred (AccessDenied) when calling the AssumeRole operation:
User: arn:aws:sts::XXXXXXXXXXXX:assumed-role/ParallelClusterApiUserRole-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX/ApiTestSession
is not authorized to perform: sts:AssumeRole on resource: arn:aws:iam::XXXXXXXXXXXX:role/ParallelClusterApiUserRole-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
```
Eliminare il ruolo e quindi eseguire nuovamente il `aws sts assume-role` comando per utilizzare. ParallelClusterApiUserRole
```
$ unset AWS_SESSION_TOKEN
unset AWS_SECRET_ACCESS_KEY
unset AWS_ACCESS_KEY_ID
```
Per fornire le attuali autorizzazioni utente per l'accesso all'API, è necessario [espandere la Resource Policy](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-resource-policies.html).
1. Esegui il comando seguente per testare il client di esempio.
```
$ python3 test_pcluster_client.py
{'cluster_configuration': 'Region: us-east-1\n'
'Image:\n'
' Os: alinux2\n'
'HeadNode:\n'
' InstanceType: t2.micro\n'
' Networking . . . :\n'
' SubnetId: subnet-1234567890abcdef0\n'
' Ssh:\n'
' KeyName: adpc\n'
'Scheduling:\n'
' Scheduler: slurm\n'
' SlurmQueues:\n'
' - Name: queue1\n'
' ComputeResources:\n'
' - Name: t2micro\n'
' InstanceType: t2.micro\n'
' MinCount: 0\n'
' MaxCount: 10\n'
' Networking . . . :\n'
' SubnetIds:\n'
' - subnet-1234567890abcdef0\n',
'cluster_name': 'test-api-cluster'}
{'cloud_formation_stack_status': 'CREATE_IN_PROGRESS',
'cloudformation_stack_arn': 'arn:aws:cloudformation:us-east-1:123456789012:stack/test-api-cluster/abcd1234-ef56-gh78-ij90-1234abcd5678',
'cluster_configuration': {'url': 'https://parallelcluster-021345abcdef6789-v1-do-not-delete...},
'cluster_name': 'test-api-cluster',
'cluster_status': 'CREATE_IN_PROGRESS',
'compute_fleet_status': 'UNKNOWN',
'creation_time': datetime.datetime(2022, 4, 28, 16, 18, 47, 972000, tzinfo=tzlocal()),
'last_updated_time': datetime.datetime(2022, 4, 28, 16, 18, 47, 972000, tzinfo=tzlocal()),
'region': 'us-east-1',
'tags': [{'key': 'parallelcluster:version', 'value': '3.1.3'}],
'version': '3.1.3'}
.
.
.
. . . working . . . {'cloud_formation_stack_status': 'CREATE_COMPLETE',
'cloudformation_stack_arn': 'arn:aws:cloudformation:us-east-1:123456789012:stack/test-api-cluster/abcd1234-ef56-gh78-ij90-1234abcd5678',
'cluster_configuration': {'url': 'https://parallelcluster-021345abcdef6789-v1-do-not-delete...},
'cluster_name': 'test-api-cluster',
'cluster_status': 'CREATE_COMPLETE',
'compute_fleet_status': 'RUNNING',
'creation_time': datetime.datetime(2022, 4, 28, 16, 18, 47, 972000, tzinfo=tzlocal()),
'head_node': {'instance_id': 'i-abcdef01234567890',
'instance_type': 't2.micro',
'launch_time': datetime.datetime(2022, 4, 28, 16, 21, 46, tzinfo=tzlocal()),
'private_ip_address': '172.31.27.153',
'public_ip_address': '52.90.156.51',
'state': 'running'},
'last_updated_time': datetime.datetime(2022, 4, 28, 16, 18, 47, 972000, tzinfo=tzlocal()),
'region': 'us-east-1',
'tags': [{'key': 'parallelcluster:version', 'value': '3.1.3'}],
'version': '3.1.3'}
READY!
```
## Passaggio 5: Copia lo script del codice del client ed elimina il cluster
1. Copia il seguente codice client di esempio in`delete_cluster_client.py`. Il codice client richiede l'eliminazione del cluster.
```
# Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: MIT-0
#
# Permission is hereby granted, free of charge, to any person obtaining a copy of this
# software and associated documentation files (the "Software"), to deal in the Software
# without restriction, including without limitation the rights to use, copy, modify,
# merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
# permit persons to whom the Software is furnished to do so.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
# INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
# PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#
# Author: Evan F. Bollig (Github: bollig)
import time, datetime
import os
import pcluster_client
from pprint import pprint
from pcluster_client.api import (
cluster_compute_fleet_api,
cluster_instances_api,
cluster_operations_api
)
from pcluster_client.model.create_cluster_request_content import CreateClusterRequestContent
from pcluster_client.model.cluster_status import ClusterStatus
region=os.environ.get("AWS_DEFAULT_REGION")
# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = pcluster_client.Configuration(
host = os.environ.get("PCLUSTER_API_URL")
)
cluster_name=os.environ.get("CLUSTER_NAME")
# Enter a context with an instance of the API client
with pcluster_client.ApiClient(configuration) as api_client:
cluster_ops = cluster_operations_api.ClusterOperationsApi(api_client)
# Delete the cluster
gone = False
try:
api_response = cluster_ops.delete_cluster(cluster_name, region=region)
except pcluster_client.ApiException as e:
print("Exception when calling delete_cluster: %s\n" % e)
time.sleep(60)
# Confirm cluster status with describe_cluster
while not gone:
try:
api_response = cluster_ops.describe_cluster(cluster_name, region=region)
pprint(api_response)
if api_response.cluster_status == ClusterStatus('DELETE_IN_PROGRESS'):
print('. . . working . . .', end='', flush=True)
time.sleep(60)
except pcluster_client.ApiException as e:
gone = True
print("DELETE COMPLETE or Exception when calling describe_cluster: %s\n" % e)
```
1. Esegui il comando seguente per eliminare il cluster.
```
$ python3 delete_cluster_client.py
{'cloud_formation_stack_status': 'DELETE_IN_PROGRESS',
'cloudformation_stack_arn': 'arn:aws:cloudformation:us-east-1:123456789012:stack/test-api-cluster/abcd1234-ef56-gh78-ij90-1234abcd5678',
'cluster_configuration': {'url': 'https://parallelcluster-021345abcdef6789-v1-do-not-delete...},
'cluster_name': 'test-api-cluster',
'cluster_status': 'DELETE_IN_PROGRESS',
'compute_fleet_status': 'UNKNOWN',
'creation_time': datetime.datetime(2022, 4, 28, 16, 50, 47, 943000, tzinfo=tzlocal()),
'head_node': {'instance_id': 'i-abcdef01234567890',
'instance_type': 't2.micro',
'launch_time': datetime.datetime(2022, 4, 28, 16, 53, 48, tzinfo=tzlocal()),
'private_ip_address': '172.31.17.132',
'public_ip_address': '34.201.100.37',
'state': 'running'},
'last_updated_time': datetime.datetime(2022, 4, 28, 16, 50, 47, 943000, tzinfo=tzlocal()),
'region': 'us-east-1',
'tags': [{'key': 'parallelcluster:version', 'value': '3.1.3'}],
'version': '3.1.3'}
.
.
.
. . . working . . . {'cloud_formation_stack_status': 'DELETE_IN_PROGRESS',
'cloudformation_stack_arn': 'arn:aws:cloudformation:us-east-1:123456789012:stack/test-api-cluster/abcd1234-ef56-gh78-ij90-1234abcd5678',
'cluster_configuration': {'url': 'https://parallelcluster-021345abcdef6789-v1-do-not-delete...},
'cluster_name': 'test-api-cluster',
'cluster_status': 'DELETE_IN_PROGRESS',
'compute_fleet_status': 'UNKNOWN',
'creation_time': datetime.datetime(2022, 4, 28, 16, 50, 47, 943000, tzinfo=tzlocal()),
'last_updated_time': datetime.datetime(2022, 4, 28, 16, 50, 47, 943000, tzinfo=tzlocal()),
'region': 'us-east-1',
'tags': [{'key': 'parallelcluster:version', 'value': '3.1.3'}],
'version': '3.1.3'}
. . . working . . . DELETE COMPLETE or Exception when calling describe_cluster: (404)
Reason: Not Found
.
.
.
HTTP response body: {"message":"Cluster 'test-api-cluster' does not exist or belongs to an incompatible ParallelCluster major version."}
```
1. Al termine del test, annullate l'impostazione delle variabili di ambiente.
```
$ unset AWS_SESSION_TOKEN
unset AWS_SECRET_ACCESS_KEY
unset AWS_ACCESS_KEY_ID
```
## Fase 6: pulizia
Puoi usare Console di gestione AWS o AWS CLI per eliminare la tua API.
1. Dalla CloudFormation console, scegli lo stack API, quindi scegli **Elimina**.
1. Esegui il comando seguente se usi il AWS CLI.
Usando CloudFormation.
```
$ aws cloudformation delete-stack --stack-name ${API_STACK_NAME}
```
# Creazione di un cluster con Slurm contabilità
Scopri come configurare e creare un cluster con Slurm contabilità. Per ulteriori informazioni, consulta [Slurmcontabilità con AWS ParallelCluster](slurm-accounting-v3.md).
Quando si utilizza l'interfaccia a riga di AWS ParallelCluster comando (CLI) o l'API, si pagano solo le AWS risorse create quando si creano o si aggiornano AWS ParallelCluster immagini e cluster. Per ulteriori informazioni, consulta [AWS servizi usati da AWS ParallelCluster](aws-services-v3.md).
In questo tutorial, si utilizza un [modello di CloudFormation creazione rapida (us-east-1) per creare un database serverless per MySQL](https://us-east-1.console.aws.amazon.com/cloudformation/home?region=us-east-1#/stacks/create/review?stackName=pcluster-slurm-db&templateURL=https://us-east-1-aws-parallelcluster.s3.amazonaws.com/templates/1-click/serverless-database.yaml). [Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraOverview.html) Il modello indica di CloudFormation creare tutti i componenti necessari per distribuire un database Amazon Aurora serverless sullo stesso VPC del cluster. Il modello crea anche una configurazione di rete e sicurezza di base per la connessione tra il cluster e il database.
**Nota**
A partire dalla versione 3.3.0, supporta AWS ParallelCluster Slurm contabilità con il parametro di configurazione del cluster [SlurmSettings](Scheduling-v3.md#Scheduling-v3-SlurmSettings)/[Database](Scheduling-v3.md#Scheduling-v3-SlurmSettings-Database).
**Nota**
Il modello di creazione rapida funge da esempio. Questo modello non copre tutti i possibili casi d'uso per un Slurm server di database contabile. È tua responsabilità creare un server di database con la configurazione e la capacità appropriate per i tuoi carichi di lavoro di produzione.
**Prerequisiti:**
+ AWS ParallelCluster [è installato.](install-v3-parallelcluster.md)
+ AWS CLI [è installato e configurato.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Hai una [coppia di EC2 chiavi Amazon](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Hai un ruolo IAM con le [autorizzazioni](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) necessarie per eseguire la [`pcluster`](pcluster-v3.md) CLI.
+ La regione in cui distribuisci il modello di creazione rapida supporta Amazon Aurora MySQL serverless v2. Per ulteriori informazioni, consulta [Aurora Serverless v2 with Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Concepts.Aurora_Fea_Regions_DB-eng.Feature.ServerlessV2.html#Concepts.Aurora_Fea_Regions_DB-eng.Feature.ServerlessV2.amy) MySQL.
## Fase 1: Creare il VPC e le sottoreti per AWS ParallelCluster
Per utilizzare il modello fornito CloudFormation per Slurm database di contabilità, è necessario disporre del VPC per il cluster pronto. È possibile eseguire questa operazione manualmente o come parte della [Configura e crea un cluster con l'interfaccia a AWS ParallelCluster riga di comando](install-v3-configuring.md) procedura. Se lo hai già utilizzato AWS ParallelCluster, potresti avere un VPC pronto per la distribuzione del cluster e del server di database.
## Fase 2: Creare lo stack di database
Usa il [modello CloudFormation quick-create (us-east-1) per creare](https://us-east-1.console.aws.amazon.com/cloudformation/home?region=us-east-1#/stacks/create/review?stackName=pcluster-slurm-db&templateURL=https://us-east-1-aws-parallelcluster.s3.amazonaws.com/templates/1-click/serverless-database.yaml) uno stack di database per Slurm contabilità. Il modello richiede i seguenti input:
+ Credenziali del server di database, in particolare il nome utente e la password dell'amministratore.
+ Dimensionamento del cluster Amazon Aurora serverless. Dipende dal caricamento previsto del cluster.
+ Parametri di rete, in particolare il VPC e le sottoreti di destinazione o i blocchi CIDR per la creazione delle sottoreti.
Seleziona le credenziali e le dimensioni appropriate per il tuo server di database. Per le opzioni di rete, è necessario utilizzare lo stesso VPC su cui è distribuito il AWS ParallelCluster cluster. È possibile creare le sottoreti per il database e passarle come input al modello. Oppure, fornisci due blocchi CIDR disgiunti per le due sottoreti e lascia che il CloudFormation modello crei le due sottoreti per i blocchi CIDR. Assicurati che i blocchi CIDR non si sovrappongano alle sottoreti esistenti. Se i blocchi CIDR si sovrappongono alle sottoreti esistenti, lo stack non viene creato.
La creazione del server del database richiede diversi minuti.
## Fase 3: Creare un cluster con Slurm contabilità abilitata
Il CloudFormation modello fornito genera uno CloudFormation stack con alcuni output definiti. Da Console di gestione AWS, è possibile visualizzare gli output nella scheda Output nella visualizzazione in **pila**. CloudFormation Per abilitare il Slurm accounting, alcuni di questi output devono essere utilizzati nel file di configurazione del AWS ParallelCluster cluster:
+ `DatabaseHost`: Utilizzato per il parametro di configurazione del [`Uri`](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-Database-Uri)cluster [`SlurmSettings`[`Database`](Scheduling-v3.md#Scheduling-v3-SlurmSettings-Database)](Scheduling-v3.md#Scheduling-v3-SlurmSettings)//.
+ `DatabaseAdminUser`: utilizzato per il valore del parametro di configurazione [`UserName`](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-Database-UserName)del cluster [`SlurmSettings`[`Database`](Scheduling-v3.md#Scheduling-v3-SlurmSettings-Database)](Scheduling-v3.md#Scheduling-v3-SlurmSettings)//.
+ `DatabaseSecretArn`: utilizzato per il parametro di configurazione [`PasswordSecretArn`](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-Database-PasswordSecretArn)del cluster [`SlurmSettings`[`Database`](Scheduling-v3.md#Scheduling-v3-SlurmSettings-Database)](Scheduling-v3.md#Scheduling-v3-SlurmSettings)//.
+ `DatabaseClientSecurityGroup`: Questo è il gruppo di sicurezza collegato al nodo principale del cluster definito nel parametro di [`SecurityGroups`](HeadNode-v3.md#yaml-HeadNode-Networking-SecurityGroups)configurazione [`HeadNode`[`Networking`](HeadNode-v3.md#HeadNode-v3-Networking)](HeadNode-v3.md)//.
Aggiorna i `Database` parametri del file di configurazione del cluster con i valori di output. Usa la [`pcluster`](pcluster-v3.md) CLI per creare il cluster.
```
$ pcluster create-cluster -n cluster-3.x -c path/to/cluster-config.yaml
```
Dopo aver creato il cluster, puoi iniziare a utilizzare Slurm comandi di contabilità come `sacctmgr` o`sacct`.
# Creazione di un cluster con un cluster esterno Slurmdbd contabilità
Scopri come configurare e creare un cluster con elementi esterni Slurmdbd contabilità. Per ulteriori informazioni, consulta [Slurm contabilità con AWS ParallelCluster](slurm-accounting-v3.md).
Quando si utilizza l'interfaccia a riga di AWS ParallelCluster comando (CLI) o l'API, si pagano solo le AWS risorse create quando si creano o si aggiornano AWS ParallelCluster immagini e cluster. Per ulteriori informazioni, consulta [AWS i servizi utilizzati](aws-services-v3.md) da. AWS ParallelCluster
L' AWS ParallelCluster interfaccia utente è basata su un'architettura serverless ed è possibile utilizzarla all'interno di AWS Free Tier categoria per la maggior parte dei casi. Per ulteriori informazioni, consulta [AWS ParallelCluster Costi dell'interfaccia utente](install-pcui-costs-v3.md).
In questo tutorial, utilizzi un modello di AWS CloudFormation creazione rapida per creare i componenti necessari per distribuire un'istanza Slurmdbd sullo stesso VPC del cluster. Il modello crea una configurazione di rete e sicurezza di base per la connessione tra il cluster e il database.
**Nota**
A partire da`version 3.10.0`, AWS ParallelCluster supporta Slurmdbd esterno con il parametro di configurazione del cluster. `SlurmSettings / ExternelSlurmdbd`
**Nota**
Il modello di creazione rapida funge da esempio. Questo modello non copre tutti i possibili casi d'uso. È tua responsabilità creare uno Slurmdbd esterno con la configurazione e la capacità appropriate per i tuoi carichi di lavoro di produzione.
**Prerequisiti:**
+ AWS ParallelCluster [è](install-v3-parallelcluster.md) installato.
+ AWS CLI [è installato e configurato.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Hai una [coppia di chiavi Amazon Elastic Compute Cloud](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Hai un AWS Identity and Access Management ruolo con le [autorizzazioni](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) necessarie per eseguire la [`pcluster`](pcluster-v3.md) CLI.
+ Hai un Slurm database contabile. Per seguire un tutorial sulla creazione Slurm database di contabilità, segui i passaggi 1 e 2 in [Creare lo stack del database di contabilità Slurm](tutorials_07_slurm-accounting-v3.md).
## Passaggio 1: creare lo stack Slurmdbd
In questo tutorial, usa un [template di CloudFormation creazione rapida (`us-east-1`) per creare](https://us-east-1.console.aws.amazon.com/cloudformation/home?region=us-east-1#/stacks/create/review?stackName=pcluster-slurm-dbd&templateURL=https://us-east-1-aws-parallelcluster.s3.amazonaws.com/templates/1-click/external-slurmdbd.json) uno stack Slurmdbd. Il modello richiede i seguenti input:
**Rete**
+ **VPCId**: L'ID VPC per avviare l'istanza Slurmdbd.
+ **SubnetId**: L'ID di sottorete per avviare l'istanza Slurmdbd.
+ **PrivatePrefix**: il prefisso CIDR del VPC.
+ **PrivateIp**: un IP privato secondario da assegnare all'istanza Slurmdbd.
**Connessioni database**
+ **DBMSClientSG**: Il gruppo di sicurezza da collegare all'istanza Slurmdbd. Questo gruppo di sicurezza dovrebbe consentire le connessioni tra il server del database e l'istanza Slurmdbd.
+ **DBMSDatabaseNome**: il nome del database.
+ **DBMSUsername**: il nome utente del database.
+ **DBMSPasswordSecretArn**: Il segreto contenente la password per il database.
+ **DBMSUri**: l'URI del server del database.
**Impostazioni a livello di istanza**
+ **InstanceType**: un tipo di istanza da utilizzare per l'istanza slurmdbd.
+ **KeyName**: una coppia di EC2 chiavi Amazon da usare per l'istanza slurmdbd.
**Impostazioni Slurmdbd**
+ **AMIID**: un AMI dell'istanza Slurmdbd. L'AMI dovrebbe essere un ParallelCluster AMI. La versione dell' ParallelCluster AMI determina la versione di Slurmdbd.
+ **MungeKeySecretArn**: Il segreto contenente la chiave munge da utilizzare per autenticare le comunicazioni tra Slurmdbd e i cluster.
+ **SlurmdbdPort**: Un numero di porta utilizzato da slurmdbd.
+ **EnableSlurmdbdSystemService**: abilita slurmdbd come servizio di sistema e lo fa funzionare all'avvio di un'istanza.
**avvertimento**
Se il database è stato creato da una versione diversa di SlurmDB, non utilizzare Slurmdbd come servizio di sistema.
Se il database contiene un numero elevato di voci, Slurm Database Daemon (SlurmDBD) potrebbe richiedere decine di minuti per aggiornare il database e non rispondere durante questo intervallo di tempo.
Prima dell'aggiornamento SlurmDB, effettua un backup del database. Per ulteriori informazioni, consultare la [.Slurm documentazione](https://slurm.schedmd.com/quickstart_admin.html#upgrade).
## Fase 2: Creare un cluster con elementi esterni Slurmdbd abilitato
Il CloudFormation modello fornito genera uno CloudFormation stack con alcuni output definiti.
Da Console di gestione AWS, visualizza la scheda **Output** nella CloudFormation pila per esaminare le entità create. Per abilitare il Slurm contabilizzazione, alcuni di questi output devono essere utilizzati nel file di AWS ParallelCluster configurazione:
+ **SlurmdbdPrivateIp**[: Utilizzato per il parametro di configurazione del cluster [SlurmSettings](Scheduling-v3.md#Scheduling-v3-SlurmSettings)/[ExternalSlurmdbd](Scheduling-v3.md#Scheduling-v3-SlurmSettings-ExternalSlurmdbd)/Host.](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-ExternalSlurmdbd-Host)
+ **SlurmdbdPort**: Utilizzato per il valore del [ SlurmSettings](Scheduling-v3.md#Scheduling-v3-SlurmSettings)parametro di configurazione del cluster [ ExternalSlurmdbd](Scheduling-v3.md#Scheduling-v3-SlurmSettings-ExternalSlurmdbd)//[Port](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-ExternalSlurmdbd-Port).
+ **AccountingClientSecurityGroup**[: Questo è il gruppo di sicurezza collegato al nodo principale del cluster definito nel parametro di configurazione [HeadNode](HeadNode-v3.md)/Networking /. [AdditionalSecurityGroups](HeadNode-v3.md#yaml-HeadNode-Networking-AdditionalSecurityGroups)](HeadNode-v3.md#HeadNode-v3-Networking)
Inoltre, dalla scheda **Parametri nella vista stack**: CloudFormation
+ **MungeKeySecretArn**: utilizzato per il valore del [SlurmSettings](Scheduling-v3.md#Scheduling-v3-SlurmSettings)parametro di configurazione/[MungeKeySecretArn](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-MungeKeySecretArn)cluster.
Aggiorna i parametri del database dei file dei file di configurazione del cluster con i valori di output. Usa pcluster per creare il cluster AWS CLI .
```
$ pcluster create-cluster -n cluster-3.x-c path/to/cluster-config.yaml
```
Dopo aver creato il cluster, puoi iniziare a usare Slurm comandi di contabilità come `sacctmgr` o`sacct`.
**avvertimento**
Traffico tra `ParallelCluster` e verso l'esterno SlurmDB non è crittografato. Si consiglia di eseguire il cluster e l'esterno SlurmDB in una rete affidabile.
# Ripristino a una versione precedente del documento AWS Systems Manager
Scoprite come ripristinare una versione precedente del documento AWS Systems Manager. Per ulteriori informazioni sui documenti SSM, vedere [AWS Systems Manager Documents](https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-ssm-docs.html) nella *AWS Systems Manager User Guide*.
Quando si utilizza l'interfaccia a riga di AWS ParallelCluster comando (CLI) o l'API, si pagano solo le AWS risorse create quando si creano o si aggiornano AWS ParallelCluster immagini e cluster. Per ulteriori informazioni, consulta [AWS servizi usati da AWS ParallelCluster](aws-services-v3.md).
**Prerequisiti:**
+ E Account AWS con le autorizzazioni per gestire i documenti SSM.
+ AWS CLI [È installato e configurato.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
## Ripristina una versione precedente del documento SSM
1. Nel tuo terminale, esegui il seguente comando per ottenere l'elenco dei documenti SSM esistenti di cui sei proprietario.
```
$ aws ssm list-documents --document-filter "key=Owner,value=Self"
```
1. Ripristina una versione precedente di un documento SSM. In questo esempio, torniamo a una versione precedente del documento. `SessionManagerRunShell` È possibile utilizzare il `SessionManagerRunShell` documento SSM per personalizzare ogni sessione della shell SSM che si avvia.
1. Trovate il `DocumentVersion` parametro per `SessionManagerRunShell` eseguendo il seguente comando:
```
$ aws ssm describe-document --name "SSM-SessionManagerRunShell"
{
"Document": {
"Hash": "...",
"HashType": "Sha256",
"Name": "SSM-SessionManagerRunShell",
"Owner": "123456789012",
"CreatedDate": "2023-02-20T19:04:32.390000+00:00",
"Status": "Active",
"DocumentVersion": "1",
"Parameters": [
{
"Name": "linuxcmd",
"Type": "String",
"Description": "The command to run on connection...",
"DefaultValue": "if [ -d '/opt/parallelcluster' ]; then source /opt/parallelcluster/cfnconfig; sudo su - $cfn_cluster_user; fi; /bin/bash"
}
],
"PlatformTypes": [
"Windows",
"Linux",
"MacOS"
],
"DocumentType": "Session",
"SchemaVersion": "1.0",
"LatestVersion": "2",
"DefaultVersion": "1",
"DocumentFormat": "JSON",
"Tags": []
}
}
```
La versione più recente è `2`.
1. Tornate alla versione precedente eseguendo il comando seguente:
```
$ aws ssm delete-document --name "SSM-SessionManagerRunShell" --document-version 2
```
1. Verificate che la versione del documento sia stata ripristinata eseguendo nuovamente il `describe-document` comando:
```
$ aws ssm describe-document --name "SSM-SessionManagerRunShell"
{
"Document": {
"Hash": "...",
"HashType": "Sha256",
"Name": "SSM-SessionManagerRunShell",
"Owner": "123456789012",
"CreatedDate": "2023-02-20T19:04:32.390000+00:00",
"Status": "Active",
"DocumentVersion": "1",
"Parameters": [
{
"Name": "linuxcmd",
"Type": "String",
"Description": "The command to run on connection...",
"DefaultValue": "if [ -d '/opt/parallelcluster' ]; then source /opt/parallelcluster/cfnconfig; sudo su - $cfn_cluster_user; fi; /bin/bash"
}
],
"PlatformTypes": [
"Windows",
"Linux",
"MacOS"
],
"DocumentType": "Session",
"SchemaVersion": "1.0",
"LatestVersion": "1",
"DefaultVersion": "1",
"DocumentFormat": "JSON",
"Tags": []
}
}
```
La versione più recente è `1`.
# Creazione di un cluster con CloudFormation
Scopri come creare un cluster con una risorsa AWS ParallelCluster CloudFormation personalizzata. Per ulteriori informazioni, consulta [AWS CloudFormation risorsa personalizzata](cloudformation-v3.md).
Quando si utilizza AWS ParallelCluster, si pagano solo le AWS risorse create quando si creano o si aggiornano AWS ParallelCluster immagini e cluster. Per ulteriori informazioni, consulta [AWS servizi usati da AWS ParallelCluster](aws-services-v3.md).
**Prerequisiti:**
+ AWS CLI [È installato e configurato](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ Una [coppia di chiavi Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Un ruolo IAM con le [autorizzazioni](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) necessarie per eseguire la [`pcluster`](pcluster-v3.md) CLI.
## Creazione di cluster con uno CloudFormation stack di creazione rapida
In questo tutorial, si utilizza uno stack di creazione rapida per distribuire un CloudFormation modello che crea un cluster e le seguenti risorse: AWS
+ Un root CloudFormation stack creato utilizzando uno stack di creazione rapida. CloudFormation
+ CloudFormation Stack annidati che includono policy predefinite, configurazione VPC predefinita e un provider di risorse personalizzato.
+ Un esempio di stack di AWS ParallelCluster cluster e un cluster a cui è possibile accedere ed eseguire lavori.
**Crea un cluster con AWS CloudFormation**
1. Accedi alla Console di gestione AWS.
1. Apri il [link di CloudFormation creazione rapida](https://us-east-1.console.aws.amazon.com/cloudformation/home?region=us-east-1#/stacks/create/review?stackName=mycluster&templateURL=https://us-east-1-aws-parallelcluster.s3.amazonaws.com/parallelcluster/3.15.0/templates/1-click/cluster-example.yaml) per creare le seguenti risorse nella CloudFormation console:
+ Uno CloudFormation stack annidato con un VPC con una sottorete pubblica e privata per l'esecuzione rispettivamente del nodo principale del cluster e dei nodi di calcolo.
+ Uno CloudFormation stack annidato con una risorsa personalizzata per la gestione del cluster AWS ParallelCluster .
+ Uno CloudFormation stack annidato con le politiche predefinite per la gestione del cluster.
+ Uno stack principale per CloudFormation gli stack annidati.
+ Un AWS ParallelCluster cluster con lo Slurm scheduler e un numero definito di nodi di calcolo.
![\[L'interfaccia utente per la creazione CloudFormation rapida della console.\]](http://docs.aws.amazon.com/it_it/parallelcluster/latest/ug/images/cfn-quick-create.png)
1. Nella sezione **Parametri **dello stack di creazione rapida**, immettete i valori per i seguenti parametri**:
1. Per **KeyName**, inserisci il nome della tua coppia di chiavi Amazon EC2.
1. Per **AvailabilityZone**, scegli una AZ per i nodi del cluster, `us-east-1a` ad esempio.
1. Seleziona le caselle per confermare ciascuna delle funzionalità di accesso nella parte inferiore della pagina.
1. Seleziona **Crea stack**.
1. Attendi che lo CloudFormation stack raggiunga lo `CREATE_COMPLETE` stato.
## Creazione di cluster con l'interfaccia CloudFormation a riga di comando (CLI)
In questo tutorial, si utilizza l'interfaccia a riga di AWS comando (CLI) CloudFormation per distribuire un CloudFormation modello che crea un cluster.
**Crea le seguenti risorse: AWS**
+ Una pila principale creata utilizzando uno CloudFormation stack di creazione CloudFormation rapida.
+ CloudFormation Stack annidati che includono policy predefinite, configurazione VPC predefinita e un provider di risorse personalizzato.
+ Uno stack di AWS ParallelCluster cluster di esempio e un cluster a cui è possibile accedere ed eseguire lavori.
Sostituiscilo*inputs highlighted in red*, ad esempio*keypair*, con i tuoi valori.
**Crea un cluster con AWS CloudFormation**
1. Crea un CloudFormation modello denominato `cluster_template.yaml` con il seguente contenuto:
```
AWSTemplateFormatVersion: '2010-09-09'
Description: > AWS ParallelCluster CloudFormation Template
Parameters:
KeyName:
Description: KeyPair to login to the head node
Type: AWS::EC2::KeyPair::KeyName
AvailabilityZone:
Description: Availability zone where instances will be launched
Type: AWS::EC2::AvailabilityZone::Name
Default: us-east-2a
Mappings:
ParallelCluster:
Constants:
Version: 3.15.0
Resources:
PclusterClusterProvider:
Type: AWS::CloudFormation::Stack
Properties:
TemplateURL: !Sub
- https://${AWS::Region}-aws-parallelcluster.s3.${AWS::Region}.${AWS::URLSuffix}/parallelcluster/${Version}/templates/custom_resource/cluster.yaml
- { Version: !FindInMap [ParallelCluster, Constants, Version] }
PclusterVpc:
Type: AWS::CloudFormation::Stack
Properties:
Parameters:
PublicCIDR: 10.0.0.0/24
PrivateCIDR: 10.0.16.0/20
AvailabilityZone: !Ref AvailabilityZone
TemplateURL: !Sub
- https://${AWS::Region}-aws-parallelcluster.s3.${AWS::Region}.${AWS::URLSuffix}/parallelcluster/${Version}/templates/networking/public-private-${Version}.cfn.json
- { Version: !FindInMap [ParallelCluster, Constants, Version ] }
PclusterCluster:
Type: Custom::PclusterCluster
Properties:
ServiceToken: !GetAtt [ PclusterClusterProvider , Outputs.ServiceToken ]
ClusterName: !Sub 'c-${AWS::StackName}'
ClusterConfiguration:
Image:
Os: alinux2
HeadNode:
InstanceType: t2.medium
Networking:
SubnetId: !GetAtt [ PclusterVpc , Outputs.PublicSubnetId ]
Ssh:
KeyName: !Ref KeyName
Scheduling:
Scheduler: slurm
SlurmQueues:
- Name: queue0
ComputeResources:
- Name: queue0-cr0
InstanceType: t2.micro
Networking:
SubnetIds:
- !GetAtt [ PclusterVpc , Outputs.PrivateSubnetId ]
Outputs:
HeadNodeIp:
Description: The Public IP address of the HeadNode
Value: !GetAtt [ PclusterCluster, headNode.publicIpAddress ]
```
1. Esegui il seguente comando AWS CLI per distribuire lo CloudFormation stack per la creazione e la gestione del cluster.
```
$ aws cloudformation deploy --template-file ./cluster_template.yaml \
--stack-name mycluster \
--parameter-overrides KeyName=keypair \
AvailabilityZone=us-east-2b \
--capabilities CAPABILITY_NAMED_IAM CAPABILITY_AUTO_EXPAND
```
## Visualizza l'output del cluster CloudFormation
Visualizza l'output del CloudFormation cluster per ottenere dettagli utili sul cluster. La `ValidationMessages` proprietà aggiunta fornisce l'accesso ai messaggi di convalida dalle operazioni di creazione e aggiornamento del cluster.
1. Vai alla [CloudFormation console](https://console.aws.amazon.com/cloudformation/home) e seleziona lo stack che include la tua risorsa AWS ParallelCluster personalizzata.
1. Scegli **i dettagli dello stack** e seleziona la scheda **Output**.
![\[La tabella degli CloudFormation output della console che mostra i valori per e. HeadNodeIp ValidationMessages\]](http://docs.aws.amazon.com/it_it/parallelcluster/latest/ug/images/cfn-outputs.png)
I messaggi di convalida potrebbero essere troncati. Per ulteriori informazioni su come recuperare i log, vedere. [AWS ParallelCluster risoluzione dei problemi](troubleshooting-v3.md)
## Accedi al tuo cluster
Accedi al cluster.
**`ssh`nel nodo principale del cluster**
1. Una volta completata la distribuzione CloudFormation dello stack, ottieni l'indirizzo IP del nodo principale con il seguente comando:
```
$ HEAD_NODE_IP=$(aws cloudformation describe-stacks --stack-name=mycluster --query "Stacks|[0].Outputs[?OutputKey=='HeadNodeIp']|[0].OutputValue" --output=text)
```
È inoltre possibile recuperare l'indirizzo IP del nodo principale dal **HeadNodeIp**parametro nella scheda **Outputs** dello stack del cluster nella console. CloudFormation
Puoi trovare l'indirizzo IP del nodo principale qui perché è stato aggiunto nella `Outputs` sezione del CloudFormation modello di cluster, in particolare per questo cluster di esempio.
1. Connect al nodo principale del cluster eseguendo il comando seguente:
```
$ ssh -i keyname.pem ec2-user@$HEAD_NODE_IP
```
## Eliminazione
Elimina il cluster.
1. Esegui il seguente comando AWS CLI per eliminare lo CloudFormation stack e il cluster.
```
$ aws cloudformation delete-stack --stack-name=mycluster
```
1. Controlla lo stato di eliminazione dello stack eseguendo il comando seguente.
```
$ aws cloudformation describe-stacks --stack-name=mycluster
```
# Implementa l' ParallelCluster API con Terraform
In questo tutorial, definirai un semplice progetto Terraform per implementare un'API. ParallelCluster
**Prerequisiti**
+ Terraform v1.5.7\$1 è installato.
+ Ruolo IAM con le autorizzazioni per distribuire l'API. ParallelCluster Per informazioni, consulta [Autorizzazioni richieste](tutorial-deploy-terraform-permissions.md).
# Definisci un progetto Terraform
In questo tutorial, definirai un progetto Terraform.
1. Crea una directory chiamata`my-pcluster-api`.
Tutti i file che creerai si troveranno all'interno di questa directory.
1. Crea il file `provider.tf` per configurare il AWS provider.
```
provider "aws" {
region = var.region
profile = var.profile
}
```
1. Crea il file `main.tf` per definire le risorse utilizzando il ParallelCluster modulo.
```
module "parallelcluster_pcluster_api" {
source = "aws-tf/parallelcluster/aws//modules/pcluster_api"
version = "1.1.0"
region = var.region
api_stack_name = var.api_stack_name
api_version = var.api_version
parameters = {
EnableIamAdminAccess = "true"
}
}
```
1. Crea il file `variables.tf` per definire le variabili che possono essere iniettate per questo progetto.
```
variable "region" {
description = "The region the ParallelCluster API is deployed in."
type = string
default = "us-east-1"
}
variable "profile" {
type = string
description = "The AWS profile used to deploy the clusters."
default = null
}
variable "api_stack_name" {
type = string
description = "The name of the CloudFormation stack used to deploy the ParallelCluster API."
default = "ParallelCluster"
}
variable "api_version" {
type = string
description = "The version of the ParallelCluster API."
}
```
1. Crea il file `terraform.tfvars` per impostare valori arbitrari per le variabili.
Il file seguente implementa un' ParallelCluster API 3.11.1 `us-east-1` utilizzando il nome dello stack. `MyParallelClusterAPI-3111` Potrai fare riferimento a questa distribuzione dell' ParallelCluster API utilizzando il nome dello stack.
**Nota**
L'`api_version`assegnazione nel codice seguente può essere sostituita con qualsiasi versione supportata AWS ParallelCluster .
```
region = "us-east-1"
api_stack_name = "MyParallelClusterAPI-3111"
api_version = "3.11.1"
```
1. Crea il file `outputs.tf` per definire gli output restituiti da questo progetto.
```
output "pcluster_api_stack_outputs" {
value = module.parallelcluster_pcluster_api.stack_outputs
}
```
La cartella del progetto è:
```
my-pcluster-api
├── main.tf - Terraform entrypoint to define the resources using the ParallelCluster module.
├── outputs.tf - Defines the outputs returned by Terraform.
├── providers.tf - Configures the AWS provider.
├── terraform.tfvars - Set the arbitrary values for the variables, i.e. region, PCAPI version, PCAPI stack name
└── variables.tf - Defines the variables, e.g. region, PCAPI version, PCAPI stack name.
```
# Distribuzione dell'API
Per distribuire l'API, esegui i comandi Terraform standard nell'ordine.
1. Compila il progetto:
```
terraform init
```
1. Definisci il piano di implementazione:
```
terraform plan -out tfplan
```
1. Implementa il piano:
```
terraform apply tfplan
```
# Autorizzazioni richieste
Sono necessarie le seguenti autorizzazioni per distribuire l'API con Terraform: ParallelCluster
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"cloudformation:DescribeStacks",
"cloudformation:GetTemplate"
],
"Resource": "arn:aws:cloudformation:us-east-1:111122223333:stack/*",
"Effect": "Allow",
"Sid": "CloudFormationRead"
},
{
"Action": [
"cloudformation:CreateStack",
"cloudformation:DeleteStack",
"cloudformation:CreateChangeSet"
],
"Resource": "arn:aws:cloudformation:us-east-1:111122223333:stack/MyParallelClusterAPI*",
"Effect": "Allow",
"Sid": "CloudFormationWrite"
},
{
"Action": [
"cloudformation:CreateChangeSet"
],
"Resource": [
"arn:aws:cloudformation:us-east-1:111122223333:aws:transform/Include",
"arn:aws:cloudformation:us-east-1:111122223333:aws:transform/Serverless-2016-10-31"
],
"Effect": "Allow",
"Sid": "CloudFormationTransformWrite"
},
{
"Action": [
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:us-east-1:111122223333:*-aws-parallelcluster/parallelcluster/*/api/ParallelCluster.openapi.yaml",
"arn:aws:s3:us-east-1:111122223333:*-aws-parallelcluster/parallelcluster/*/layers/aws-parallelcluster/lambda-layer.zip"
],
"Effect": "Allow",
"Sid": "S3ParallelClusterArtifacts"
},
{
"Action": [
"iam:CreateRole",
"iam:DeleteRole",
"iam:GetRole",
"iam:CreatePolicy",
"iam:DeletePolicy",
"iam:GetPolicy",
"iam:GetRolePolicy",
"iam:AttachRolePolicy",
"iam:DetachRolePolicy",
"iam:PutRolePolicy",
"iam:DeleteRolePolicy",
"iam:ListPolicyVersions"
],
"Resource": [
"arn:aws:iam::111122223333:role/*",
"arn:aws:iam::111122223333:policy/*"
],
"Effect": "Allow",
"Sid": "IAM"
},
{
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::111122223333:role/ParallelClusterLambdaRole-*",
"arn:aws:iam::111122223333:role/APIGatewayExecutionRole-*"
],
"Effect": "Allow",
"Sid": "IAMPassRole"
},
{
"Action": [
"lambda:CreateFunction",
"lambda:DeleteFunction",
"lambda:GetFunction",
"lambda:PublishLayerVersion",
"lambda:DeleteLayerVersion",
"lambda:GetLayerVersion",
"lambda:TagResource",
"lambda:UntagResource"
],
"Resource": [
"arn:aws:lambda:us-east-1:111122223333:layer:PCLayer-*",
"arn:aws:lambda:us-east-1:111122223333:function:*-ParallelClusterFunction-*"
],
"Effect": "Allow",
"Sid": "Lambda"
},
{
"Action": [
"logs:CreateLogGroup",
"logs:DeleteLogGroup",
"logs:DescribeLogGroups",
"logs:PutRetentionPolicy",
"logs:TagLogGroup",
"logs:UntagLogGroup"
],
"Resource": [
"arn:aws:logs:us-east-1:111122223333:log-group:/aws/lambda/*-ParallelClusterFunction-*"
],
"Effect": "Allow",
"Sid": "Logs"
},
{
"Action": [
"apigateway:DELETE",
"apigateway:GET",
"apigateway:PATCH",
"apigateway:POST",
"apigateway:PUT",
"apigateway:UpdateRestApiPolicy"
],
"Resource": [
"arn:aws:apigateway:us-east-1::/restapis",
"arn:aws:apigateway:us-east-1::/restapis/*",
"arn:aws:apigateway:us-east-1::/tags/*"
],
"Effect": "Allow",
"Sid": "APIGateway"
}
]
}
```
------
# Creare un cluster con Terraform
Quando si utilizza AWS ParallelCluster, si pagano solo le AWS risorse create quando si creano o si aggiornano AWS ParallelCluster immagini e cluster. Per ulteriori informazioni, consulta [AWS servizi usati da AWS ParallelCluster](aws-services-v3.md).
**Prerequisiti**
+ Terraform v1.5.7\$1 è installato.
+ [AWS ParallelCluster API](api-reference-v3.md)v3.8.0\$1 è distribuito nel tuo account. Per informazioni, consulta [Implementa l' ParallelCluster API con Terraform](tutorial-deploy-terraform.md).
+ Ruolo IAM con le autorizzazioni per richiamare l'API. ParallelCluster Vedi [Autorizzazioni richieste]
# Definisci un progetto Terraform
In questo tutorial, definirai un semplice progetto Terraform per distribuire un cluster.
1. Crea una directory chiamata. `my-clusters`
Tutti i file che creerai si troveranno all'interno di questa directory.
1. Crea il file `terraform.tf` per importare il ParallelCluster provider.
```
terraform {
required_version = ">= 1.5.7"
required_providers {
aws-parallelcluster = {
source = "aws-tf/aws-parallelcluster"
version = "~> 1.0"
}
}
}
```
1. Crea il file `providers.tf` per configurare i AWS provider ParallelCluster e.
```
provider "aws" {
region = var.region
profile = var.profile
}
provider "aws-parallelcluster" {
region = var.region
profile = var.profile
api_stack_name = var.api_stack_name
use_user_role = true
}
```
1. Crea il file `main.tf` per definire le risorse utilizzando il ParallelCluster modulo.
```
module "pcluster" {
source = "aws-tf/parallelcluster/aws"
version = "1.1.0"
region = var.region
api_stack_name = var.api_stack_name
api_version = var.api_version
deploy_pcluster_api = false
template_vars = local.config_vars
cluster_configs = local.cluster_configs
config_path = "config/clusters.yaml"
}
```
1. Crea il file `clusters.tf` per definire più cluster come variabili locali Terraform.
**Nota**
È possibile definire più cluster all'interno dell'elemento. `cluster_config` Per ogni cluster, è possibile definire in modo esplicito le proprietà del cluster all'interno delle variabili locali (vedere`DemoCluster01`) o fare riferimento a un file esterno (vedere`DemoCluster02`).
Per esaminare le proprietà del cluster che è possibile impostare all'interno dell'elemento di configurazione, vedere[File di configurazione del cluster](cluster-configuration-file-v3.md).
Per esaminare le opzioni che è possibile impostare per la creazione di cluster, vedere[`pcluster create-cluster`](pcluster.create-cluster-v3.md).
```
locals {
cluster_configs = {
DemoCluster01 : {
region : local.config_vars.region
rollbackOnFailure : false
validationFailureLevel : "WARNING"
suppressValidators : [
"type:KeyPairValidator"
]
configuration : {
Region : local.config_vars.region
Image : {
Os : "alinux2"
}
HeadNode : {
InstanceType : "t3.small"
Networking : {
SubnetId : local.config_vars.subnet
}
Iam : {
AdditionalIamPolicies : [
{ Policy : "arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore" }
]
}
}
Scheduling : {
Scheduler : "slurm"
SlurmQueues : [{
Name : "queue1"
CapacityType : "ONDEMAND"
Networking : {
SubnetIds : [local.config_vars.subnet]
}
Iam : {
AdditionalIamPolicies : [
{ Policy : "arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore" }
]
}
ComputeResources : [{
Name : "compute"
InstanceType : "t3.small"
MinCount : "1"
MaxCount : "4"
}]
}]
SlurmSettings : {
QueueUpdateStrategy : "TERMINATE"
}
}
}
}
DemoCluster02 : {
configuration : "config/cluster_config.yaml"
}
}
}
```
1. Crea il file `config/clusters.yaml` per definire più cluster come configurazione YAML.
```
DemoCluster03:
region: ${region}
rollbackOnFailure: true
validationFailureLevel: WARNING
suppressValidators:
- type:KeyPairValidator
configuration: config/cluster_config.yaml
DemoCluster04:
region: ${region}
rollbackOnFailure: false
configuration: config/cluster_config.yaml
```
1. Crea il file`config/cluster_config.yaml`, che è un file di ParallelCluster configurazione standard in cui è possibile inserire le variabili Terraform.
Per esaminare le proprietà del cluster che è possibile impostare all'interno dell'elemento di configurazione, vedere. [File di configurazione del cluster](cluster-configuration-file-v3.md)
```
Region: ${region}
Image:
Os: alinux2
HeadNode:
InstanceType: t3.small
Networking:
SubnetId: ${subnet}
Iam:
AdditionalIamPolicies:
- Policy: arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore
Scheduling:
Scheduler: slurm
SlurmQueues:
- Name: queue1
CapacityType: ONDEMAND
Networking:
SubnetIds:
- ${subnet}
Iam:
AdditionalIamPolicies:
- Policy: arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore
ComputeResources:
- Name: compute
InstanceType: t3.small
MinCount: 1
MaxCount: 5
SlurmSettings:
QueueUpdateStrategy: TERMINATE
```
1. Crea il file `clusters_vars.tf` per definire le variabili che possono essere inserite nelle configurazioni del cluster.
Questo file consente di definire valori dinamici che possono essere utilizzati nelle configurazioni del cluster, come regione e sottorete.
Questo esempio recupera i valori direttamente dalle variabili di progetto, ma potrebbe essere necessario utilizzare una logica personalizzata per determinarli.
```
locals {
config_vars = {
subnet = var.subnet_id
region = var.cluster_region
}
}
```
1. Create il file `variables.tf` per definire le variabili che possono essere inserite per questo progetto.
```
variable "region" {
description = "The region the ParallelCluster API is deployed in."
type = string
default = "us-east-1"
}
variable "cluster_region" {
description = "The region the clusters will be deployed in."
type = string
default = "us-east-1"
}
variable "profile" {
type = string
description = "The AWS profile used to deploy the clusters."
default = null
}
variable "subnet_id" {
type = string
description = "The id of the subnet to be used for the ParallelCluster instances."
}
variable "api_stack_name" {
type = string
description = "The name of the CloudFormation stack used to deploy the ParallelCluster API."
default = "ParallelCluster"
}
variable "api_version" {
type = string
description = "The version of the ParallelCluster API."
}
```
1. Crea il file `terraform.tfvars` per impostare valori arbitrari per le variabili.
Il file seguente distribuisce i cluster all'`eu-west-1`interno della sottorete`subnet-123456789`, utilizzando l' ParallelCluster API 3.11.1 esistente, che è già distribuita con il nome dello stack. `us-east-1` `MyParallelClusterAPI-3111`
```
region = "us-east-1"
api_stack_name = "MyParallelClusterAPI-3111"
api_version = "3.11.1"
cluster_region = "eu-west-1"
subnet_id = "subnet-123456789"
```
1. Crea il file per definire gli output restituiti `outputs.tf` da questo progetto.
```
output "clusters" {
value = module.pcluster.clusters
}
```
La cartella del progetto è:
```
my-clusters
├── config
│ ├── cluster_config.yaml - Cluster configuration, where terraform variables can be injected..
│ └── clusters.yaml - File listing all the clusters to deploy.
├── clusters.tf - Clusters defined as Terraform local variables.
├── clusters_vars.tf - Variables that can be injected into cluster configurations.
├── main.tf - Terraform entrypoint where the ParallelCluster module is configured.
├── outputs.tf - Defines the cluster as a Terraform output.
├── providers.tf - Configures the providers: ParallelCluster and AWS.
├── terraform.tf - Import the ParallelCluster provider.
├── terraform.tfvars - Defines values for variables, e.g. region, PCAPI stack name.
└── variables.tf - Defines the variables, e.g. region, PCAPI stack name.
```
# Distribuzione del cluster
Per distribuire il cluster, esegui i comandi Terraform standard nell'ordine.
**Nota**
Questo esempio presuppone che tu abbia già distribuito l' ParallelCluster API nel tuo account.
1. Compila il progetto:
```
terraform init
```
1. Definisci il piano di implementazione:
```
terraform plan -out tfplan
```
1. Implementa il piano:
```
terraform apply tfplan
```
## Implementa l' ParallelCluster API con i cluster
Se non hai distribuito l' ParallelCluster API e desideri distribuirla con i cluster, modifica i seguenti file:
+ `main.tf`
```
module "pcluster" {
source = "aws-tf/aws/parallelcluster"
version = "1.0.0"
region = var.region
api_stack_name = var.api_stack_name
api_version = var.api_version
deploy_pcluster_api = true
parameters = {
EnableIamAdminAccess = "true"
}
template_vars = local.config_vars
cluster_configs = local.cluster_configs
config_path = "config/clusters.yaml"
}
```
+ `providers.tf`
```
provider "aws-parallelcluster" {
region = var.region
profile = var.profile
endpoint = module.pcluster.pcluster_api_stack_outputs.ParallelClusterApiInvokeUrl
role_arn = module.pcluster.pcluster_api_stack_outputs.ParallelClusterApiUserRole
}
```
# Autorizzazioni richieste
Sono necessarie le seguenti autorizzazioni per distribuire un cluster con Terraform:
+ assume il ruolo dell' ParallelCluster API, che è responsabile dell'interazione con l'API ParallelCluster
+ descrivi lo CloudFormation stack dell' ParallelCluster API per verificarne l'esistenza e recuperarne i parametri e gli output
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": "sts:AssumeRole",
"Resource": "arn:aws:sts::111122223333:role/PCAPIUserRole-*",
"Effect": "Allow",
"Sid": "AssumePCAPIUserRole"
},
{
"Action": [
"cloudformation:DescribeStacks"
],
"Resource": "arn:aws:cloudformation:us-east-1:111122223333:stack/*",
"Effect": "Allow",
"Sid": "CloudFormation"
}
]
}
```
------
# Creazione di un'AMI personalizzata con Terraform
Quando si utilizza AWS ParallelCluster, si pagano solo le AWS risorse create quando si creano o si aggiornano AWS ParallelCluster immagini e cluster. Per ulteriori informazioni, consulta [AWS servizi usati da AWS ParallelCluster](aws-services-v3.md).
**Prerequisiti**
+ Terraform v1.5.7\$1 è installato.
+ [AWS ParallelCluster API](api-reference-v3.md)v3.8.0\$1 è distribuito nel tuo account. Per informazioni, consulta [Creare un cluster con Terraform](tutorial-create-cluster-terraform.md).
+ Ruolo IAM con le autorizzazioni per richiamare l'API. ParallelCluster Per informazioni, consulta [Autorizzazioni richieste](tutorial-create-ami-terraform-permissions.md).
# Definisci un progetto Terraform
In questo tutorial, definirai un semplice progetto Terraform per implementare un' ParallelCluster AMI personalizzata.
1. Crea una directory chiamata. `my-amis`
Tutti i file che creerai si troveranno all'interno di questa directory.
1. Crea il file `terraform.tf` per importare il ParallelCluster provider.
```
terraform {
required_version = ">= 1.5.7"
required_providers {
aws-parallelcluster = {
source = "aws-tf/aws-parallelcluster"
version = "~> 1.0"
}
}
}
```
1. Crea il file `providers.tf` per configurare i AWS provider ParallelCluster e.
```
provider "aws" {
region = var.region
profile = var.profile
}
provider "aws-parallelcluster" {
region = var.region
profile = var.profile
api_stack_name = var.api_stack_name
use_user_role = true
}
```
1. Crea il file `main.tf` per definire le risorse utilizzando il ParallelCluster modulo.
Per esaminare le proprietà dell'immagine che è possibile impostare all'interno dell'`image_configuration`elemento, vedere[Crea file di configurazione delle immagini](image-builder-configuration-file-v3.md).
Per esaminare le opzioni che è possibile impostare per la creazione di immagini, ad esempio `image_id` e`rollback_on_failure`, vedere[`pcluster build-image`](pcluster.build-image-v3.md).
```
data "aws-parallelcluster_list_official_images" "parent_image" {
region = var.region
os = var.os
architecture = var.architecture
}
resource "aws-parallelcluster_image" "demo01" {
image_id = "demo01"
image_configuration = yamlencode({
"Build":{
"InstanceType": "c5.2xlarge",
"ParentImage": data.aws-parallelcluster_list_official_images.parent_image.official_images[0].amiId,
"UpdateOsPackages": {"Enabled": false}
}
})
rollback_on_failure = false
}
```
1. Create il file `variables.tf` per definire le variabili che possono essere inserite per questo progetto.
```
variable "region" {
description = "The region the ParallelCluster API is deployed in."
type = string
default = "us-east-1"
}
variable "profile" {
type = string
description = "The AWS profile used to deploy the clusters."
default = null
}
variable "api_stack_name" {
type = string
description = "The name of the CloudFormation stack used to deploy the ParallelCluster API."
default = "ParallelCluster"
}
variable "api_version" {
type = string
description = "The version of the ParallelCluster API."
}
variable "os" {
type = string
description = "The OS of the ParallelCluster image."
}
variable "architecture" {
type = string
description = "The architecture of the ParallelCluster image."
}
```
1. Crea il file `terraform.tfvars` per impostare i tuoi valori arbitrari per le variabili.
Con il file seguente, distribuisci l'AMI personalizzata `us-east-1` basata sull'architettura Amazon Linux 2 per x86\$164, utilizzando l' ParallelCluster API 3.11.1 esistente che è già distribuita con il nome dello stack. `us-east-1` `MyParallelClusterAPI-3111`
```
region = "us-east-1"
api_stack_name = "MyParallelClusterAPI-3111"
api_version = "3.11.1"
os = "alinux2"
architecture = "x86_64"
```
1. Crea il file per definire gli output restituiti `outputs.tf` da questo progetto.
```
output "parent_image" {
value = data.aws-parallelcluster_list_official_images.parent_image.official_images[0]
}
output "custom_image" {
value = aws-parallelcluster_image.demo01
}
```
La cartella del progetto è:
```
my-amis
├── main.tf - Terraform entrypoint where the ParallelCluster module is configured.
├── outputs.tf - Defines the cluster as a Terraform output.
├── providers.tf - Configures the providers: ParallelCluster and AWS.
├── terraform.tf - Import the ParallelCluster provider.
├── terraform.tfvars - Defines values for variables, e.g. region, PCAPI stack name.
└── variables.tf - Defines the variables, e.g. region, PCAPI stack name.
```
# Implementa l'AMI
Per distribuire l'AMI, esegui i comandi Terraform standard nell'ordine.
1. Compila il progetto:
```
terraform init
```
1. Definisci il piano di implementazione:
```
terraform plan -out tfplan
```
1. Implementa il piano:
```
terraform apply tfplan
```
# Autorizzazioni richieste
Sono necessarie le seguenti autorizzazioni per distribuire un'AMI personalizzata con Terraform:
+ assume il ruolo dell' ParallelCluster API, che si occupa dell'interazione con l'API ParallelCluster
+ descrivi lo CloudFormation stack dell' ParallelCluster API, per verificarne l'esistenza e recuperarne i parametri e gli output
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": "sts:AssumeRole",
"Resource": "arn:aws:sts::111122223333:role/PCAPIUserRole-*",
"Effect": "Allow",
"Sid": "AssumePCAPIUserRole"
},
{
"Action": [
"cloudformation:DescribeStacks"
],
"Resource": "arn:aws:cloudformation:us-east-1:111122223333:stack/*",
"Effect": "Allow",
"Sid": "CloudFormation"
}
]
}
```
------
# AWS ParallelCluster Integrazione dell'interfaccia utente con Identity Center
L'obiettivo di questo tutorial è dimostrare come integrare l' AWS ParallelCluster interfaccia utente con IAM Identity Center per una soluzione Single Sign-On che unifica gli utenti in Active Directory e può essere condivisa con i cluster. AWS ParallelCluster
Quando si utilizza AWS ParallelCluster, si pagano solo le AWS risorse create quando si creano o si AWS ParallelCluster aggiornano immagini e cluster. Per ulteriori informazioni, consulta [AWS servizi usati da AWS ParallelCluster](aws-services-v3.md).
**Prerequisiti:**
+ Un' AWS ParallelCluster interfaccia utente esistente che può essere installata seguendo le istruzioni riportate [qui](install-pcui-v3.md).
+ Un'Active Directory gestita esistente, preferibilmente una che utilizzerai anche per [l' AWS ParallelCluster integrazione](tutorials_05_multi-user-ad.md).
## Abilita IAM Identity Center
Se disponi già di un centro di identità collegato al tuo AWS Managed Microsoft AD (Active Directory), puoi utilizzarlo e passare alla sezione **Aggiungere l'applicazione a IAM Identity** Center.
Se non disponi già di un centro di identità collegato a un AWS Managed Microsoft AD, segui i passaggi seguenti per configurarlo.
**Attivazione di Identity Center**
1. Nella console, accedi a IAM Identity Center. (Assicurati di trovarti nella regione in cui hai il tuo AWS Managed Microsoft AD.)
1. Fai clic sul pulsante **Abilita**, potrebbe essere richiesto se desideri abilitare le organizzazioni. Questo è un requisito, quindi puoi scegliere di abilitarlo. **Nota**: in questo modo invierai all'amministratore del tuo account un'email di conferma che dovrai seguire il link per confermare.
**Connessione di Identity Center a Managed AD**
1. Nella pagina successiva, dopo aver abilitato il centro di identità, dovresti vedere i passaggi di configurazione consigliati, nella fase 1, seleziona **Scegli la tua origine di identità**.
1. Nella sezione Origine dell'identità, fai clic sul menu a discesa **Azioni** (in alto a destra), quindi seleziona **Cambia fonte di identità**.
1. Seleziona **Active Directory**.
1. In **Directory esistenti**, scegli la tua directory.
1. Fare clic su Avanti.
1. Controlla le modifiche, scorri verso il basso, digita ACCETTA nella casella di testo per confermare, quindi fai clic su **Cambia origine dell'identità**.
1. Attendi il completamento delle modifiche, quindi dovresti vedere un banner verde in alto.
**Sincronizzazione di utenti e gruppi con Identity Center**
1. Nel banner verde, fai clic su **Avvia configurazione guidata** (pulsante in alto a destra)
![\[Schermata che evidenzia il pulsante Avvia configurazione guidata.\]](http://docs.aws.amazon.com/it_it/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_start_guided_setup_1.png)
1. **Nella sezione **Configura le mappature degli attributi**, fai clic su Avanti**
1. **Nella sezione Configura l'ambito di sincronizzazione, digita il nome degli utenti che desideri sincronizzare con Identity Center, quindi fai clic su Aggiungi**
1. **Una volta terminata l'aggiunta di utenti e gruppi, fai clic su Avanti**
![\[Schermata che evidenzia il pulsante Avanti.\]](http://docs.aws.amazon.com/it_it/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_guided_setup_add_users_groups_2.png)
1. **Controlla le modifiche, quindi fai clic su Salva configurazione**
1. Se nella schermata successiva viene visualizzato un avviso relativo alla mancata sincronizzazione degli utenti, seleziona il **pulsante Riprendi la sincronizzazione** in alto a destra.
1. Successivamente, per abilitare gli utenti, nella scheda **Utenti** a sinistra, seleziona un utente, quindi fai clic su **Abilita accesso utente > **Abilita** accesso utente**
**Nota**: potrebbe essere necessario selezionare Riprendi sincronizzazione se hai un banner di avviso in alto e poi attendi che gli utenti si sincronizzino (prova il pulsante di aggiornamento per vedere se sono già sincronizzati).
![\[Schermata che evidenzia la scheda Utenti.\]](http://docs.aws.amazon.com/it_it/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_enable_user_access_3.png)
## Aggiungere l'applicazione a IAM Identity Center
Dopo aver sincronizzato gli utenti con IAM Identity Center, dovrai aggiungere una nuova applicazione. Questo configura quali applicazioni abilitate all'SSO saranno disponibili sul tuo portale IAM Identity Center. In questo caso, aggiungeremo l' AWS ParallelCluster interfaccia utente come applicazione mentre IAM Identity Center sarà il provider di identità.
Il passaggio successivo aggiungerà l' AWS ParallelCluster interfaccia utente come applicazione in IAM Identity Center. AWS ParallelCluster L'interfaccia utente è un portale web che aiuta l'utente a gestire i propri cluster. Per ulteriori informazioni, consulta [AWS ParallelCluster UI](pcui-using-v3.md).
**Configurazione dell'applicazione in Identity Center**
1. In **IAM Identity Center** > **Applicazioni** (nella barra del menu a sinistra, fai clic su Applicazioni)
1. Fai clic su **Aggiungi applicazione**
1. Seleziona **Aggiungi un'applicazione SAML 2.0 personalizzata**
1. **Fai clic su Avanti**
1. Seleziona il nome visualizzato e la descrizione che desideri utilizzare (ad esempio PCUI e AWS ParallelCluster UI)
1. Nella sezione **Metadati IAM Identity Center**, copia il link per il file di metadati IAM Identity Center SAML e salvalo per utilizzarlo in un secondo momento. Questo verrà utilizzato per configurare l'SSO sull'app web
1. In **Proprietà dell'applicazione**, nell'URL di avvio dell'applicazione, inserisci il tuo indirizzo PCUI. **Puoi trovarlo accedendo alla CloudFormation console, selezionando lo stack che corrisponde a PCUI (ad esempio parallelcluster-ui) e andando alla scheda Output per trovare** ParallelCluster UIUrl
ad esempio https://m2iwazsi1j.execute-api.us-east-1.amazonaws.com
1. In **Metadati dell'applicazione**, scegli **Digita manualmente i valori dei metadati**. Fornisci quindi i seguenti valori.
1. **Importante**: assicurati di sostituire i valori domain-prefix, region e userpool-id con informazioni specifiche del tuo ambiente.
1. **Il prefisso del dominio, la regione e l'userpool-id possono essere ottenuti aprendo la console Amazon Cognito > User **pools****
![\[Schermata che evidenzia il nome del pool di utenti nei pool di utenti di Cognito\]](http://docs.aws.amazon.com/it_it/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_user_pools_4.png)
1. Seleziona il pool di utenti che corrisponde a PCUI (che avrà un nome di pool di utenti come PCUI-CD8A2-Cognito-153 EK3 TO45 S98-UserPool)
1. **Vai** a Integrazione delle app
![\[Schermata che evidenzia il Dominio Cognito nella scheda Integrazione app\]](http://docs.aws.amazon.com/it_it/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_app_integration_5.png)
1. URL dell'Application Assertion Consumer Service (ACS): https://.auth. .amazoncognito. com/saml2/idpresponse
Destinatari SAML dell'applicazione: urn:amazon:cognito:sp:
1. Seleziona **Invia**. **Quindi, vai alla pagina dei dettagli dell'applicazione che hai aggiunto.**
1. Seleziona l'elenco a discesa **Azioni** e scegli **Modifica mappature degli attributi**. Quindi, fornisci i seguenti attributi.
1. Attributo utente nell'applicazione: **soggetto** (Nota: l'**oggetto** è precompilato). **→ Esegue il mapping a questo valore di stringa o attributo utente in IAM Identity Center: **\$1 \$1user:email\$1, Format: emailAddress****
1. **Attributo utente nell'applicazione: **email → Esegue** il mapping a questo valore di stringa o attributo utente in IAM Identity Center: **\$1 \$1user:email**\$1, Formato: unspecified**
![\[Schermata che evidenzia la sezione Mappature degli attributi per PCUI\]](http://docs.aws.amazon.com/it_it/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_attribute_mappings_PCUI_6.png)
1. Salvare le modifiche.
1. Scegli il pulsante **Assegna utenti, quindi assegna** l'utente all'applicazione. Questi sono gli utenti di Active Directory che avranno accesso all'interfaccia PCUI.
![\[Schermata che evidenzia Assegna utenti all'applicazione.\]](http://docs.aws.amazon.com/it_it/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_PCUI_App_7.png)
**Configura IAM Identity Center come IdP SAML nel tuo pool di utenti**
1. **Nelle impostazioni del pool di utenti, seleziona **Esperienza di accesso** > Aggiungi provider di identità**
![\[Schermata che evidenzia la scheda Esperienza di accesso\]](http://docs.aws.amazon.com/it_it/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_sign_in_expereince_8.png)
1. Scegli un IdP SAML
1. Per il nome del **provider**, fornisci **IdentityCenter**
1. In **Origine del documento di metadati** scegli **Inserisci l'URL dell'endpoint del documento di metadati e fornisci l'URL** copiato durante la configurazione dell'applicazione di Identity Center
1. In **Attributi**, per e-mail scegli email
![\[Schermata che evidenzia la scheda Esperienza di accesso\]](http://docs.aws.amazon.com/it_it/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazonw_cognito_SAML_9.png)
1. Seleziona **Aggiungi provider di identità**.
**Integra l'IdP con il client dell'app del pool di utenti**
1. Successivamente, nella sezione **Integrazione delle app** del tuo pool di utenti, scegli il client elencato nell'elenco dei **client dell'app**
![\[Schermata che evidenzia la scheda Esperienza di accesso\]](http://docs.aws.amazon.com/it_it/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_user_pool_app_client_10.png)
1. **In **Hosted** UI scegli Modifica**
1. Nella sezione **Provider di identità** scegli **IdentityCenter**anche.
1. Scegliere **Salva modifiche**.
**Convalida la configurazione**
1. Successivamente convalideremo la configurazione che abbiamo appena creato accedendo a PCUI. Accedi al tuo portale PCUI e ora dovresti vedere un'opzione per accedere con il tuo ID aziendale:
![\[Schermata che evidenzia la scheda Esperienza di accesso\]](http://docs.aws.amazon.com/it_it/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_validate_step_11.png)
1. Facendo clic sul **IdentityCenter**pulsante dovresti accedere al login IAM Identity Center IdP seguito da una pagina con le tue applicazioni che include PCUI, apri quell'applicazione.
1. Quando arrivi alla schermata seguente, l'utente sarà stato aggiunto al pool di utenti di Cognito.
![\[Schermata che evidenzia la scheda Esperienza di accesso\]](http://docs.aws.amazon.com/it_it/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_continue_with_IC_12.png)
**Rendi il tuo utente un amministratore**
1. Ora vai alla **console **Amazon Cognito** > Pool di utenti e seleziona l'utente** appena creato, che dovrebbe avere il prefisso identitycenter.
![\[Schermata che evidenzia la scheda Esperienza di accesso\]](http://docs.aws.amazon.com/it_it/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_user_pools_new_created_user_13.png)
1. **In **Appartenenze al gruppo** seleziona **Aggiungi utente al gruppo**, scegli **amministratore** e fai clic su Aggiungi.**
1. Ora, quando fai clic su **Continua con**, IdentityCenter verrai indirizzato alla pagina dell' AWS ParallelCluster interfaccia utente.
# Esecuzione di lavori containerizzati con Pyxis
Scopri come creare un cluster in grado di eseguire lavori containerizzati utilizzando Pyxis, un plug-in SPANK per gestire i lavori containerizzati in SLURM. I contenitori in Pyxis sono gestiti da Enroot, uno strumento per trasformare le immagini tradizionali in sandbox non privilegiate. container/OS [https://github.com/NVIDIA/pyxis](https://github.com/NVIDIA/pyxis)
**Nota**
Questa funzionalità è disponibile con la versione 3.11.1 AWS ParallelCluster
Gli script di questo tutorial spostano (`mv`) alcuni file, eliminandoli dalle loro posizioni originali. Se volete conservare le copie di questi file nelle loro posizioni originali, modificate gli script per usare invece il comando copy (`cp`).
Quando si utilizza AWS ParallelCluster, si pagano solo le AWS risorse create quando si creano o si aggiornano AWS ParallelCluster immagini e cluster. Per ulteriori informazioni, consulta [AWS servizi usati da AWS ParallelCluster](aws-services-v3.md).
**Prerequisiti:**
+ AWS CLI È [installato e configurato](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ Una [coppia di chiavi Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html). .
+ Un ruolo IAM con le [autorizzazioni](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) necessarie per eseguire la [CLI di pcluster](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
## Creazione del cluster
A partire dalla AWS ParallelCluster 3.11.1, tutte le versioni ufficiali AMIs vengono fornite con Pyxis ed Enroot preinstallati. In particolare, SLURM viene ricompilato con il supporto Pyxis ed Enroot viene installato come binario nel sistema. Tuttavia, è necessario configurarli in base alle proprie esigenze specifiche. Le cartelle utilizzate da Enroot e Pyxis avranno un impatto critico sulle prestazioni del cluster. [Per ulteriori informazioni, consulta la documentazione di [Pyxis](https://github.com/NVIDIA/pyxis/wiki/Setup#slurm-plugstack-configuration) e la documentazione di Enroot.](https://github.com/NVIDIA/pyxis/wiki/Setup#enroot-configuration-example)
Per comodità, puoi trovare configurazioni di esempio per Pyxis, Enroot e SPANK all'interno. `/opt/parallelcluster/examples/`
Per distribuire un cluster utilizzando le configurazioni di esempio che abbiamo fornito, completa il seguente tutorial.
**Per creare il cluster con una configurazione di esempio**
Pyxis ed Enroot devono essere configurati sul nodo principale creando prima le directory persistenti e volatili per Enroot, quindi creando la directory di runtime per Pyxis e infine abilitando Pyxis come plug-in SPANK nell'intero cluster.
1. Esegui lo script seguente come azione [OnNodeConfigured](HeadNode-v3.md#yaml-HeadNode-CustomActions-OnNodeConfigured)personalizzata nel nodo principale per configurare Pyxis ed Enroot sul nodo principale.
```
#!/bin/bash
set -e
echo "Executing $0"
# Configure Enroot
ENROOT_PERSISTENT_DIR="/var/enroot"
ENROOT_VOLATILE_DIR="/run/enroot"
sudo mkdir -p $ENROOT_PERSISTENT_DIR
sudo chmod 1777 $ENROOT_PERSISTENT_DIR
sudo mkdir -p $ENROOT_VOLATILE_DIR
sudo chmod 1777 $ENROOT_VOLATILE_DIR
sudo mv /opt/parallelcluster/examples/enroot/enroot.conf /etc/enroot/enroot.conf
sudo chmod 0644 /etc/enroot/enroot.conf
# Configure Pyxis
PYXIS_RUNTIME_DIR="/run/pyxis"
sudo mkdir -p $PYXIS_RUNTIME_DIR
sudo chmod 1777 $PYXIS_RUNTIME_DIR
sudo mkdir -p /opt/slurm/etc/plugstack.conf.d/
sudo mv /opt/parallelcluster/examples/spank/plugstack.conf /opt/slurm/etc/
sudo mv /opt/parallelcluster/examples/pyxis/pyxis.conf /opt/slurm/etc/plugstack.conf.d/
sudo -i scontrol reconfigure
```
1. Pyxis ed Enroot devono essere configurati sulla flotta di calcolo creando le directory persistenti e volatili per Enroot e la directory di runtime per Pyxis. Esegui lo script seguente come azione [OnNodeStart](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-CustomActions-OnNodeStart)personalizzata nei nodi di calcolo per configurare Pyxis ed Enroot sulla flotta di elaborazione.
```
#!/bin/bash
set -e
echo "Executing $0"
# Configure Enroot
ENROOT_PERSISTENT_DIR="/var/enroot"
ENROOT_VOLATILE_DIR="/run/enroot"
ENROOT_CONF_DIR="/etc/enroot"
sudo mkdir -p $ENROOT_PERSISTENT_DIR
sudo chmod 1777 $ENROOT_PERSISTENT_DIR
sudo mkdir -p $ENROOT_VOLATILE_DIR
sudo chmod 1777 $ENROOT_VOLATILE_DIR
sudo mkdir -p $ENROOT_CONF_DIR
sudo chmod 1777 $ENROOT_CONF_DIR
sudo mv /opt/parallelcluster/examples/enroot/enroot.conf /etc/enroot/enroot.conf
sudo chmod 0644 /etc/enroot/enroot.conf
# Configure Pyxis
PYXIS_RUNTIME_DIR="/run/pyxis"
sudo mkdir -p $PYXIS_RUNTIME_DIR
sudo chmod 1777 $PYXIS_RUNTIME_DIR
# In Ubuntu24.04 Apparmor blocks the creation of unprivileged user namespaces,
# which is required by Enroot. So to run Enroot, it is required to disable this restriction.
# See https://ubuntu.com/blog/ubuntu-23-10-restricted-unprivileged-user-namespaces
source /etc/os-release
if [ "${ID}${VERSION_ID}" == "ubuntu24.04" ]; then
echo "kernel.apparmor_restrict_unprivileged_userns = 0" | sudo tee /etc/sysctl.d/99-pcluster-disable-apparmor-restrict-unprivileged-userns.conf
sudo sysctl --system
fi
```
## Invia offerte di lavoro
Ora che Pyxis è configurato nel cluster, è possibile inviare lavori containerizzati utilizzando i comandi sbatch e srun, che ora sono arricchiti con opzioni specifiche del contenitore.
```
# Submitting an interactive job
srun -N 2 --container-image docker://ubuntu:22.04 hostname
# Submitting a batch job
sbatch -N 2 --wrap='srun --container-image docker://ubuntu:22.04 hostname'
```
# Creazione di un cluster con un Lustre abilitato per EFA FSx
In questo tutorial, creerai un cluster che utilizza un file system FSx Lustre abilitato all'EFA come storage condiviso. L'utilizzo di un file system FSx Lustre con EFA abilitato può fornire un incremento delle prestazioni fino a 8 volte. *Per verificare se un file system compatibile [con EFA è ciò di cui hai bisogno, consulta la sezione Utilizzo dei file system abilitati per EFA nella Guida per l'utente di for Lustre](https://docs.aws.amazon.com/fsx/latest/LustreGuide/efa-file-systems.html). FSx *
Quando si utilizza AWS ParallelCluster, si pagano solo AWS le risorse create durante la creazione o l'aggiornamento di immagini e cluster. AWS ParallelCluster Per ulteriori informazioni, consulta [AWS servizi usati da AWS ParallelCluster](aws-services-v3.md).
## Requisiti
+ La AWS CLI è [installata e](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) configurata.
+ La ParallelCluster CLI è [installata e](install-v3-parallelcluster.md) configurata.
+ Una [coppia di chiavi Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) per accedere al cluster.
+ Un ruolo IAM con le [autorizzazioni](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) necessarie per eseguire la ParallelCluster CLI.
## Creazione di gruppi di sicurezza
Crea due gruppi di sicurezza nello stesso VPC in cui verranno distribuiti il cluster e il file system: uno per il client in esecuzione sui nodi del cluster e uno per il file system.
```
# Create security group for the FSx client
aws ec2 create-security-group \
--group-name Fsx-Client-SecurityGroup \
--description "Allow traffic for the FSx Lustre client" \
--vpc-id vpc-cluster \
--region region
# Create security group for the FSx file system
aws ec2 create-security-group \
--group-name Fsx-FileSystem-SecurityGroup \
--description "Allow traffic for the FSx Lustre File System" \
--vpc-id vpc-cluster \
--region region
```
Nel resto del tutorial, assumeremo `sg-client` e `sg-file-system` siano gli ID dei gruppi di sicurezza rispettivamente del client e del file system.
Configura il gruppo di sicurezza per il client per consentire tutto il traffico in uscita verso il file system, come [richiesto da](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html#efa-start-security) EFA.
```
# Allow all outbound traffic from the client to the file system
aws ec2 authorize-security-group-egress \
--group-id sg-client \
--protocol -1 \
--port -1 \
--source-group sg-file-system \
--region region
```
Configura il gruppo di sicurezza per il file system per consentire tutto il inbound/outbound traffico interno e tutto il traffico in entrata dal client, come [richiesto](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html#efa-start-security) dall'EFA.
```
# Allow all inbound traffic within this security group
aws ec2 authorize-security-group-ingress \
--group-id sg-file-system \
--protocol -1 \
--port -1 \
--source-group sg-file-system \
--region region
# Allow all outbound traffic within this security group
aws ec2 authorize-security-group-egress \
--group-id sg-file-system \
--protocol -1 \
--port -1 \
--source-group sg-file-system \
--region region
# Allow all inbound traffic from the client
aws ec2 authorize-security-group-ingress \
--group-id sg-file-system \
--protocol -1 \
--port -1 \
--source-group sg-client \
--region region
# Allow all outbound traffic to the client
aws ec2 authorize-security-group-egress \
--group-id sg-file-system \
--protocol -1 \
--port -1 \
--source-group sg-client \
--region region
```
## Crea il file system
Crea il file system all'interno della stessa zona di disponibilità (AZ) in cui si troveranno i nodi di elaborazione e `subnet-compute-nodes` sostituiscilo con il relativo ID nel codice seguente. Ciò è necessario per consentire a EFA di funzionare con il file system. Nota che, come parte della creazione del file system, abilitiamo EFA utilizzando la EfaEnable proprietà.
```
aws fsx create-file-system \
--file-system-type LUSTRE \
--storage-capacity 38400 \
--storage-type SSD \
--subnet-ids subnet-compute-nodes \
--security-group-ids sg-file-system \
--lustre-configuration DeploymentType=PERSISTENT_2,PerUnitStorageThroughput=125,EfaEnabled=true,MetadataConfiguration={Mode=AUTOMATIC} \
--region region
```
Prendete nota dell'id del file system restituito dal comando precedente. Nel resto del tutorial, sostituiscilo `fs-id` con questo id del file system.
## Creazione del cluster
1. Crea il cluster con le seguenti configurazioni impostate nel file di configurazione AWS ParallelCluster YAML:
1. AMI basata su un sistema operativo supportato, come Ubuntu 22.04.
1. I nodi di calcolo devono utilizzare un [tipo di istanza supportato da EFA con [Nitro v4\$1](https://docs.aws.amazon.com/ec2/latest/instancetypes/ec2-nitro-instances.html), ad esempio](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html#efa-instance-types) g6.16xlarge.
+ I nodi di calcolo devono trovarsi nella stessa AZ in cui si trova il file system.
+ I nodi di calcolo devono avere [Efa/Enabled](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-ComputeResources-Efa-Enabled) impostato su true.
+ I nodi di calcolo devono eseguire lo script di configurazione `configure-efa-fsx-lustre-client.sh` come azione personalizzata. [OnNodeStart](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-CustomActions-OnNodeStart) Lo script, fornito nella [documentazione FSx ufficiale](https://docs.aws.amazon.com/fsx/latest/LustreGuide/configure-efa-clients.html) e offerto nel nostro bucket pubblico per comodità, ha lo scopo di configurare il client FSx Lustre sui nodi di calcolo per consentire loro di utilizzare EFA.
1. Crea un file di configurazione del cluster: `config.yaml`
```
Region: region
Image:
Os: ubuntu2204
HeadNode:
InstanceType: c5.xlarge
Networking:
SubnetId: subnet-xxxxxxxxxx
AdditionalSecurityGroups:
- sg-client
Ssh:
KeyName: my-ssh-key
Scheduling:
Scheduler: slurm
SlurmQueues:
- Name: q1
ComputeResources:
- Name: cr1
Instances:
- InstanceType: g6.16xlarge
MinCount: 1
MaxCount: 3
Efa:
Enabled: true
Networking:
SubnetIds:
- subnet-xxxxxxxxxx # Subnet in the same AZ where the file system is
AdditionalSecurityGroups:
- sg-client
PlacementGroup:
Enabled: false
CustomActions:
OnNodeStart:
Script: https://us-east-1-aws-parallelcluster.s3.us-east-1.amazonaws.com/scripts/fsx-lustre-efa/configure-efa-fsx-lustre-client.sh
SharedStorage:
- MountDir: /fsx
Name: my-fsxlustre-efa-external
StorageType: FsxLustre
FsxLustreSettings:
FileSystemId: fs-id
```
Quindi crea un cluster utilizzando quella configurazione:
```
pcluster create-cluster \
--cluster-name fsx-efa-tutorial \
--cluster-configuration config.yaml \
--region region
```
## La convalida FSx con EFA funziona
Per verificare che il traffico di rete Lustre utilizzi EFA, utilizzate `lnetctl` lo strumento Lustre in grado di mostrare il traffico di rete per una determinata interfaccia di rete. A tal fine, esegui i seguenti comandi in un nodo di calcolo:
```
# Take note of the number of packets flowing through the interface,
# which are specified in statistics:send_count and statistics:recv_count
sudo lnetctl net show --net efa -v
# Generate traffic to the file system
echo 'Hello World' > /fsx/hello-world.txt
# Take note of the number of packets flowing through the interface,
# which are specified in statistics:send_count and statistics:recv_count
sudo lnetctl net show --net efa -v
```
Se la funzionalità funziona, si prevede che il numero di pacchetti che fluiscono attraverso l'interfaccia aumenti.
# Supporta Nvidia-IMEX con istanza p6e-gb200
Questo tutorial mostra come iniziare a usare P6e-GB200, per sfruttare le AWS ParallelCluster massime prestazioni della GPU per l'addestramento e l'inferenza dell'IA. Le [istanze p6e-gb200.36xlarge sono disponibili solo tramite P6e](https://aws.amazon.com/ec2/instance-types/p6/), dove è Ultraserver Size ed è la dimensione che forma l'ultraserver. GB200 UltraServers `u-p6e-gb200x72` `p6e-gb200.36xlarge` [InstanceType](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-ComputeResources-InstanceType) [Al momento dell'acquisto, un Ultraserver sarà disponibile tramite un EC2 Capacity `u-p6e-gb200x72` Blocks for ML che avrà 18 istanze.](https://aws.amazon.com/ec2/capacityblocks/) `p6e-gb200.36xlarge` [Per ulteriori informazioni, consulta P6e-. GB200](https://aws.amazon.com/ec2/instance-types/p6/)
AWS ParallelCluster versione 3.14.0:
+ fornisce lo stack software NVIDIA completo (driver, CUDA, EFA, NVIDIA-IMEX) richiesto da questo tipo di istanza
+ crea configurazioni GB200 nvidia-imex per ultraserver P6e-
+ abilita e avvia il servizio per `nvidia-imex` P6e- ultraserver GB200
+ configura il plug-in di topologia Slurm Block in modo che ogni Ultraserver P6e-GB200 (un blocco di capacità EC2) sia uno Slurm Block della giusta dimensione (vedi la voce relativa alla versione 3.14.0). [Note di rilascio e cronologia dei documenti](document_history.md)
Tuttavia, GPU-to-GPU la comunicazione via cavo NVLink richiede configurazioni aggiuntive, in particolare un [https://docs.nvidia.com/multi-node-nvlink-systems/imex-guide/config.html#imex-service-node-configuration-file-location](https://docs.nvidia.com/multi-node-nvlink-systems/imex-guide/config.html#imex-service-node-configuration-file-location)file che contiene gli indirizzi IP dei nodi di calcolo in un dominio IMEX che non viene generato automaticamente. ParallelCluster Per facilitare la generazione di questo file, forniamo uno script prolog che rileva automaticamente il nodo di calcolo IPs e configura i [https://docs.nvidia.com/multi-node-nvlink-systems/imex-guide/config.html#imex-service-node-configuration-file-location](https://docs.nvidia.com/multi-node-nvlink-systems/imex-guide/config.html#imex-service-node-configuration-file-location)seguenti consigli di [NVIDIA IMEX Slurm](https://docs.nvidia.com/multi-node-nvlink-systems/imex-guide/deployment.html#job-scheduler-integration) Job Scheduler Integration. Questo tutorial illustra come creare lo script prolog, distribuirlo tramite un'azione personalizzata e convalidare la configurazione IMEX. HeadNode
**Nota**
P6e- GB200 è supportato a partire dalla versione AWS ParallelCluster 3.14.0 su Amazon Linux 2023, Ubuntu 22.04 e Ubuntu 24.04. [Per le versioni software dettagliate e un elenco aggiornato delle distribuzioni supportate, consulta il changelog.AWS ParallelCluster](https://github.com/aws/aws-parallelcluster/blob/develop/CHANGELOG.md)
## Crea uno script Prolog per gestire Nvidia-IMEX
**Limitazione:**
+ Questo script di prolog verrà eseguito al momento dell'invio di un lavoro esclusivo. Questo serve a garantire che un riavvio IMEX non interrompa i processi in esecuzione sui nodi P6e-GB200 che appartengono a un dominio IMEX.
Di seguito è riportato `91_nvidia_imex_prolog.sh` lo script da configurare come prolog in Slurm. Viene utilizzato per aggiornare automaticamente la configurazione nvidia-imex sui nodi di calcolo. [Il nome dello script ha il prefisso di `91` aderire alla convenzione di denominazione di SchedMD.](https://slurm.schedmd.com/prolog_epilog.html) Ciò garantisce che venga eseguito prima di qualsiasi altro script di prolog nella sequenza. Lo script riconfigura la configurazione del nodo NVIDIA Imex all'avvio di un processo e ricarica i daemon NVIDIA necessari.
**Nota**
Questo script non verrà eseguito nel caso in cui più lavori vengano avviati contemporaneamente sugli stessi nodi, pertanto suggeriamo di utilizzare il flag all'invio. `--exclusive`
```
#!/usr/bin/env bash
# This prolog script configures the NVIDIA IMEX on compute nodes involved in the job execution.
#
# In particular:
# - Checks whether the job is executed exclusively.
# If not, it exits immediately because it requires jobs to be executed exclusively.
# - Checks if it is running on a p6e-gb200 instance type.
# If not, it exits immediately because IMEX must be configured only on that instance type.
# - Checks if the IMEX service is enabled.
# If not, it exits immediately because IMEX must be enabled to get configured.
# - Creates the IMEX default channel.
# For more information about IMEX channels, see https://docs.nvidia.com/multi-node-nvlink-systems/imex-guide/imexchannels.html
# - Writes the private IP addresses of compute nodes into /etc/nvidia-imex/nodes_config.cfg.
# - Restarts the IMEX system service.
#
# REQUIREMENTS:
# - This prolog assumes to be run only with exclusive jobs.
LOG_FILE_PATH="/var/log/parallelcluster/nvidia-imex-prolog.log"
SCONTROL_CMD="/opt/slurm/bin/scontrol"
IMEX_START_TIMEOUT=60
IMEX_STOP_TIMEOUT=15
ALLOWED_INSTANCE_TYPES="^(p6e-gb200)"
IMEX_SERVICE="nvidia-imex"
IMEX_NODES_CONFIG="/etc/nvidia-imex/nodes_config.cfg"
function info() {
echo "$(date "+%Y-%m-%dT%H:%M:%S.%3N") [INFO] [PID:$$] [JOB:${SLURM_JOB_ID}] $1"
}
function warn() {
echo "$(date "+%Y-%m-%dT%H:%M:%S.%3N") [WARN] [PID:$$] [JOB:${SLURM_JOB_ID}] $1"
}
function error() {
echo "$(date "+%Y-%m-%dT%H:%M:%S.%3N") [ERROR] [PID:$$] [JOB:${SLURM_JOB_ID}] $1"
}
function error_exit() {
error "$1" && exit 1
}
function prolog_end() {
info "PROLOG End JobId=${SLURM_JOB_ID}: $0"
info "----------------"
exit 0
}
function get_instance_type() {
local token=$(curl -X PUT -s "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600")
curl -s -H "X-aws-ec2-metadata-token: ${token}" http://169.254.169.254/latest/meta-data/instance-type
}
function return_if_unsupported_instance_type() {
local instance_type=$(get_instance_type)
if [[ ! ${instance_type} =~ ${ALLOWED_INSTANCE_TYPES} ]]; then
info "Skipping IMEX configuration because instance type ${instance_type} does not support it"
prolog_end
fi
}
function return_if_imex_disabled() {
if ! systemctl is-enabled "${IMEX_SERVICE}" &>/dev/null; then
warn "Skipping IMEX configuration because system service ${IMEX_SERVICE} is not enabled"
prolog_end
fi
}
function return_if_job_is_not_exclusive() {
if [[ "${SLURM_JOB_OVERSUBSCRIBE}" =~ ^(NO|TOPO)$ ]]; then
info "Job is exclusive, proceeding with IMEX configuration"
else
info "Skipping IMEX configuration because the job is not exclusive"
prolog_end
fi
}
function get_ips_from_node_names() {
local _nodes=$1
${SCONTROL_CMD} -ao show node "${_nodes}" | sed 's/^.* NodeAddr=\([^ ]*\).*/\1/'
}
function get_compute_resource_name() {
local _queue_name_prefix=$1
local _slurmd_node_name=$2
echo "${_slurmd_node_name}" | sed -E "s/${_queue_name_prefix}(.+)-[0-9]+$/\1/"
}
function reload_imex() {
info "Stopping IMEX"
timeout ${IMEX_STOP_TIMEOUT} systemctl stop ${IMEX_SERVICE}
pkill -9 ${IMEX_SERVICE}
info "Restarting IMEX"
timeout ${IMEX_START_TIMEOUT} systemctl start ${IMEX_SERVICE}
}
function create_default_imex_channel() {
info "Creating IMEX default channel"
MAJOR_NUMBER=$(cat /proc/devices | grep nvidia-caps-imex-channels | cut -d' ' -f1)
if [ ! -d "/dev/nvidia-caps-imex-channels" ]; then
sudo mkdir /dev/nvidia-caps-imex-channels
fi
# Then check and create device node
if [ ! -e "/dev/nvidia-caps-imex-channels/channel0" ]; then
sudo mknod /dev/nvidia-caps-imex-channels/channel0 c $MAJOR_NUMBER 0
info "IMEX default channel created"
else
info "IMEX default channel already exists"
fi
}
{
info "PROLOG Start JobId=${SLURM_JOB_ID}: $0"
return_if_job_is_not_exclusive
return_if_unsupported_instance_type
return_if_imex_disabled
create_default_imex_channel
IPS_FROM_CR=$(get_ips_from_node_names "${SLURM_NODELIST}")
info "Node Names: ${SLURM_NODELIST}"
info "Node IPs: ${IPS_FROM_CR}"
info "IMEX Nodes Config: ${IMEX_NODES_CONFIG}"
info "Updating IMEX nodes config ${IMEX_NODES_CONFIG}"
echo "${IPS_FROM_CR}" > "${IMEX_NODES_CONFIG}"
reload_imex
prolog_end
} 2>&1 | tee -a "${LOG_FILE_PATH}" | logger -t "91_nvidia_imex_prolog"
```
## Crea lo script di HeadNode OnNodeStart azione personalizzato
Crea un'azione `install_custom_action.sh` personalizzata che scaricherà il suddetto script prolog in una directory condivisa a `/opt/slurm/etc/scripts/prolog.d/` cui accede Compute Nodes e imposterà le autorizzazioni appropriate per l'esecuzione.
```
#!/bin/bash
set -e
echo "Executing $0"
PROLOG_NVIDIA_IMEX=/opt/slurm/etc/scripts/prolog.d/91_nvidia_imex_prolog.sh
aws s3 cp "s3:///91_nvidia_imex_prolog.sh" "${PROLOG_NVIDIA_IMEX}"
chmod 0755 "${PROLOG_NVIDIA_IMEX}"
```
## Creazione del cluster
Crea un cluster che includa istanze P6e-. GB200 Di seguito è riportato un esempio di configurazione contenente SlurmQueues il tipo Ultraserver. `u-p6e-gb200x72`
P6e- GB200 è attualmente disponibile solo nelle Local Zones. Alcune [Local Zones non supportano un gateway NAT](https://docs.aws.amazon.com/local-zones/latest/ug/local-zones-connectivity-nat.html), quindi segui le [opzioni di connettività per Local Zones](https://docs.aws.amazon.com/local-zones/latest/ug/local-zones-connectivity.html) se ParallelCluster necessario per connetterti [Configurazione di gruppi di sicurezza per ambienti con restrizioni](security-groups-configuration.md) ai AWS Servizi. Segui [Avvia istanze con Capacity Blocks (CB)](launch-instances-capacity-blocks.md) (AWS ParallelClusterLaunch) poiché gli Ultraserver sono disponibili solo come blocchi di capacità.
```
HeadNode:
CustomActions:
OnNodeStart:
Script: s3:///install_custom_action.sh
S3Access:
- BucketName:
InstanceType:
Networking:
SubnetId:
Ssh:
KeyName:
Image:
Os: ubuntu2404
Scheduling:
Scheduler: slurm
SlurmSettings:
CustomSlurmSettings:
- PrologFlags: "Alloc,NoHold"
- MessageTimeout: 240
SlurmQueues:
- CapacityReservationTarget:
CapacityReservationId:
CapacityType: CAPACITY_BLOCK
ComputeResources: ### u-p6e-gb200x72
- DisableSimultaneousMultithreading: true
Efa:
Enabled: true
InstanceType: p6e-gb200.36xlarge
MaxCount: 18
MinCount: 18
Name: cr1
Name: q1
Networking:
SubnetIds:
-
```
## Convalida la configurazione IMEX
Il `91_nvidia_imex_prolog.sh` prolog verrà eseguito quando invii un lavoro Slurm. Di seguito è riportato un esempio di lavoro per verificare lo stato del dominio Nvidia-IMEX.
```
#!/bin/bash
#SBATCH --job-name=nvidia-imex-status-job
#SBATCH --ntasks-per-node=1
#SBATCH --output=slurm-%j.out
#SBATCH --error=slurm-%j.err
QUEUE_NAME="q1"
COMPUTE_RES_NAME="cr1"
IMEX_CONFIG_FILE="/opt/parallelcluster/shared/nvidia-imex/config_${QUEUE_NAME}_${COMPUTE_RES_NAME}.cfg"
srun bash -c "/usr/bin/nvidia-imex-ctl -N -c ${IMEX_CONFIG_FILE} > result_\${SLURM_JOB_ID}_\$(hostname).out 2> result_\${SLURM_JOB_ID}_\$(hostname).err"
```
Controlla l'output del Job:
```
Connectivity Table Legend:
I - Invalid - Node wasn't reachable, no connection status available
N - Never Connected
R - Recovering - Connection was lost, but clean up has not yet been triggered.
D - Disconnected - Connection was lost, and clean up has been triggreed.
A - Authenticating - If GSSAPI enabled, client has initiated mutual authentication.
!V! - Version mismatch, communication disabled.
!M! - Node map mismatch, communication disabled.
C - Connected - Ready for operation
5/12/2025 06:08:10.580
Nodes:
Node #0 - 172.31.48.81 - READY - Version: 570.172
Node #1 - 172.31.48.98 - READY - Version: 570.172
Node #2 - 172.31.48.221 - READY - Version: 570.172
Node #3 - 172.31.49.228 - READY - Version: 570.172
Node #4 - 172.31.50.39 - READY - Version: 570.172
Node #5 - 172.31.50.44 - READY - Version: 570.172
Node #6 - 172.31.51.66 - READY - Version: 570.172
Node #7 - 172.31.51.157 - READY - Version: 570.172
Node #8 - 172.31.52.239 - READY - Version: 570.172
Node #9 - 172.31.53.80 - READY - Version: 570.172
Node #10 - 172.31.54.95 - READY - Version: 570.172
Node #11 - 172.31.54.183 - READY - Version: 570.172
Node #12 - 172.31.54.203 - READY - Version: 570.172
Node #13 - 172.31.54.241 - READY - Version: 570.172
Node #14 - 172.31.55.59 - READY - Version: 570.172
Node #15 - 172.31.55.187 - READY - Version: 570.172
Node #16 - 172.31.55.197 - READY - Version: 570.172
Node #17 - 172.31.56.47 - READY - Version: 570.172
Nodes From\To 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
0 C C C C C C C C C C C C C C C C C C
1 C C C C C C C C C C C C C C C C C C
2 C C C C C C C C C C C C C C C C C C
3 C C C C C C C C C C C C C C C C C C
4 C C C C C C C C C C C C C C C C C C
5 C C C C C C C C C C C C C C C C C C
6 C C C C C C C C C C C C C C C C C C
7 C C C C C C C C C C C C C C C C C C
8 C C C C C C C C C C C C C C C C C C
9 C C C C C C C C C C C C C C C C C C
10 C C C C C C C C C C C C C C C C C C
11 C C C C C C C C C C C C C C C C C C
12 C C C C C C C C C C C C C C C C C C
13 C C C C C C C C C C C C C C C C C C
14 C C C C C C C C C C C C C C C C C C
15 C C C C C C C C C C C C C C C C C C
16 C C C C C C C C C C C C C C C C C C
17 C C C C C C C C C C C C C C C C C C
Domain State: UP
```
# Personalizza le interfacce di rete dei nodi di calcolo con sostituzioni dei modelli di avvio
A partire dalla AWS ParallelCluster versione 3.15.0, il `LaunchTemplateOverrides` parametro consente di personalizzare le interfacce di rete dei nodi di calcolo sovrascrivendo la configurazione dell'interfaccia di rete predefinita con la configurazione in un modello di avvio di riferimento. L'intera sezione dell'interfaccia di rete dei nodi di calcolo viene sovrascritta dalla sezione dell'interfaccia di rete del modello di avvio utilizzato per l'override.
Questo tutorial illustra un esempio di sovrascrittura della configurazione di rete predefinita dei nodi di calcolo. `p6-b300.48xlarge` Questa personalizzazione è utile quando è necessaria una configurazione specifica dell'interfaccia di rete diversa da quella AWS ParallelCluster predefinita. [In questo esempio, configuriamo lo use case 2 per le istanze P6-B300 come indicato nella documentazione dei tipi di istanze supportati da Amazon EC2 EFA.](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-acc-inst-types.html)
**Nota**
Si consiglia di utilizzare per creare il modello di avvio AWS CLI anziché la console per la massima flessibilità.
**Nota**
Il modello di avvio deve contenere solo le sostituzioni delle interfacce di rete. AWS ParallelCluster ha una convalida che impedisce la sovrascrittura di altri parametri.
**avvertimento**
Se si utilizza l'override per configurare le interfacce di rete in un modo non supportato dal tipo di istanza utilizzato, le istanze non verranno avviate.
**Prerequisiti**
+ AWS ParallelCluster [è installata la versione 3.15.0 o successiva.](install-v3-parallelcluster.md)
+ AWS CLI [è installato e configurato.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Hai un ruolo IAM con le [autorizzazioni](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) necessarie per eseguire la [`pcluster`](pcluster-v3.md) CLI.
## Fase 1: Creare gruppi di sicurezza
Quando si crea il modello di avvio da utilizzare nell'override, è necessario fare riferimento a un gruppo di sicurezza. Il gruppo AWS ParallelCluster di sicurezza predefinito per la risorsa di calcolo non esiste fino alla creazione del cluster, quindi è necessario creare un gruppo di sicurezza personalizzato. Questo gruppo di sicurezza deve quindi essere referenziato dal gruppo di sicurezza del nodo principale per consentire il traffico tra il nodo principale e i nodi di elaborazione.
Se stai aggiornando un cluster esistente per personalizzare una nuova capacità, puoi utilizzare il gruppo di sicurezza del nodo di AWS ParallelCluster calcolo predefinito nel modello di avvio anziché crearne uno personalizzato.
Crea i due gruppi di sicurezza seguenti:
+ **Gruppo di sicurezza aggiuntivo del nodo principale** (`sg-1234abcd`):
+ Ingresso: tutto il traffico proveniente dal gruppo di sicurezza di elaborazione
+ **Gruppo di sicurezza di calcolo** (): `sg-abcd1234`
+ Ingresso: tutto il traffico proveniente dal gruppo di sicurezza del nodo principale
+ Ingresso: tutto il traffico proveniente da self () compute-to-compute
+ Uscita: impostazione predefinita allow-all
## Fase 2: Creare il modello di lancio
Crea un modello di avvio che definisca la configurazione dell'interfaccia di rete per i nodi di `p6-b300.48xlarge` calcolo. Per l'interfaccia di rete principale (indice della scheda di rete 0, indice del dispositivo 0), utilizzate un'interfaccia di rete ENA (predefinita). Per le altre schede di rete, create un'interfaccia solo EFA (indici delle schede di rete 1-16, indice del dispositivo 0) e un'interfaccia ENA (predefinita) (indici delle schede di rete 1-16, indice del dispositivo 1).
Eseguite il seguente AWS CLI comando per creare il modello di avvio (): `lt-123456789`
```
aws ec2 create-launch-template \
--region us-east-1 \
--launch-template-name override-lt \
--launch-template-data '{
"NetworkInterfaces": [
{"NetworkCardIndex":0, "DeviceIndex":0, "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":1, "DeviceIndex":0, "InterfaceType":"efa-only", "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":1, "DeviceIndex":1, "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":2, "DeviceIndex":0, "InterfaceType":"efa-only", "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":2, "DeviceIndex":1, "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":3, "DeviceIndex":0, "InterfaceType":"efa-only", "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":3, "DeviceIndex":1, "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":4, "DeviceIndex":0, "InterfaceType":"efa-only", "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":4, "DeviceIndex":1, "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":5, "DeviceIndex":0, "InterfaceType":"efa-only", "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":5, "DeviceIndex":1, "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":6, "DeviceIndex":0, "InterfaceType":"efa-only", "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":6, "DeviceIndex":1, "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":7, "DeviceIndex":0, "InterfaceType":"efa-only", "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":7, "DeviceIndex":1, "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":8, "DeviceIndex":0, "InterfaceType":"efa-only", "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":8, "DeviceIndex":1, "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":9, "DeviceIndex":0, "InterfaceType":"efa-only", "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":9, "DeviceIndex":1, "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":10, "DeviceIndex":0, "InterfaceType":"efa-only", "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":10, "DeviceIndex":1, "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":11, "DeviceIndex":0, "InterfaceType":"efa-only", "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":11, "DeviceIndex":1, "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":12, "DeviceIndex":0, "InterfaceType":"efa-only", "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":12, "DeviceIndex":1, "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":13, "DeviceIndex":0, "InterfaceType":"efa-only", "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":13, "DeviceIndex":1, "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":14, "DeviceIndex":0, "InterfaceType":"efa-only", "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":14, "DeviceIndex":1, "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":15, "DeviceIndex":0, "InterfaceType":"efa-only", "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":15, "DeviceIndex":1, "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":16, "DeviceIndex":0, "InterfaceType":"efa-only", "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":16, "DeviceIndex":1, "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"}
]
}'
```
## Passaggio 3: Creare il cluster con le sostituzioni del modello di avvio
Crea una configurazione del cluster che utilizzi il `LaunchTemplateOverrides` parametro per fare riferimento al modello di lancio che hai creato.
```
Region: us-east-1
HeadNode:
InstanceType: c5.xlarge
Networking:
SubnetId: subnet-abcdefghi
AdditionalSecurityGroups:
# Add the head node SG that allows traffic from the compute node SG
- sg-1234abcd
...
Scheduling:
Scheduler: slurm
SlurmQueues:
- Name: queue0
Networking:
SubnetIds:
- subnet-123456789
ComputeResources:
- Name: compute-resource1
InstanceType: p6-b300.48xlarge
Efa:
Enabled: false # The override replaces all network interface configuration, so this setting is ignored
LaunchTemplateOverrides:
LaunchTemplateId: lt-123456789
Version: 1 # If the launch template is updated, then the new version should be specified here.
```