

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.

# Überwachen von Amazon-ECS-Containern mit ECS Exec
<a name="ecs-exec"></a>

Mit Amazon ECS Exec können Sie direkt mit Containern interagieren, ohne zuerst mit dem Host-Container-Betriebssystem interagieren, eingehende Ports öffnen oder SSH-Schlüssel verwalten zu müssen. Sie können ECS Exec verwenden, um Befehle in einem Container auszuführen oder eine Shell zu erhalten, der auf einer Amazon-EC2-Instance oder auf AWS Fargate ausgeführt wird. Dies erleichtert das Sammeln von Diagnoseinformationen und die schnelle Fehlerbehebung. Beispielsweise können Sie ECS Exec in einem Entwicklungsumfeld verwenden, um problemlos mit verschiedenen Prozessen in Ihren Containern zu interagieren und Ihre Anwendungen zu beheben. In Produktionsszenarien können Sie ECS Exec verwenden, um Notfallszugriff auf Ihre Container zu erhalten, um Probleme zu beheben. 

Sie können Befehle in einem laufenden Linux- oder Windows-Container mit ECS Exec über die Amazon ECS-API AWS Command Line Interface (AWS CLI) oder die AWS SDKs AWS Copilot-CLI ausführen. [Einzelheiten zur Verwendung von ECS Exec sowie eine Videoanleitung mit der AWS Copilot-CLI finden Sie in der Copilot-Dokumentation. GitHub](https://aws.github.io/copilot-cli/docs/commands/svc-exec/)

Sie können ECS Exec auch verwenden, um strengere Zugriffskontrolle-Richtlinien beizubehalten. Wenn Sie dieses Feature selektiv aktivieren, können Sie steuern, wer Befehle ausführen kann und für welche Tasks diese Befehle ausgeführt werden können. Mit einem Protokoll der einzelnen Befehle und ihrer Ausgabe können Sie mit ECS Exec sehen, welche Aufgaben ausgeführt wurden, und Sie können CloudTrail damit überprüfen, wer auf einen Container zugegriffen hat.

## Überlegungen
<a name="ecs-exec-considerations"></a>

Beachten Sie Folgendes, wenn Sie ECS Exec verwenden.
+ ECS Exec funktioniert möglicherweise nicht wie erwartet, wenn es auf Betriebssystemen läuft, die nicht von Systems Manager unterstützt werden. Weitere Informationen zu den unterstützten Betriebssystemen finden Sie unter [Typen von Betriebssystemen](https://docs.aws.amazon.com/systems-manager/latest/userguide/operating-systems-and-machine-types.html#prereqs-os-linux) im *Benutzerhandbuch für AWS Systems Manager *.
+ ECS Exec wird für Aufgaben unterstützt, die auf der folgenden Infrastruktur ausgeführt werden:
  + Linux-Container auf Amazon EC2 auf jeder Amazon-ECS-optimierten AMI, einschließlich Bottlerocket
  + Linux- und Windows-Container auf externen Instances (Amazon ECS Anywhere)
  + Linux- und Windows-Container auf AWS Fargate
  + Windows-Container auf Amazon EC2 auf den folgenden für Amazon ECS optimierten Windows AMIs (mit der Container-Agent-Version `1.56` oder höher):
    + Amazon-ECS-optimierter Windows Server 2022 Full AMI
    + Amazon-ECS-optimierter Windows Server 2022 Core AMI
    + Amazon-ECS-optimierter Windows Server 2019 Full AMI
    + Amazon-ECS-optimierter Windows Server 2019 Core AMI
    + Amazon-ECS-optimiertes Windows Server 20H2 Core AMI
+ Wenn Sie einen HTTP-Proxy für Ihre Aufgabe konfiguriert haben, setzen Sie die `NO_PROXY`-Umgebungsvariable auf `"NO_PROXY=169.254.169.254,169.254.170.2"`, um den Proxy für EC2-Instance-Metadaten und IAM-Rollen-Datenverkehr zu umgehen. Wenn Sie die `NO_PROXY`-Umgebungsvariable nicht konfigurieren, kann es beim Abrufen von Instance-Metadaten oder IAM-Rollen-Anmeldeinformationen vom Metadaten-Endpunkt innerhalb des Containers zu Fehlern kommen. Wenn Sie die `NO_PROXY`-Umgebungsvariable wie empfohlen festlegen, werden die Metadaten und der IAM-Datenverkehr gefiltert, sodass Anfragen an `169.254.169.254 and 169.254.170.2` nicht über den `HTTP`-Proxy weitergeleitet werden.
+ ECS Exec und Amazon VPC
  + Wenn Sie Amazon-VPC-Endpunkte als Schnittstelle mit Amazon ECS verwenden, müssen Sie die Schnittstelle Amazon-VPC-Endpunkte für Systems Manager Session Manager (`ssmmessages`) erstellen. *Weitere Informationen zu Systems Manager Manager-VPC-Endpunkten finden Sie im [Benutzerhandbuch unter Verwenden AWS PrivateLink zum Einrichten eines VPC-Endpoints für Session Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-getting-started-privatelink.html).AWS Systems Manager *
  + Wenn Sie Amazon VPC-Schnittstellenendpunkte mit Amazon ECS verwenden und diese für die Verschlüsselung verwenden, müssen Sie die Schnittstelle erstellen, AWS KMS key für die Amazon VPC-Endpunkte verwendet werden. AWS KMS key Weitere Informationen finden Sie unter [Verbinden mit AWS KMS key über einen VPC-Endpunkt](https://docs.aws.amazon.com/kms/latest/developerguide/kms-vpc-endpoint.html) im *AWS Key Management Service -Entwicklerhandbuch*.
  + Wenn Sie Aufgaben haben, die auf Amazon-EC2-Instances ausgeführt werden, verwenden Sie den `awsvpc`-Netzwerkmodus. Wenn Sie keinen Internetzugang haben (bzw. nicht für die Verwendung eines NAT-Gateways konfiguriert), müssen Sie die Schnittstellen-Amazon-VPC-Endpunkte für den Systems Manager Session Manager (`ssmmessages`) erstellen. Weitere Informationen zu Überlegungen zum `awsvpc`-Netzwerkmodus finden Sie unter [Überlegungen.](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking-awsvpc.html#linux) *Weitere Informationen zu Systems Manager Manager-VPC-Endpunkten finden Sie im [Benutzerhandbuch unter Verwenden AWS PrivateLink zum Einrichten eines VPC-Endpoints für Session Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-getting-started-privatelink.html).AWS Systems Manager *
+ Amazon ECS Exec wird nicht für Aufgaben unterstützt, die in einer IPv6 Nur-Konfiguration ausgeführt werden. Weitere Informationen zum Ausführen von Aufgaben in einer IPv6 Nur-Konfiguration finden Sie unter und. [Netzwerkoptionen für Amazon-ECS-Aufgaben für Fargate](fargate-task-networking.md) [Netzwerkoptionen für Amazon-ECS-Aufgaben für EC2](task-networking.md)
+ ECS Exec und SSM
  + Wenn ein Benutzer Befehle für einen Container mit ECS Exec ausführt, werden diese Befehle als der `root`-Benutzer ausgeführt. Der SSM Agent und seine untergeordneten Prozesse werden auch dann als Root ausgeführt, wenn Sie eine Benutzer-ID für den Container angeben.
  + Der SSM-Agent erfordert, dass auf das Container-Dateisystem geschrieben werden kann, um die erforderlichen Verzeichnisse und Dateien zu erstellen. Daher wird das Schreibschützen der Root-Dateisystem mit dem `readonlyRootFilesystem`-Aufgabendefinitionsparameter oder eine andere Methode nicht unterstützt.
  + Obwohl das Starten von SSM-Sitzungen außerhalb der `execute-command`-Aktion möglich ist, führt dies dazu, dass die Sitzungen nicht protokolliert und gegen das Sitzungslimit gezählt werden. Wir empfehlen, diesen Zugriff einzuschränken, indem Sie die `ssm:start-session`-Aktion mit einer IAM-Richtlinie verweigern. Weitere Informationen finden Sie unter [Beschränken des Zugriffs auf die Aktion „Sitzung starten“](#ecs-exec-limit-access-start-session).
+ Die folgenden Features werden als Sidecar-Container ausgeführt. Daher müssen Sie den Namen des Containers angeben, für den der Befehl ausgeführt werden soll.
  + Laufzeitüberwachung
  + Service Connect
+ Benutzer können alle Befehle ausführen, die im Container-Kontext verfügbar sind. Die folgenden Aktionen können zu verwaisten und Zombie-Prozessen führen: Beenden des Hauptprozesses des Containers, Beenden des Befehls-Agenten und Löschen von Abhängigkeiten. Um Zombie-Prozesse zu bereinigen, empfehlen wir Ihnen, das `initProcessEnabled`-Flag an Ihre Aufgabendefinition anzufügen.
+ ECS Exec wird CPU und Arbeitsspeicher verwenden. Sie sollten dies berücksichtigen, wenn Sie die CPU- und Arbeitsspeicherressourcenzuordnungen in Ihrer Aufgabendefinition angeben.
+ Sie müssen AWS CLI Version `1.22.3` oder höher oder AWS CLI Version `2.3.6` oder höher verwenden. Informationen zur Aktualisierung [von finden Sie unter Installation oder Aktualisierung der neuesten Version von AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) im *AWS Command Line Interface Benutzerhandbuch Version 2. AWS CLI*
+  Sie können nur eine ECS-Exec-Sitzung pro Prozess-ID-Namespace (PID) haben. Wenn Sie [einen PID-Namespace in einer Aufgabe freigeben](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html#other_task_definition_params), können Sie ECS-Exec-Sitzungen nur in einem Container starten.
+ Für die ECS Exec-Sitzung ist eine Zeitüberschreitung von 20 Minuten konfiguriert. Dieser Wert kann nicht geändert werden.
+ Sie können ECS Exec nicht für vorhandene Aufgaben aktivieren. Es kann nur für neue Aufgaben aktiviert werden.
+ Sie können ECS Exec nicht verwenden, wenn Sie mit `run-task` eine Aufgabe auf einem Cluster starten, der verwaltete Skalierung mit asynchroner Platzierung verwendet (eine Aufgabe ohne Instance starten).
+ Sie können ECS Exec nicht für Microsoft-Nano-Server-Container ausführen. 

## Architektur
<a name="ecs-exec-architecture"></a>

ECS Exec verwendet den AWS Systems Manager (SSM) Session Manager, um eine Verbindung mit dem laufenden Container herzustellen, und verwendet AWS Identity and Access Management (IAM) -Richtlinien, um den Zugriff auf laufende Befehle in einem laufenden Container zu steuern. Dies wird ermöglicht, indem die notwendigen SSM Agent-Binärdateien in den Container eingebunden werden. Der Amazon ECS oder AWS Fargate -Agent ist dafür verantwortlich, den SSM-Core-Agenten im Container zusammen mit Ihrem Anwendungscode zu starten. Weitere Informationen erhalten Sie unter [ Systems Manager Session Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager.html).

Sie können anhand des `ExecuteCommand` Event in überprüfen, welcher Benutzer auf den Container zugegriffen hat, AWS CloudTrail und jeden Befehl (und seine Ausgabe) in Amazon S3 oder Amazon CloudWatch Logs protokollieren. Um Daten zwischen dem lokalen Client und dem Container mit Ihrem eigenen Verschlüsselungsschlüssel zu verschlüsseln, müssen Sie den Schlüssel AWS Key Management Service (AWS KMS) angeben.



## Konfiguration von ECS Exec
<a name="ecs-exec-enabling-and-using"></a>

Um ECS Exec verwenden zu können, müssen Sie zuerst das Feature für Ihre Aufgaben und Services aktivieren. Anschließend können Sie Befehle in Ihren Containern ausführen.

### Änderungen an optionalen Aufgabendefinition
<a name="ecs-exec-task-definition"></a>

Wenn Sie den Aufgabendefinitionefinitions-Parameter auf `initProcessEnabled` oder `true` setzen, startet dies den Init-Prozess innerhalb des Containers. Dadurch werden alle gefundenen untergeordneten Prozesse des Zombie-SSM-Agents entfernt. Folgendes ist ein Beispiel.

```
{
    "taskRoleArn": "ecsTaskRole",
    "networkMode": "awsvpc",
    "requiresCompatibilities": [
        "EC2",
        "FARGATE"
    ],
    "executionRoleArn": "ecsTaskExecutionRole",
    "memory": ".5 gb",
    "cpu": ".25 vcpu",
    "containerDefinitions": [
        {
            "name": "amazon-linux",
            "image": "amazonlinux:latest",
            "essential": true,
            "command": ["sleep","3600"],
            "linuxParameters": {
                "initProcessEnabled": true
            }
        }
    ],
    "family": "ecs-exec-task"
}
```

### Aktivieren von ECS Exec für Ihre Aufgaben und Services
<a name="ecs-exec-enabling"></a>

Sie können die ECS Exec-Funktion für Ihre Dienste und eigenständigen Aufgaben aktivieren, indem Sie das `--enable-execute-command` Flag angeben, wenn Sie einen der folgenden AWS CLI Befehle verwenden: [https://docs.aws.amazon.com/cli/latest/reference/ecs/create-service.html](https://docs.aws.amazon.com/cli/latest/reference/ecs/create-service.html), [https://docs.aws.amazon.com/cli/latest/reference/ecs/update-service.html](https://docs.aws.amazon.com/cli/latest/reference/ecs/update-service.html), oder. [https://docs.aws.amazon.com/cli/latest/reference/ecs/run-task.html](https://docs.aws.amazon.com/cli/latest/reference/ecs/run-task.html)

Wenn Sie beispielsweise den folgenden Befehl ausführen, wird das ECS-Exec-Feature für einen neu erstellten Service aktiviert, der in Fargate ausgeführt wird. Weitere Informationen zum Erstellen von Services finden Sie unter [create-service](https://docs.aws.amazon.com/cli/latest/reference/ecs/create-service.html).

```
aws ecs create-service \
    --cluster cluster-name \
    --task-definition task-definition-name \
    --enable-execute-command \
    --service-name service-name \
    --launch-type FARGATE \
     --network-configuration "awsvpcConfiguration={subnets=[subnet-12344321],securityGroups=[sg-12344321],assignPublicIp=ENABLED}" \
    --desired-count 1
```

Nachdem Sie ECS Exec für eine Aufgabe aktiviert haben, können Sie den folgenden Befehl ausführen, um zu bestätigen, dass die Aufgabe für die Verwendung bereit ist. Wenn die `lastStatus`-Eigenschaft des `ExecuteCommandAgent` als `RUNNING` aufgelistet wird und die `enableExecuteCommand`-Eigenschaft auf `true` festgelegt ist, dann ist Ihre Aufgabe fertig.

```
aws ecs describe-tasks \
    --cluster cluster-name \
    --tasks task-id
```

Das folgende Ausgabeschnippsel ist ein Beispiel davon, was Sie sehen könnten.

```
{
    "tasks": [
        {
            ...
            "containers": [
                {
                    ...
                    "managedAgents": [
                        {
                            "lastStartedAt": "2021-03-01T14:49:44.574000-06:00",
                            "name": "ExecuteCommandAgent",
                            "lastStatus": "RUNNING"
                        }
                    ]
                }
            ],
            ...
            "enableExecuteCommand": true,
            ...
        }
    ]
}
```

### Ausführen von Befehlen mit ECS Exec
<a name="ecs-exec-running-commands"></a>

## Protokollierung mit ECS Exec
<a name="ecs-exec-logging"></a>

Sie können die Protokollierung für ECS-Exec-Sitzungen so konfigurieren, dass Befehle und ihre Ausgabe zu Prüfungs- und Fehlerbehebungszwecken erfasst werden.

### Aktivieren der Protokollierung und Überwachung in Ihren Aufgaben und Services
<a name="ecs-exec-enabling-logging"></a>

**Wichtig**  
Weitere Informationen zur CloudWatch Preisgestaltung finden Sie unter [CloudWatch Preise](https://aws.amazon.com/cloudwatch/pricing/). Amazon ECS stellt außerdem Überwachungsmetriken bereit, die ohne zusätzliche Gebühren bereitgestellt werden. Weitere Informationen finden Sie unter [Überwachen Sie Amazon ECS mit CloudWatch](cloudwatch-metrics.md).

Amazon ECS bietet eine Standardkonfiguration für die Protokollierung von Befehlen, die mit ECS Exec ausgeführt werden. Standardmäßig werden CloudWatch Protokolle mithilfe des `awslogs` Protokolltreibers, der in Ihrer Aufgabendefinition konfiguriert ist, an Logs gesendet. Wenn Sie eine benutzerdefinierte Konfiguration bereitstellen möchten, AWS CLI unterstützt der ein `--configuration` Flag sowohl für die `create-cluster` `update-cluster` Befehle als auch. Das Container-Image muss `script` installiert sein`cat`, damit die Befehlsprotokolle korrekt in Amazon S3 oder CloudWatch Logs hochgeladen werden können. Weitere Informationen zum Erstellen von Clustern finden Sie unter [create-cluster](https://docs.aws.amazon.com/cli/latest/reference/ecs/create-cluster.html).

**Anmerkung**  
Diese Konfiguration verarbeitet nur die Protokollierung der `execute-command`-Sitzung. Dies wirkt sich nicht auf die Protokollierung Ihrer Anwendung aus.

Das folgende Beispiel erstellt einen Cluster und protokolliert dann die Ausgabe in Ihren CloudWatch Logs LogGroup named `cloudwatch-log-group-name` und Ihrem Amazon S3 S3-Bucket named`s3-bucket-name`.

Sie müssen einen vom AWS KMS Kunden verwalteten Schlüssel verwenden, um die Protokollgruppe zu verschlüsseln, wenn Sie die `CloudWatchEncryptionEnabled` Option auf `true` setzen. *Informationen zur Verschlüsselung der Protokollgruppe finden Sie unter [Verschlüsseln von Protokolldaten im Abschnitt CloudWatch Protokolle mithilfe von AWS Key Management Service Protokollen](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/encrypt-log-data-kms.html#encrypt-log-data-kms-policy) im Amazon CloudWatch Logs Benutzerhandbuch.*

```
aws ecs create-cluster \
    --cluster-name cluster-name \
    --configuration executeCommandConfiguration="{ \
        kmsKeyId=string, \
        logging=OVERRIDE, \
        logConfiguration={ \
            cloudWatchLogGroupName=cloudwatch-log-group-name, \
            cloudWatchEncryptionEnabled=true, \
            s3BucketName=s3-bucket-name, \
            s3EncryptionEnabled=true, \
            s3KeyPrefix=demo \
        } \
    }"
```

Die `logging`-Eigenschaft bestimmt das Verhalten der Protokollierungsfunktion von ECS Exec:
+ `NONE`: Protokollierung ist deaktiviert
+ `DEFAULT`: Protokolle werden an den konfigurierten `awslogs`-Treiber gesendet. Wenn der Treiber nicht konfiguriert ist, wird kein Protokoll gespeichert.
+ `OVERRIDE`: Protokolle werden an die bereitgestellten Amazon CloudWatch Logs- LogGroup, Amazon S3 S3-Bucket oder beide gesendet.

### Für Amazon CloudWatch Logs oder Amazon S3 Logging sind IAM-Berechtigungen erforderlich
<a name="ecs-exec-required-logging-permissions"></a>

Um die Protokollierung zu aktivieren, benötigt die Amazon-ECS-Aufgabenrolle, die in Ihrer Aufgabendefinition referenziert wird, zusätzliche Berechtigungen. Diese zusätzlichen Berechtigungen können der Aufgabenrolle als Richtlinie hinzugefügt werden. Sie unterscheiden sich, je nachdem, ob Sie Ihre Protokolle an Amazon CloudWatch Logs oder Amazon S3 weiterleiten.

------
#### [ Amazon CloudWatch Logs ]

Die folgende Beispielrichtlinie fügt die erforderlichen Amazon CloudWatch Logs-Berechtigungen hinzu.

****  

```
{
   "Version":"2012-10-17",		 	 	 
   "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "logs:DescribeLogGroups"
            ],
            "Resource": "*"
        },
        {
            "Effect": "Allow",
            "Action": [
               "logs:CreateLogStream",
               "logs:DescribeLogStreams",
               "logs:PutLogEvents"
            ],
            "Resource": "arn:aws:logs:us-east-1:111122223333:log-group:/aws/ecs/cloudwatch-log-group-name:*"
        }
   ]
}
```

------
#### [ Amazon S3 ]

Das folgende Beispiel einer Richtlinie fügt die erforderlichen Amazon-S3-Berechtigungen hinzu.

****  

```
{
   "Version":"2012-10-17",		 	 	 
   "Statement": [
        {
            "Effect": "Allow",
            "Action": [
               "s3:GetBucketLocation"
            ],
            "Resource": "*"
        },
        {
           "Effect": "Allow",
           "Action": [
               "s3:GetEncryptionConfiguration"
           ],
           "Resource": "arn:aws:s3:::s3-bucket-name"
        },
        {
            "Effect": "Allow",
            "Action": [
                "s3:PutObject"
            ],
            "Resource": "arn:aws:s3:::s3-bucket-name/*"
        }
    ]
   }
```

------

### Für die Verschlüsselung mit Ihrem eigenen AWS KMS key (KMS-Schlüssel) sind IAM-Berechtigungen erforderlich
<a name="ecs-exec-required-kms-permissions"></a>

Standardmäßig verwenden die zwischen Ihrem lokalen Client und dem Container übertragenen Daten die TLS 1.2-Verschlüsselung, die dies AWS ermöglicht. Um Daten mit Ihrem eigenen KMS-Schlüssel weiter zu verschlüsseln, müssen Sie einen KMS-Schlüssel erstellen und die `kms:Decrypt`-Berechtigung für Ihre Aufgaben-IAM-Rolle hinzufügen. Diese Berechtigung wird von Ihrem Container verwendet, um die Daten zu entschlüsseln. Weitere Informationen zum Erstellen eines KMS-Schlüssels finden Sie unter [Erstellen von Schlüsseln](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html).

Sie fügen die folgende Inline-Richtlinie zu Ihrer Aufgaben-IAM-Rolle hinzu, was die AWS KMS -Berechtigungen erfordern. Weitere Informationen finden Sie unter [ECS-Exec-Berechtigungen](task-iam-roles.md#ecs-exec-required-iam-permissions).

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "kms:Decrypt"
            ],
            "Resource": "arn:aws:kms:us-east-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"
        }
    ]
}
```

------

Damit die Daten mit Ihrem eigenen KMS-Schlüssel verschlüsselt werden, muss dem Benutzer oder der Gruppe, der/die die `execute-command`-Aktion verwendet, die `kms:GenerateDataKey`-Berechtigung gewährt werden.

Die folgende Beispielrichtlinie für Ihren Benutzer oder Ihre Gruppe enthält die erforderliche Berechtigung, Ihren eigenen KMS-Schlüssel zu verwenden. Sie müssen den Amazon-Ressourcennamen (ARN) Ihres KMS-Schlüssels angeben.

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "kms:GenerateDataKey"
            ],
            "Resource": "arn:aws:kms:us-east-2:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"
        }
    ]
}
```

------

## Verwenden von IAM-Richtlinien, um den Zugriff auf ECS Exec zu beschränken
<a name="ecs-exec-best-practices-limit-access-execute-command"></a>

Sie können den Benutzerzugriff auf die API-Aktion execute-command beschränken, indem Sie einen oder mehrere der folgenden IAM-Richtlinien-Bedingungsschlüssel verwenden:
+ `aws:ResourceTag/clusterTagKey`
+ `ecs:ResourceTag/clusterTagKey`
+ `aws:ResourceTag/taskTagKey`
+ `ecs:ResourceTag/taskTagKey`
+ `ecs:container-name`
+ `ecs:cluster`
+ `ecs:task`
+ `ecs:enable-execute-command`

Mit dem folgenden Beispiel einer IAM-Richtlinie können Benutzer Befehle in Containern ausführen, die innerhalb von Aufgaben mit einem Tag ausgeführt werden, das einen `environment`-Schlüssel und `development`-Wert hat und in einem Cluster mit dem Namen `cluster-name`.

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "ecs:ExecuteCommand",
                "ecs:DescribeTasks"
            ],
            "Resource": [
                   "arn:aws:ecs:us-east-1:111122223333:task/cluster-name/*",
                   "arn:aws:ecs:us-east-1:111122223333:cluster/cluster-name"
            ],
            "Condition": {
                "StringEquals": {
                    "ecs:ResourceTag/environment": "development"
                }
            }
        }
    ]
}
```

------

Im folgenden IAM-Richtlinienbeispiel können Benutzer die `execute-command`-API nicht verwenden, wenn der Containername `production-app` lautet.

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Deny",
            "Action": [
                "ecs:ExecuteCommand"
            ],
            "Resource": "*",
            "Condition": {
                "StringEquals": {                    
                    "ecs:container-name": "production-app"
                }
            }
        }
    ]
}
```

------

Mit der folgenden IAM-Richtlinie können Benutzer Aufgaben nur starten, wenn ECS Exec deaktiviert ist.

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "ecs:RunTask",
                "ecs:StartTask",
                "ecs:CreateService",
                "ecs:UpdateService"
            ],
            "Resource": "*",
            "Condition": {
                "StringEquals": {                    
                    "ecs:enable-execute-command": "false"
                }
            }
        }
    ]
}
```

------

**Anmerkung**  
Da die `execute-command`API-Aktion nur Task- und Clusterressourcen in einer Anforderung enthält, werden nur Cluster- und Task-Tags ausgewertet.

Weitere Informationen zu IAM-Richtlinienbedingungsschlüsseln finden Sie unter [Aktionen, Ressourcen und Bedingungsschlüssel für den Amazon Elastic Container Service](/service-authorization/latest/reference/list_amazonelasticcontainerservice.html) in der *Service Authorization-Referenz*.

### Beschränken des Zugriffs auf die Aktion „Sitzung starten“
<a name="ecs-exec-limit-access-start-session"></a>

Während das Starten von SSM-Sitzungen auf Ihrem Container außerhalb von ECS Exec möglich ist, kann dies möglicherweise dazu führen, dass die Sitzungen nicht protokolliert werden. Sitzungen, die außerhalb von ECS Exec gestartet wurden, zählen ebenfalls zum Sitzungskontingent. Wir empfehlen, diesen Zugriff einzuschränken, indem Sie die `ssm:start-session`-Aktion direkt für Ihre Amazon-ECS-Aufgaben mithilfe einer IAM-Richtlinie verweigern. Sie können den Zugriff auf alle Amazon-ECS-Aufgaben oder bestimmte Aufgaben basierend auf den verwendeten Tags verweigern.

Nachfolgend finden Sie eine Beispiel-IAM-Richtlinie, die den Zugriff auf die `ssm:start-session`-Aktion für Tasks in allen Regionen mit einem angegebenen Clusternamen verweigert. Optional können Sie einen Platzhalter mit `cluster-name` einschließen.

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Deny",
            "Action": "ssm:StartSession",
            "Resource": [
                   "arn:aws:ecs:us-east-1:111122223333:task/cluster-name/*"
            ]
        }
    ]
}
```

------

Nachfolgend finden Sie eine Beispiel-IAM-Richtlinie, die den Zugriff auf die `ssm:start-session`-Aktion für Ressourcen in allen Regionen, die mit Tag-Schlüssel `Task-Tag-Key` markiert sind und Tag-Wert `Exec-Task` haben, verweigert.

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Deny",
            "Action": "ssm:StartSession",
            "Resource": "arn:aws:ecs:*:*:task/*",
            "Condition": {
                "StringEquals": {
                    "aws:ResourceTag/Task-Tag-Key": "Exec-Task"
                }
            }
        }
    ]
}
```

------

## Fehlerbehebung bei ECS Exec
<a name="ecs-exec-troubleshooting-overview"></a>

Weitere Informationen zur Fehlerbehebung finden Sie unter [Beheben von Problemen mit Exec](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-exec-troubleshooting.html).

# Ausführen von Befehlen mit ECS Exec
<a name="ecs-exec-run"></a>

Sie können Amazon ECS Exec verwenden, um Diagnoseinformationen zu Ihren Containern zu sammeln und Fehler zu beheben, die während des gesamten Lebenszyklus Ihrer Container auftreten.

## Voraussetzungen
<a name="ecs-exec-run-prerequisites"></a>

Bevor Sie ECS Exec verwenden, stellen Sie sicher, dass Sie die folgenden Aktionen ausgeführt haben:
+ Überlegungen überprüfen Weitere Informationen finden Sie unter [Überlegungen](ecs-exec.md#ecs-exec-considerations).
+ Konfigurieren von ECS Exec für Ihre Aufgaben und Services Weitere Informationen finden Sie unter [Konfiguration von ECS Exec](ecs-exec.md#ecs-exec-enabling-and-using).
+ **Installieren und Konfigurieren der AWS CLI**. Weitere Informationen finden Sie unter [Erste Schritte mit der AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html).
+ **Installieren Sie das Session Manager-Plug-In für AWS CLI**. Weitere Informationen finden Sie unter [Installieren des Session Manager-Plugins für AWS CLI](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-working-with-install-plugin.html).
+ **Konfigurieren Sie eine Aufgabenrolle mit den entsprechenden Berechtigungen**. Sie müssen eine Aufgabenrolle mit den entsprechenden Berechtigungen für ECS Exec verwenden. Weitere Informationen finden Sie unter [Aufgaben-IAM-Rollen](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html).
+ **Überprüfen Sie die Versionsanforderungen**. ECS Exec hat Versionsanforderungen abhängig davon, ob Ihre Aufgaben auf Amazon EC2 oder AWS Fargate gehostet werden:
  + Wenn Sie Amazon EC2 verwenden, müssen Sie ein für Amazon ECS optimiertes AMI verwenden, das nach dem 20. Januar 2021 mit einer Agent-Version von 1.50.2 oder höher veröffentlicht wurde. Weitere Informationen finden Sie unter [Amazon ECS-optimiert AMIs](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html).
  + Wenn Sie verwenden AWS Fargate, müssen Sie die Plattformversion `1.4.0` oder höher (Linux) oder `1.0.0` (Windows) verwenden. Weitere Informationen finden Sie unter [AWS Fargate -Plattformversionen](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform-fargate.html).

## Verwenden der Konsole für Serviceaufgaben
<a name="ecs-exec-run-using-console"></a>

Sie können Befehle mit ECS Exec mithilfe der Konsole ausführen.

1. Öffnen Sie die Konsole auf [https://console.aws.amazon.com/ecs/Version](https://console.aws.amazon.com/ecs/v2) 2.

1. Wählen Sie auf der **Cluster**-Seite den Cluster aus.

1. Wählen Sie auf der Seite mit den Cluster-Details im Abschnitt **Services** den Service aus.

   Die Seite mit den Service-Details wird angezeigt.

1. Wählen Sie auf der Servie-Detailseite **Aufgaben** aus. Wählen Sie dann die Aufgabe aus.

1. Wählen Sie unter **Container** den Container aus, in dem Sie ECS Exec verwenden möchten.

1. Gehen Sie folgendermaßen vor, um Befehle auszuführen:
   + Wählen Sie **Connect** aus. 

     Es wird eine CloudShell Sitzung angezeigt, in der Sie Ihre Befehle ausführen können.
   + Wählen Sie den Pfeil und dann den **Befehl AWS CLI -Kopieren** aus.

     Sie können die Befehle dann lokal ausführen.

**Erwartete Ergebnisse**

Wenn die Verbindung erfolgreich ist, sollten Sie in Ihrem Container ein interaktives Shell-Prompt sehen. Sie können Befehle jetzt direkt in der Container-Umgebung ausführen. Um die Sitzung zu beenden, wählen Sie **Sitzung beenden**.

## Verwenden der Konsole für eigenständige Aufgaben
<a name="ecs-exec-run-using-console-standalone-tasks"></a>

Sie können Befehle mit ECS Exec mithilfe der Konsole ausführen.

1. Öffnen Sie die Konsole auf [https://console.aws.amazon.com/ecs/Version](https://console.aws.amazon.com/ecs/v2) 2.

1. Wählen Sie auf der **Cluster**-Seite den Cluster aus.

1. Wählen Sie auf der Seite mit den Cluster-Details im Abschnitt **Aufgaben** die Aufgabe aus.

   Die Seite mit den Aufgabendetails wird angezeigt.

1. Wählen Sie unter **Container** den Container aus, in dem Sie ECS Exec verwenden möchten.

1. Gehen Sie folgendermaßen vor, um Befehle auszuführen:
   + Wählen Sie **Connect** aus. 

     Es wird eine CloudShell Sitzung angezeigt, in der Sie Ihre Befehle ausführen können.
   + Wählen Sie den Pfeil und dann den **Befehl AWS CLI -Kopieren** aus.

     Sie können die Befehle dann lokal ausführen.

**Erwartete Ergebnisse**

Wenn die Verbindung erfolgreich ist, sollten Sie in Ihrem Container ein interaktives Shell-Prompt sehen. Sie können Befehle jetzt direkt in der Container-Umgebung ausführen. Um die Sitzung zu beenden, wählen Sie **Sitzung beenden**.

## Verwenden der Command Shell
<a name="ecs-exec-run-using-command-shell"></a>

Sie können Befehle mit ECS Exec mithilfe der Command Shell ausführen.

Nachdem Sie bestätigt haben, dass `ExecuteCommandAgent` ausgeführt wird, können Sie eine interaktive Shell in Ihrem Container mit dem folgenden Befehl öffnen. Wenn Ihre Aufgabe mehrere Container enthält, müssen Sie den Containernamen mithilfe des `--container`-Flag angeben. Amazon ECS unterstützt nur das Initiieren interaktiver Sitzungen. Daher müssen Sie das `--interactive`-Flag verwenden.

Mit dem folgenden Befehl wird ein interaktiver `/bin/sh` Befehl **container-name** für einen Container ausgeführt, der nach einer Aufgabe mit der ID benannt ist*task-id*.

Das *task-id* ist der Amazon-Ressourcenname (ARN) der Aufgabe.

```
aws ecs execute-command --cluster cluster-name \
    --task task-id \
    --container container-name \
    --interactive \
    --command "/bin/sh"
```

**Erwartete Ergebnisse**

Wenn der Befehl erfolgreich ausgeführt wurde, sollte ein interaktives Shell-Prompt von Ihrem Container aus angezeigt werden. Sie können Befehle jetzt direkt in der Container-Umgebung ausführen. Um die Sitzung zu beenden, geben Sie `exit` ein oder wählen Sie `Ctrl+D`.