Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Amazon-ECS-Aufgabendefinitionen für GPU-Workloads
Amazon ECS unterstützt Workloads, die GPUs verwenden, wenn Sie Cluster mit Container-Instances erstellen, die GPUs unterstützen. GPU-basierte Amazon EC2 EC2-Container-Instances, die die Instance-Typen p2, p3, p5, g3, g4 und g5 verwenden, bieten Zugriff auf NVIDIA. GPUs Weitere Informationen finden Sie unter [Linux-beschleunigte Computing-Instances](https://docs.aws.amazon.com/ec2/latest/instancetypes/ac.html) im *Benutzerhandbuch für Instance-Typen von Amazon EC2*.
Amazon ECS bietet eine GPU-optimierte AMI, die mit vorkonfigurierten NVIDIA-Kernel-Treibern und einer Docker-GPU-Laufzeitumgebung ausgestattet ist. Weitere Informationen finden Sie unter [Amazon ECS-optimiertes Linux AMIs](ecs-optimized_AMI.md).
Sie können GPUs in Ihrer Aufgabendefinition eine Reihe von angeben, die bei der Platzierung von Aufgaben auf Containerebene berücksichtigt werden sollen. Amazon ECS plant für verfügbare Container-Instances, die für eine optimale Leistung physische Container unterstützen GPUs und GPUs an die richtigen Container anbinden.
Die folgenden GPU-basierten Instance-Typen von Amazon EC2 werden unterstützt. Weitere Informationen finden Sie unter [Amazon-EC2-P2-Instances](https://aws.amazon.com/ec2/instance-types/p2/), [Amazon-EC2-P3-Instances](https://aws.amazon.com/ec2/instance-types/p3/), [Amazon-EC2-P4d-Instances](https://aws.amazon.com/ec2/instance-types/p4/), [Amazon-EC2-P5-Instances](https://aws.amazon.com/ec2/instance-types/p5/), [Amazon-EC2-G3-Instances](https://aws.amazon.com/ec2/instance-types/g3/), [Amazon-EC2-G4-Instances](https://aws.amazon.com/ec2/instance-types/g4/), [Amazon-EC2-G5-Instances](https://aws.amazon.com/ec2/instance-types/g5/), [Amazon-EC2-G6-Instances](https://aws.amazon.com/ec2/instance-types/g6/) und [Amazon-EC2-G6e-Instances](https://aws.amazon.com/ec2/instance-types/g6e/).
| Instance-Typ | GPUs | GPU-Speicher (GiB) | v CPUs | Arbeitsspeicher (GiB) |
| --- | --- | --- | --- | --- |
| p3.2xgroß | 1 | 16 | 8 | 61 |
| p3.8xgroß | 4 | 64 | 32 | 244 |
| p3.16xgroß | 8 | 128 | 64 | 488 |
| p3dn.24xgroß | 8 | 256 | 96 | 768 |
| p4d.24xgroß | 8 | 320 | 96 | 1 152 |
| p5.48xlarge | 8 | 640 | 192 | 2048 |
| g3s.xgroß | 1 | 8 | 4 | 30,5 |
| g3.4xgroß | 1 | 8 | 16 | 122 |
| g3.8xgroß | 2 | 16 | 32 | 244 |
| g3.16xgroß | 4 | 32 | 64 | 488 |
| g4dn.xgroß | 1 | 16 | 4 | 16 |
| g4dn.2xgroß | 1 | 16 | 8 | 32 |
| g4dn.4xgroß | 1 | 16 | 16 | 64 |
| g4dn.8xgroß | 1 | 16 | 32 | 128 |
| g4dn.12xgroß | 4 | 64 | 48 | 192 |
| g4dn.16xgroß | 1 | 16 | 64 | 256 |
| g5.xgroß | 1 | 24 | 4 | 16 |
| g5.2xlarge | 1 | 24 | 8 | 32 |
| g5.4xlarge | 1 | 24 | 16 | 64 |
| g5.8xlarge | 1 | 24 | 32 | 128 |
| g5.16xlarge | 1 | 24 | 64 | 256 |
| g5.12xlarge | 4 | 96 | 48 | 192 |
| g5.24xlarge | 4 | 96 | 96 | 384 |
| g5.48xlarge | 8 | 192 | 192 | 768 |
| g6.xlarge | 1 | 24 | 4 | 16 |
| g6.2xlarge | 1 | 24 | 8 | 32 |
| g6.4xlarge | 1 | 24 | 16 | 64 |
| g6.8xlarge | 1 | 24 | 32 | 128 |
| g6.16.xlarge | 1 | 24 | 64 | 256 |
| g6.12xlarge | 4 | 96 | 48 | 192 |
| g6.24xlarge | 4 | 96 | 96 | 384 |
| g6.48xlarge | 8 | 192 | 192 | 768 |
| g6.metal | 8 | 192 | 192 | 768 |
| gr6.4xlarge | 1 | 24 | 16 | 128 |
| g6e.xlarge | 1 | 48 | 4 | 32 |
| g6e.2xlarge | 1 | 48 | 8 | 64 |
| g6e.4xlarge | 1 | 48 | 16 | 128 |
| g6e.8xlarge | 1 | 48 | 32 | 256 |
| g6e16.xlarge | 1 | 48 | 64 | 512 |
| g6e12.xlarge | 4 | 192 | 48 | 384 |
| g6e24.xlarge | 4 | 192 | 96 | 768 |
| g6e48.xlarge | 8 | 384 | 192 | 1536 |
| gr6.8xlarge | 1 | 24 | 32 | 256 |
Sie können die Amazon Machine Image (AMI) -ID für Amazon ECS-Optimized abrufen, AMIs indem Sie die AWS Systems Manager Parameter Store-API abfragen. Mit diesem Parameter müssen Sie Amazon ECS-optimiertes AMI nicht manuell suchen. IDs Weitere Informationen zur Systems Manager Parameter Store-API finden Sie unter [GetParameter](https://docs.aws.amazon.com/systems-manager/latest/APIReference/API_GetParameter.html). Der von Ihnen verwendete Benutzer muss über die `ssm:GetParameter`-IAM-Berechtigung zum Abrufen der Amazon-EKS-optimierten AMI-Metadaten verfügen.
```
aws ssm get-parameters --names /aws/service/ecs/optimized-ami/amazon-linux-2/gpu/recommended --region us-east-1
```
# Verwendung GPUs mit Amazon ECS Managed Instances
Amazon ECS Managed Instances unterstützt GPU-beschleunigte Datenverarbeitung für Workloads wie Machine Learning, Hochleistungsrechnen und Videoverarbeitung über die folgenden Instance-Typen von Amazon EC2. Weitere Informationen zu den von Amazon ECS Managed Instances unterstützten Instance-Typen finden Sie unter [Instance-Typen von Amazon ECS Managed Instances](managed-instances-instance-types.md).
Im Folgenden finden Sie eine Teilmenge der GPU-basierten Instance-Typen, die in Amazon ECS Managed Instances unterstützt werden:
+ `g4dn`: Unterstützt von NVIDIA T4 GPUs, geeignet für Machine Learning, Inferenz, Computer Vision und grafikintensive Anwendungen.
+ `g5`: Unterstützt von NVIDIA A10G GPUs, bietet höhere Leistung für grafikintensive Anwendungen und Workloads für Machine Learning.
+ `p3`: Unterstützt von NVIDIA V100 GPUs, konzipiert für Hochleistungscomputer und Deep-Learning-Training.
+ `p4d`: Unterstützt von NVIDIA A100 GPUs, bietet die höchste Leistung für Training für Machine Learning und Hochleistungs-Datenverarbeitung.
Wenn Sie GPU-fähige Instance-Typen mit Amazon ECS Managed Instances verwenden, sind die NVIDIA-Treiber und das CUDA-Toolkit auf der Instance vorinstalliert, sodass GPU-beschleunigte Workloads einfacher ausgeführt werden können.
## Auswahl GPU-fähiger Instances
Verwenden Sie das `instanceRequirements`-Objekt in der Startvorlage des Kapazitätsanbieters, um GPU-fähige Instance-Typen für Ihre Workloads von Amazon ECS Managed Instances auszuwählen. Der folgende Ausschnitt zeigt die Attribute, die für die Auswahl GPU-fähiger Instances verwendet werden können.
```
{
"instanceRequirements": {
"acceleratorTypes": "gpu",
"acceleratorCount": 1,
"acceleratorManufacturers": ["nvidia"]
}
}
```
Der folgende Ausschnitt zeigt die Attribute, die verwendet werden können, um GPU-fähige Instance-Typen in der Startvorlage anzugeben.
```
{
"instanceRequirements": {
"allowedInstanceTypes": ["g4dn.xlarge", "p4de.24xlarge"]
}
}
```
## GPU-fähige Container-Images
Für die Verwendung GPUs in Ihren Containern müssen Sie Container-Images verwenden, die die erforderlichen GPU-Bibliotheken und -Tools enthalten. NVIDIAstellt mehrere vorgefertigte Container-Images bereit, die Sie als Basis für Ihre GPU-Workloads verwenden können, darunter die folgenden:
+ `nvidia:cuda`: Basis-Images mit dem CUDA-Toolkit für GPU-Datenverarbeitung.
+ `tensorflow/tensorflow:latest-gpu`: TensorFlow mit GPU-Unterstützung.
+ `pytorch/pytorch:latest-cuda`: PyTorch mit GPU-Unterstützung.
Ein Beispiel für eine Aufgabendefinition für Amazon ECS auf Amazon ECS Managed Instances, die die Verwendung von beinhaltet GPUs, finden Sie unter[GPUs In einer Amazon ECS-Aufgabendefinition angeben](ecs-gpu-specifying.md).
## Überlegungen
**Anmerkung**
Die Unterstützung für den g2-Instance-Familientyp ist veraltet.
Der Instance-Familientyp p2 wird nur von Versionen vor `20230912` des Amazon-ECS-GPU-optimierten AMI unterstützt. Wenn Sie weiterhin P2-Instances verwenden müssen, finden Sie weitere Informationen unter [Was tun, wenn Sie eine P2-Instance benötigen](#p2-instance).
Direkte Aktualisierungen der NVIDIA/CUDA Treiber für diese beiden Instance-Familientypen können zu potenziellen Ausfällen der GPU-Arbeitslast führen.
Wir empfehlen Ihnen, Folgendes zu berücksichtigen, bevor Sie mit der Arbeit GPUs an Amazon ECS beginnen.
+ Ihre Cluster können eine Mischung aus GPU- und Nicht-GPU-Container-Instances enthalten.
+ Sie können GPU-Workloads auf externen Instances ausführen. Stellen Sie beim Anmelden einer externen Instance bei Ihrem Cluster sicher, dass das `--enable-gpu`-Flag im Installationsskript enthalten ist. Weitere Informationen finden Sie unter [Registrieren einer externen Instance in einem Amazon-ECS-Cluster](ecs-anywhere-registration.md).
+ Sie müssen in Ihrer Agenten-Konfigurationsdatei `ECS_ENABLE_GPU_SUPPORT` auf `true` setzen. Weitere Informationen finden Sie unter [Konfiguration des Amazon-ECS-Container-Agenten](ecs-agent-config.md).
+ Wenn Sie eine Aufgabe ausführen oder einen Service erstellen, können Sie beim Konfigurieren der Platzierungsbedingungen mithilfe von Attributen des Instance-Typs festlegen, für welche Ihrer Container-Instances die Aufgabe gestartet wird. Auf diese Weise können Sie Ihre Ressourcen effektiver verwenden. Weitere Informationen finden Sie unter [So platziert Amazon ECS Aufgaben in Container-Instances](task-placement.md).
Das folgende Beispiel startet eine Aufgabe auf einer `g4dn.xlarge`-Container-Instance in Ihrem Standard-Cluster.
```
aws ecs run-task --cluster default --task-definition ecs-gpu-task-def \
--placement-constraints type=memberOf,expression="attribute:ecs.instance-type == g4dn.xlarge" --region us-east-2
```
+ Für jeden Container, der eine in der Container-Definition festgelegte GPU-Ressourcenanforderung hat, legt Amazon ECS fest, dass die Container-Laufzeitumgebung die NVIDIA-Container-Laufzeitumgebung ist.
+ Die NVIDIA Container-Laufzeitumgebung erfordert, dass einige Umgebungsvariablen im Container festgelegt werden, damit sie korrekt funktioniert. Eine Liste dieser Umgebungsvariablen finden Sie unter [Spezialisierte Konfigurationen mit Docker](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/docker-specialized.html?highlight=environment%20variable). Amazon ECS legt als Wert der `NVIDIA_VISIBLE_DEVICES` Umgebungsvariablen eine Liste des GPU-Geräts fest IDs , das Amazon ECS dem Container zuweist. Die anderen erforderlichen Umgebungsvariablen legt Amazon ECS nicht fest. Stellen Sie daher sicher, dass Ihr Container-Image sie festlegt oder dass sie in der Container-Definition festgelegt sind.
+ Die p5-Instance-Typ-Familie wird auf Version `20230929` und höher des Amazon-ECS GPU-optimierten AMI unterstützt.
+ Die g4-Instance-Typ-Familie wird auf Version `20230913` und höher des Amazon ECS GPU-optimierten AMI unterstützt. Weitere Informationen finden Sie unter [Amazon ECS-optimiertes Linux AMIs](ecs-optimized_AMI.md). Sie wird im Workflow „Cluster erstellen“ in der Amazon-ECS-Konsole nicht unterstützt. Um diese Instance-Typen zu verwenden, müssen Sie entweder die Amazon EC2 EC2-Konsole oder die API verwenden und die Instances manuell in Ihrem Cluster registrieren. AWS CLI
+ Der Instance-Typ p4d.24xlarge funktioniert nur mit CUDA 11 oder höher.
+ Das GPU-optimierte AMI von Amazon ECS wurde IPv6 aktiviert, was zu Problemen bei der Verwendung führt. `yum` Dieses Problem kann durch die Konfiguration für die Verwendung IPv4 mit `yum` dem folgenden Befehl behoben werden.
```
echo "ip_resolve=4" >> /etc/yum.conf
```
+ Wenn Sie ein Container-Image erstellen, das die NVIDIA/CUDA Basis-Images nicht verwendet, müssen Sie die `NVIDIA_DRIVER_CAPABILITIES` Container-Laufzeitvariable auf einen der folgenden Werte setzen:
+ `utility,compute`
+ `all`
Informationen zum Festlegen der Variablen finden Sie unter [Steuern der NVIDIA Container Runtime](https://sarus.readthedocs.io/en/stable/user/custom-cuda-images.html#controlling-the-nvidia-container-runtime) auf der NVIDIA-Website.
+ GPUs werden in Windows-Containern nicht unterstützt.
# Eine GPU-Container-Instance für Amazon ECS starten
Um eine GPU-Instance mit Amazon ECS in Amazon EC2 zu verwenden, müssen Sie eine Startvorlage und eine Benutzerdatendatei erstellen und die Instance starten.
Anschließend können Sie eine Aufgabe ausführen, die eine für GPU konfigurierte Aufgabendefinition verwendet.
## Verwenden einer Startvorlage
Sie können eine Startvorlage erstellen
+ Erstellen Sie eine Startvorlage, die die Amazon-ECS-optimierte GPU-AMI-ID für das AMI verwendet. Informationen zum Erstellen einer Startvorlage finden Sie unter [Erstellen einer neuen Startvorlage mithilfe von Parametern, die Sie definieren](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/create-launch-template.html#create-launch-template-define-parameters) im *Amazon-EC2-Benutzerhandbuch*.
Verwenden Sie die AMI-ID aus dem vorherigen Schritt für das **Amazon Machine Image**. Informationen zur Angabe der AMI-ID mit dem Systems-Manager-Parameter finden Sie unter [Spezifizieren eines Systems-Manager-Parameters in einer Startvorlage](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/create-launch-template.html#use-an-ssm-parameter-instead-of-an-ami-id) im *Amazon-EC2-Benutzerhandbuch*.
Fügen Sie den **Benutzerdaten** in der Startvorlage Folgendes hinzu. Ersetzen Sie *cluster-name* mit dem Namen Ihres Clusters.
```
#!/bin/bash
echo ECS_CLUSTER=cluster-name >> /etc/ecs/ecs.config;
echo ECS_ENABLE_GPU_SUPPORT=true >> /etc/ecs/ecs.config
```
## Verwenden Sie die AWS CLI
Sie können den verwenden AWS CLI , um die Container-Instance zu starten.
1. Erstellen Sie eine Datei mit dem Namen `userdata.toml`. Diese Datei wird für Instance-Benutzerdaten verwendet. Ersetzen Sie *cluster-name* mit dem Namen Ihres Clusters.
```
#!/bin/bash
echo ECS_CLUSTER=cluster-name >> /etc/ecs/ecs.config;
echo ECS_ENABLE_GPU_SUPPORT=true >> /etc/ecs/ecs.config
```
1. Führen Sie den folgenden Befehl aus, um die GPU-AMI-ID zu erhalten. Sie verwenden dies im folgenden Schritt.
```
aws ssm get-parameters --names /aws/service/ecs/optimized-ami/amazon-linux-2/gpu/recommended --region us-east-1
```
1. Führen Sie den folgenden Befehl aus, um die GPU-Instance zu starten. Denken Sie daran, die folgenden Parameter zu ersetzen:
+ *subnet*Ersetzen Sie es durch die ID des privaten oder öffentlichen Subnetzes, in dem Ihre Instance gestartet wird.
+ *gpu\$1ami*Ersetzen Sie durch die AMI-ID aus dem vorherigen Schritt.
+ *t3.large*Ersetzen Sie durch den Instance-Typ, den Sie verwenden möchten.
+ *region*Ersetzen Sie durch den Regionalcode.
```
aws ec2 run-instances --key-name ecs-gpu-example \
--subnet-id subnet \
--image-id gpu_ami \
--instance-type t3.large \
--region region \
--tag-specifications 'ResourceType=instance,Tags=[{Key=GPU,Value=example}]' \
--user-data file://userdata.toml \
--iam-instance-profile Name=ecsInstanceRole
```
1. Führen Sie den folgenden Befehl aus, um zu überprüfen, ob die Container-Instance im Cluster registriert ist. Denken Sie beim Ausführen dieses Befehls daran, die folgenden Parameter zu ersetzen:
+ Ersetzen Sie *cluster* mit Ihrem Clusternamen.
+ *region*Ersetzen Sie es durch Ihren Regionalcode.
```
aws ecs list-container-instances --cluster cluster-name --region region
```
# GPUs In einer Amazon ECS-Aufgabendefinition angeben
Um die GPUs On-a-Container-Instance und die Docker-GPU-Laufzeit zu verwenden, stellen Sie sicher, dass Sie in der Aufgabendefinition die Anzahl angeben, die GPUs Ihr Container benötigt. Wenn Container, die Unterstützung bieten, platziert GPUs werden, heftet der Amazon ECS-Container-Agent die gewünschte Anzahl GPUs an physischen Containern an den entsprechenden Container. Die Anzahl der für alle Container in einer Aufgabe GPUs reservierten Container darf die Anzahl der verfügbaren Container auf der Container-Instance, GPUs auf der die Aufgabe gestartet wird, nicht überschreiten. Weitere Informationen finden Sie unter [Erstellen einer Amazon-ECS-Aufgabendefinition mit der Konsole](create-task-definition.md).
**Wichtig**
Wenn Ihre GPU-Anforderungen in der Aufgabendefinition nicht angegeben werden, verwendet die Aufgabe die Standard-Docker-Laufzeit.
Das folgende Beispiel zeigt das JSON-Format für die GPU-Anforderungen in einer Aufgabendefinition:
```
{
"containerDefinitions": [
{
...
"resourceRequirements" : [
{
"type" : "GPU",
"value" : "2"
}
],
},
...
}
```
Das folgende Beispiel veranschaulicht die Syntax eines Docker-Containers, der eine GPU-Anforderung angibt. Dieser Container verwendet zwei GPUs, führt das `nvidia-smi` Hilfsprogramm aus und wird dann beendet.
```
{
"containerDefinitions": [
{
"memory": 80,
"essential": true,
"name": "gpu",
"image": "nvidia/cuda:11.0.3-base",
"resourceRequirements": [
{
"type":"GPU",
"value": "2"
}
],
"command": [
"sh",
"-c",
"nvidia-smi"
],
"cpu": 100
}
],
"family": "example-ecs-gpu"
}
```
Die folgende Beispielaufgabendefinition zeigt einen TensorFlow Container, der die Anzahl der verfügbaren GPUs Objekte ausgibt. Die Aufgabe wird in Amazon ECS Managed Instances ausgeführt, benötigt eine GPU und verwendet eine `g4dn.xlarge`-Instance.
```
{
"family": "tensorflow-gpu",
"networkMode": "awsvpc",
"executionRoleArn": "arn:aws:iam::account-id:role/ecsTaskExecutionRole",
"containerDefinitions": [
{
"name": "tensorflow",
"image": "tensorflow/tensorflow:latest-gpu",
"essential": true,
"command": [
"python",
"-c",
"import tensorflow as tf; print('Num GPUs Available: ', len(tf.config.list_physical_devices('GPU')))"
],
"resourceRequirements": [
{
"type": "GPU",
"value": "1"
}
],
"logConfiguration": {
"logDriver": "awslogs",
"options": {
"awslogs-group": "/ecs/tensorflow-gpu",
"awslogs-region": "region",
"awslogs-stream-prefix": "ecs"
}
}
}
],
"requiresCompatibilities": [
"MANAGED_INSTANCES"
],
"cpu": "4096",
"memory": "8192",
}
```
## Teilen GPUs
Wenn Sie teilen möchten GPUs, müssen Sie Folgendes konfigurieren.
1. Entfernen Sie GPU-Ressourcenanforderungen aus Ihren Aufgabendefinitionen, sodass Amazon ECS keine Ressourcen reserviert GPUs , die gemeinsam genutzt werden sollten.
1. Fügen Sie Ihren Instances die folgenden Benutzerdaten hinzu, wenn Sie sie teilen möchten GPUs. Dadurch wird nvidia zur standardmäßigen Docker-Container-Laufzeit auf der Container-Instance, sodass alle Amazon ECS-Container die GPUs verwenden können. Weitere Informationen finden Sie unter [Ausführen von Befehlen beim Start einer EC2-Instance mit Benutzer-Dateneingabe](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/user-data.html) im *Amazon-EC2-Benutzerhandbuch*.
```
const userData = ec2.UserData.forLinux();
userData.addCommands(
'sudo rm /etc/sysconfig/docker',
'echo DAEMON_MAXFILES=1048576 | sudo tee -a /etc/sysconfig/docker',
'echo OPTIONS="--default-ulimit nofile=32768:65536 --default-runtime nvidia" | sudo tee -a /etc/sysconfig/docker',
'echo DAEMON_PIDFILE_TIMEOUT=10 | sudo tee -a /etc/sysconfig/docker',
'sudo systemctl restart docker',
);
```
1. Legen Sie die `NVIDIA_VISIBLE_DEVICES`-Umgebungsvariable in Ihrem Container fest. Dazu können Sie die Umgebungsvariable in Ihrer Aufgabendefinition festlegen. Informationen zu den gültigen Werten finden Sie unter [GPU-Nummerierung](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/docker-specialized.html#gpu-enumeration) auf der NVIDIA-Dokumentationsseite.
## Was tun, wenn Sie eine P2-Instance benötigen
Wenn Sie die P2-Instance verwenden müssen, können Sie eine der folgenden Optionen verwenden, um die Instances weiterhin zu verwenden.
Sie müssen die Benutzerdaten der Instance für beide Optionen ändern. Weitere Informationen finden Sie unter [Ausführen von Befehlen beim Start einer EC2-Instance mit Benutzer-Dateneingabe](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/user-data.html) im *Amazon-EC2-Benutzerhandbuch*.
**Verwenden der zuletzt unterstützten GPU-optimierten AMI**
Sie können die `20230906`-Version des GPU-optimierten AMI verwenden und den Instance-Benutzerdaten Folgendes hinzufügen.
Ersetzen Sie cluster-name durch den Namen Ihres Clusters.
```
#!/bin/bash
echo "exclude=*nvidia* *cuda*" >> /etc/yum.conf
echo "ECS_CLUSTER=cluster-name" >> /etc/ecs/ecs.config
```
**Die aktuellsten GPU-optimierten AMI verwenden und die Benutzerdaten aktualisieren**
Sie können den Benutzerdaten der Instance Folgendes hinzufügen. Dadurch werden die Nvidia 535/Cuda12.2-Treiber deinstalliert und anschließend die Nvidia 470/Cuda11.4-Treiber installiert und die Version repariert.
```
#!/bin/bash
yum remove -y cuda-toolkit* nvidia-driver-latest-dkms*
tmpfile=$(mktemp)
cat >$tmpfile <> /etc/yum.conf
nvidia-smi
```
**Ihr eigenes P2-kompatibles und GPU-optimiertes AMI erstellen**
Sie können Ihr eigenes benutzerdefiniertes GPU-optimiertes Amazon-ECS-AMI erstellen, das mit P2-Instances kompatibel ist, und dann P2-Instances mithilfe des AMI starten.
1. Führen Sie den folgenden Befehl aus, um das `amazon-ecs-ami repo` zu klonen.
```
git clone https://github.com/aws/amazon-ecs-ami
```
1. Stellen Sie die erforderlichen Amazon-ECS-Agent- und Amazon-Linux-AMI-Quellversionen in `release.auto.pkrvars.hcl` oder `overrides.auto.pkrvars.hcl` ein.
1. Führen Sie den folgenden Befehl aus, um ein privates P2-kompatibles EC2-AMI zu erstellen.
Ersetzen Sie Region durch die Region mit der Instance-Region.
```
REGION=region make al2keplergpu
```
1. Verwenden Sie das AMI mit den folgenden Instance-Benutzerdaten, um eine Verbindung zum Amazon-ECS-Cluster herzustellen.
Ersetzen Sie cluster-name durch den Namen Ihres Clusters.
```
#!/bin/bash
echo "ECS_CLUSTER=cluster-name" >> /etc/ecs/ecs.config
```