

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.

# Sensible Daten an einen Amazon-ECS-Container übergeben
<a name="specifying-sensitive-data"></a>

Sie können vertrauliche Daten, wie z. B. Anmeldeinformationen für eine Datenbank, sicher in Ihren Container übergeben. 

Secrets, wie API-Schlüssel und Datenbankanmeldeinformationen, werden häufig von Anwendungen verwendet, um auf andere Systeme zuzugreifen. Sie bestehen häufig aus einem Benutzernamen und einem Passwort, einem Zertifikat oder einem API-Schlüssel. Der Zugriff auf diese Secrets sollte auf bestimmte IAM-Prinzipale beschränkt werden, die IAM verwenden und zur Laufzeit in Container eingespeist werden.

Secrets können nahtlos aus AWS Secrets Manager einem Amazon EC2 Systems Manager Parameter Store in Container eingefügt werden. Auf diese Secrets kann in Ihrer Aufgabe wie folgt verwiesen werden.

1. Sie werden als Umgebungsvariablen referenziert, die den `secrets`-Container-Definitionsparameter verwenden.

1. Sie werden als `secretOptions` bezeichnet, wenn Ihre Protokollierungsplattform eine Authentifizierung erfordert. Weitere Informationen finden Sie unter [Konfigurationsoptionen für die Protokollierung](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_LogConfiguration.html#API_LogConfiguration_Contents).

1. Sie werden als Secrets bezeichnet, die von Images abgerufen werden, die den `repositoryCredentials`-Container-Definitionsparameter verwenden, wenn die Registrierung, aus der der Container abgerufen wird, eine Authentifizierung erfordert. Verwenden Sie diese Methode, wenn Sie Images aus Amazon ECR Public Gallery abrufen. Weitere Informationen finden Sie unter [Private Registrierungsauthentifizierung für Aufgaben](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/private-auth.html).

Wir empfehlen Ihnen, bei der Einrichtung der Verwaltung von Secrets wie folgt vorzugehen.

## Verwenden Sie AWS Secrets Manager unseren AWS Systems Manager Parameter Store zum Speichern geheimer Materialien
<a name="security-secrets-management-recommendations-storing-secret-materials"></a>

Sie sollten API-Schlüssel, Datenbank-Anmeldeinformationen und andere geheime Materialien sicher in Secrets Manager oder als verschlüsselte Parameter im Systems Manager Parameter Store speichern. Diese Dienste ähneln sich, da es sich bei beiden um verwaltete Schlüsselwertspeicher handelt, die AWS KMS zur Verschlüsselung sensibler Daten verwendet werden. Secrets Manager bietet jedoch auch die Möglichkeit, Geheimnisse automatisch zu rotieren, Zufalls-Geheimnisse zu generieren und Geheimnisse über Konten hinweg freizugeben. Verwenden Sie Secrets Manager, um diese Features zu nutzen. Verwenden Sie andernfalls verschlüsselte Parameter im Systems Manager Parameter Store.

**Wichtig**  
Wenn sich Ihr Secret ändert, müssen Sie eine neue Bereitstellung erzwingen oder eine neue Aufgabe starten, um den neuesten Secret-Wert abzurufen. Weitere Informationen finden Sie unter den folgenden Themen:  
Aufgaben – Stoppen Sie die Aufgabe und starten Sie sie dann. Weitere Informationen erhalten Sie unter [Beenden einer Amazon-ECS-Aufgabe](standalone-task-stop.md) und [Ausführen einer Anwendung als Amazon-ECS-Aufgabe](standalone-task-create.md).
Service – Aktualisieren Sie den Service und verwenden Sie die Option Neue Bereitstellung erzwingen. Weitere Informationen finden Sie unter [Aktualisierung eines Amazon ECS-Service](update-service-console-v2.md).

## Daten aus einem verschlüsselten Amazon-S3-Bucket abrufen
<a name="security-secrets-management-recommendations-encrypted-s3-buckets"></a>

Sie sollten Geheimnisse in einem verschlüsselten Amazon-S3-Bucket speichern und Aufgabenrollen verwenden, um den Zugriff auf diese Geheimnisse zu beschränken. Dadurch wird verhindert, dass die Werte von Umgebungsvariablen versehentlich in die Protokolle gelangen und bei der Ausführung von `docker inspect` aufgedeckt werden. Wenn Sie dies tun, muss Ihre Anwendung so geschrieben werden, dass sie das Secret aus dem Amazon-S3-Bucket liest. Anweisungen dazu finden Sie unter [Festlegen des standardmäßigen serverseitigen Verschlüsselungsverhaltens für Amazon-S3-Buckets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/bucket-encryption.html).

## Das Secret mit Hilfe eines Beiwagen-Containers in ein Volume mounten
<a name="security-secrets-management-recommendations-mount-secret-volumes"></a>

Da bei Umgebungsvariablen ein erhöhtes Risiko von Datenlecks besteht, sollten Sie einen Sidecar-Container verwenden, der Ihre geheimen Daten liest AWS Secrets Manager und auf ein gemeinsam genutztes Volume schreibt. Dieser Container kann vor dem Anwendungscontainer ausgeführt und beendet werden, indem Sie [Amazon-ECS-Container-Anordnungen](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_ContainerDependency.html) verwenden. Wenn Sie dies tun, mountet der Anwendungscontainer anschließend das Volume, auf dem das Secret geschrieben wurde. Wie bei der Amazon-S3-Bucket-Methode muss Ihre Anwendung so geschrieben werden, dass sie das Secret aus dem gemeinsam genutzten Volume liest. Da das Volume auf die Aufgabe beschränkt ist, wird das Volume nach dem Beenden der Aufgabe automatisch gelöscht. Ein Beispiel finden Sie im Projekt [task-def.json](https://github.com/aws-samples/aws-secret-sidecar-injector/blob/master/ecs-task-def/task-def.json).

In Amazon EC2 kann das Volume, auf welches das Secret geschrieben wird, mit einem vom Kunden verwalteten AWS KMS -Schlüssel verschlüsselt werden. Bei aktivierter AWS Fargate Option wird der Datenträgerspeicher automatisch mithilfe eines vom Service verwalteten Schlüssels verschlüsselt. 

# Eine einzelne Umgebungsvariable an einen Amazon-ECS-Container übergeben
<a name="taskdef-envfiles"></a>

**Wichtig**  
Wir empfehlen, Ihre sensiblen Daten entweder in AWS Secrets Manager Secrets- oder AWS Systems Manager Parameter Store-Parametern zu speichern. Weitere Informationen finden Sie unter [Sensible Daten an einen Amazon-ECS-Container übergeben](specifying-sensitive-data.md).  
Die in der Aufgabendefinition angegebenen Umgebungsvariablen sind für alle Benutzer und Rollen lesbar, die die `DescribeTaskDefinition`-Aktion für die Aufgabendefinition durchführen dürfen.

Sie können Umgebungsvariablen auf folgende Weise an Ihre Container übergeben:
+ Individuell mit dem `environment`-Containerdefinitionsparameter. Dies wird auf die Option `--env` abgebildet, um auf die [https://docs.docker.com/reference/cli/docker/container/run/](https://docs.docker.com/reference/cli/docker/container/run/) zu verweisen.
+ Verwenden Sie den Container-Definitionsparameter `environmentFiles`, um eine oder mehrere Dateien aufzulisten, die die Umgebungsvariablen enthalten. Die Datei muss in Amazon S3 gehostet werden. Dies wird auf die Option `--env-file` abgebildet, um auf die [https://docs.docker.com/reference/cli/docker/container/run/](https://docs.docker.com/reference/cli/docker/container/run/) zu verweisen.

Im Folgenden finden Sie ein Ausschnitt aus einer Aufgabendefinition, in dem gezeigt wird, wie einzelne Umgebungsvariablen angegeben werden.

```
{
    "family": "",
    "containerDefinitions": [
        {
            "name": "",
            "image": "",
            ...
            "environment": [
                {
                    "name": "variable",
                    "value": "value"
                }
            ],
            ...
        }
    ],
    ...
}
```

# Umgebungsvariablen an einen Amazon-ECS-Container übergeben
<a name="use-environment-file"></a>

**Wichtig**  
Wir empfehlen, Ihre sensiblen Daten entweder in AWS Secrets Manager Secrets- oder AWS Systems Manager Parameter Store-Parametern zu speichern. Weitere Informationen finden Sie unter [Sensible Daten an einen Amazon-ECS-Container übergeben](specifying-sensitive-data.md).  
Umgebungsvariablen-Dateien sind Objekte in Amazon S3, und es gelten alle Sicherheitsüberlegungen von Amazon S3.   
Sie können den `environmentFiles`-Parameter nicht für Windows-Container und Windows-Container in Fargate verwenden.

Sie können eine Umgebungsvariablendatei erstellen und in Amazon S3 speichern, um Umgebungsvariablen an Ihren Container zu übergeben.

Durch das Angeben von Umgebungsvariablen in einer Datei können Sie Umgebungsvariablen gesammelt einfügen. Geben Sie innerhalb der Containerdefinition das Objekt `environmentFiles` mit einer Liste von Amazon S3-Buckets an, die Ihre Umgebungsvariablendateien enthalten.

Amazon ECS erzwingt keine Größenbeschränkung für die Umgebungsvariablen, aber eine große Umgebungsvariablendatei kann den Speicherplatz auffüllen. Jede Aufgabe, die eine Umgebungsvariablendatei verwendet, bewirkt, dass eine Kopie der Datei auf den Datenträger heruntergeladen wird. Amazon ECS entfernt die Datei als Teil der Aufgabenbereinigung.

Informationen zu den unterstützten Umgebungsvariablen finden Sie unter [Erweiterte Container-Definitionsparameter – Umgebung](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html#container_definition_environment).

Berücksichtigen Sie Folgendes, wenn eine Umgebungsvariablendatei in einer Containerdefinition angegeben wird.
+ Für Amazon-ECS-Aufgaben auf Amazon EC2 benötigen Ihre Container-Instances die Container-Agenten-Version `1.39.0` oder höher, um dieses Feature verwenden zu können. Informationen zum Überprüfen Ihrer Agenten-Version und zum Aktualisieren auf die neueste Version finden Sie unter [Überprüfen des Amazon-ECS-Container-Agenten](ecs-agent-update.md).
+ Für Amazon ECS-Aufgaben auf AWS Fargate müssen Ihre Aufgaben die Plattformversion `1.4.0` oder höher (Linux) verwenden, um diese Funktion nutzen zu können. Weitere Informationen finden Sie unter [Fargate-Plattformversionen für Amazon ECS](platform-fargate.md).

  Stellen Sie sicher, dass die Variable für die Betriebssystem-Plattform unterstützt wird. Weitere Informationen erhalten Sie unter [Containerdefinitionen](task_definition_parameters.md#container_definitions) und [Andere Parameter der Aufgabendefinition](task_definition_parameters.md#other_task_definition_params).
+ Die Datei muss die `.env`-Dateierweiterung und die UTF-8-Kodierung verwenden.
+ Die Aufgabenausführungsrolle ist erforderlich, um dieses Feature mit den zusätzlichen Berechtigungen für Amazon S3 zu verwenden. Auf diese Weise kann der Container-Agent die Umgebungsvariablendatei von Amazon S3 abrufen. Weitere Informationen finden Sie unter [IAM-Rolle für die Amazon-ECS-Aufgabenausführung](task_execution_IAM_role.md).
+ Es gibt ein Limit von 10 Dateien pro Aufgabendefinition.
+ Jede Zeile in einer Umgebungsdatei muss eine Umgebungsvariable im Format `VARIABLE=VALUE` enthalten. Leerzeichen oder Anführungszeichen **werden** als Teil der Werte für Amazon-ECS-Dateien einbezogen. Zeilen, die mit `#` beginnen, werden als Kommentare behandelt und ignoriert. Weitere Informationen zur Syntax der Umgebungsvariablendatei finden Sie unter [Setzen von Umgebungsvariablen (-e, --env, --env-file)](https://docs.docker.com/reference/cli/docker/container/run/#env) in der Docker-Dokumentation.

  Im Folgenden finden Sie die entsprechende Syntax.

  ```
  #This is a comment and will be ignored
  VARIABLE=VALUE
  ENVIRONMENT=PRODUCTION
  ```
+ Wenn Umgebungsvariablen mit dem `environment`-Parameter in einer Containerdefinition angegeben sind, haben sie Vorrang vor den Variablen, die in einer Umgebungsdatei enthalten sind.
+ Wenn mehrere Umgebungsdateien angegeben sind und sie dieselbe Variable enthalten, werden sie in der Reihenfolge ihres Eintrags verarbeitet. Dies bedeutet, dass der erste Wert der Variablen verwendet wird und nachfolgende Werte doppelter Variablen ignoriert werden. Es wird empfohlen, eindeutige Variablennamen zu verwenden.
+ Wenn eine Umgebungsdatei als Container-Überschreibung angegeben wird, wird sie verwendet. Darüber hinaus werden alle anderen Umgebungsdateien ignoriert, die in der Containerdefinition angegeben sind.
+ Die folgenden Regeln gelten für Fargate:
  + Die Datei wird wie eine native env.file-Docker-Datei behandelt.
  + Container-Definitionen, die auf Umgebungsvariablen verweisen, die leer sind und in Amazon S3 gespeichert sind, werden nicht im Container angezeigt.
  + Es gibt keine Unterstützung für Shell-Escape-Handling.
  + Der Container-Einstiegspunkt interpretiert die `VARIABLE`-Werte.

## Beispiel
<a name="environment-file-example"></a>

Im Folgenden finden Sie ein Ausschnitt aus einer Aufgabendefinition, in dem gezeigt wird, wie eine Umgebungsvariablendatei angegeben wird.

```
{
    "family": "",
    "containerDefinitions": [
        {
            "name": "",
            "image": "",
            ...
            "environmentFiles": [
                {
                    "value": "arn:aws:s3:::amzn-s3-demo-bucket/envfile_object_name.env",
                    "type": "s3"
                }
            ],
            ...
        }
    ],
    ...
}
```

# Secrets-Manager-Geheimnisse programmgesteuert in Amazon ECS weitergeben
<a name="secrets-app-secrets-manager"></a>

Anstatt sensible Daten in Ihrer Anwendung im Klartext fest zu kodieren, können Sie Secrets Manager verwenden, um die sensiblen Daten zu speichern.

Wir empfehlen diese Methode zum Abrufen vertraulicher Daten, da die Anwendung automatisch die neueste Version des Secrets-Manager-Geheimnisses abruft, wenn das Secrets-Manager-Geheimnis anschließend aktualisiert wird.

Erstellen Sie ein Geheimnis in Secrets Manager. Nachdem Sie ein Secrets-Manager-Geheimnis erstellt haben, aktualisieren Sie Ihren Anwendungscode, um das Geheimnis abzurufen.

Lesen Sie die folgenden Überlegungen, bevor Sie vertrauliche Daten in Secrets Manager sichern.
+ Es werden nur Geheimnisse unterstützt, die Textdaten speichern, bei denen es sich um Geheimnisse handelt, die mit dem `SecretString` [CreateSecret](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_CreateSecret.html)API-Parameter erstellt wurden. Geheimnisse, die Binärdaten speichern, bei denen es sich um Geheimnisse handelt, die mit dem `SecretBinary` [CreateSecret](https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_CreateSecret.html)API-Parameter erstellt wurden, werden nicht unterstützt.
+ Verwenden Sie Schnittstellen-VPC-Endpunkte, um die Sicherheitskontrollen zu verbessern. Sie müssen die Schnittstellen-VPC-Endpunkte für den Secrets Manager erstellen. Informationen über den VPC-Endpunkt finden Sie unter [VPC-Endpunkte erstellen](https://docs.aws.amazon.com/secretsmanager/latest/userguide/setup-create-vpc.html) im *AWS Secrets Manager -Benutzerhandbuch*.
+ Die von Ihrer Aufgabe verwendete VPC muss die DNS-Auflösung verwenden.
+ Ihre Aufgabendefinition muss eine Aufgabenrolle mit den zusätzlichen Berechtigungen für Secrets Manager verwenden. Weitere Informationen finden Sie unter [Aufgaben-IAM-Rolle für Amazon ECS](task-iam-roles.md).

## Erstellen des Secrets-Manager-Geheimnisses
<a name="secrets-app-secrets-manager-create-secret"></a>

Sie können die Secrets Manager-Konsole verwenden, um ein Secret für Ihre sensiblen Daten zu erstellen. Informationen zum Erstellen von Geheimnissen finden Sie unter [Erstellen eines AWS Secrets Manager -Geheimnisses](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html) im *AWS Secrets Manager -Benutzerhandbuch*.

## Aktualisieren Sie Ihre Anwendung, um Secrets-Manager-Geheimnisse programmgesteuert abzurufen
<a name="secrets-app-secrets-manager-update-app"></a>

Sie können Secrets mit einem Aufruf des Secrets Manager APIs direkt aus Ihrer Anwendung abrufen. Weitere Informationen finden Sie unter [Abrufen von Geheimnissen aus AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/retrieving-secrets.html) im *Benutzerhandbuch für AWS Secrets Manager *.

Informationen zum Abrufen der in der AWS Secrets Manager gespeicherten vertraulichen Daten finden Sie unter [Codebeispiele zur AWS Secrets Manager Verwendung AWS SDKs](https://docs.aws.amazon.com/code-library/latest/ug/secrets-manager_code_examples.html) in der *AWS SDK-Codebeispiel-Codebibliothek*.

# Geheimnisse von Systems Manager Parameter Store programmgesteuert in Amazon ECS übergeben
<a name="secrets-app-ssm-paramstore"></a>

Systems Manager Parameter Store ermöglicht die sichere Speicherung und Verwaltung von Geheimnissen. Sie können Daten wie Passwörter, Datenbankzeichenfolgen, EC2-Instance IDs und AMI IDs sowie Lizenzcodes als Parameterwerte speichern, anstatt diese Informationen in Ihrer Anwendung fest zu codieren. Sie können Werte als Klartext oder als verschlüsselte Daten speichern.

Wir empfehlen diese Methode zum Abrufen sensible Daten, da die Anwendung automatisch die neueste Version abruft, wenn der Parameter für Secrets Manager Parameter Store danach aktualisiert wird.

Lesen Sie die folgenden Überlegungen, bevor Sie sensible Daten im Systems Manager Parameter Store sichern.
+ Es werden nur Geheimnisse unterstützt, die Textdaten speichern. Geheimnisse zum Speichern von Binärdaten werden nicht unterstützt.
+ Verwenden Sie Schnittstellen-VPC-Endpunkte, um die Sicherheitskontrollen zu verbessern.
+ Die von Ihrer Aufgabe verwendete VPC muss die DNS-Auflösung verwenden.
+ Für Aufgaben, die EC2 verwenden, müssen Sie die Amazon-ECS-Agent-Konfigurationsvariable `ECS_ENABLE_AWSLOGS_EXECUTIONROLE_OVERRIDE=true` verwenden, um dieses Feature verwenden zu können. Sie können sie während der Erstellung der Container-Instance zur Datei `/etc/ecs/ecs.config` hinzufügen oder sie zu einer vorhandenen Instance hinzufügen und dann den ECS-Agenten neu starten. Weitere Informationen finden Sie unter [Konfiguration des Amazon-ECS-Container-Agenten](ecs-agent-config.md).
+ Ihre Aufgabendefinition muss eine Aufgabenrolle mit den zusätzlichen Berechtigungen für Systems Manager Parameter Store verwenden. Weitere Informationen finden Sie unter [Aufgaben-IAM-Rolle für Amazon ECS](task-iam-roles.md).

## Erstellen des -Parameters
<a name="secrets-app-ssm-paramstore-create-secret"></a>

Sie können die Systems-Manager-Konsole verwenden, um einen Parameter des Systems Manager Parameter Stores für Ihre sensiblen Daten zu erstellen. Weitere Informationen finden Sie im *AWS Systems Manager -Benutzerhandbuch* unter [Erstellen eines Systems-Manager-Parameters (Konsole)](https://docs.aws.amazon.com/systems-manager/latest/userguide/parameter-create-console.html) oder [Erstellen eines Systems-Manager-Parameters (AWS CLI)](https://docs.aws.amazon.com/systems-manager/latest/userguide/param-create-cli.html).

## Aktualisieren Sie Ihre Anwendung, um die Geheimnisse des Systems-Manager-Parameter-Speichers programmgesteuert abzurufen
<a name="secrets-app-ssm-paramstore-update-app"></a>

Informationen zum Abrufen der sensiblen Daten, die im Parameter Store-Parameter von Systems Manager gespeichert sind, finden Sie unter [Codebeispiele für die Verwendung durch Systems Manager AWS SDKs](https://docs.aws.amazon.com/code-library/latest/ug/ssm_code_examples.html) in der *AWS SDK-Codebeispiel-Codebibliothek*.

# Secrets-Manager-Geheimnisse über Amazon-ECS-Umgebungsvariablen weitergeben
<a name="secrets-envvar-secrets-manager"></a>

Wenn Sie ein Geheimnis als Umgebungsvariable einfügen, können Sie den vollständigen Inhalt eines Geheimnisses oder eines bestimmten JSON-Schlüssels innerhalb eines Secrets Geheimnisses angeben. Das hilft Ihnen, die sensiblen Daten zu steuern, die Ihrem Container zur Verfügung gestellt werden. Weitere Informationen zur Geheimnis-Versionsverwaltung finden Sie unter [Was ist in einem Secrets-Manager-Geheimnis enthalten?](https://docs.aws.amazon.com/secretsmanager/latest/userguide/whats-in-a-secret.html#term_version) im *Benutzerhandbuch für AWS Secrets Manager *.

Folgendes sollte bei der Injektion eines Secrets-Manager-Geheimnisses in einen Container mit einer Umgebungsvariable berücksichtigt werden.
+ Sensible Daten werden beim ersten Start des Containers an diesen übergeben. Wenn das Secret anschließend aktualisiert oder rotiert wird, erhält der Container nicht automatisch den aktualisierten Wert. Sie müssen eine neue Aufgabe starten. Alternativ können Sie, wenn Ihre Aufgabe Teil eines Services ist, den Service aktualisieren und die Option **Force new deployment (Neue Bereitstellung erzwingen)** auswählen, um den Service zu zwingen, eine neue Aufgabe zu starten.
+ Anwendungen, die auf dem Container ausgeführt werden sowie Container-Protokolle und Debugging-Tools haben Zugriff auf die Umgebungsvariablen.
+ Beachten Sie bei Amazon ECS-Aufgaben Folgendes: AWS Fargate
  + Um den vollständigen Inhalt eines Secrets als Umgebungsvariable oder in eine Protokollkonfiguration einzufügen, müssen Sie die Plattformversion `1.3.0` oder höher verwenden. Weitere Informationen finden Sie unter [Fargate-Plattformversionen für Amazon ECS](platform-fargate.md).
  + Um einen bestimmten JSON-Schlüssel oder eine Version eines Geheimnisses als Umgebungsvariable oder in eine Protokollkonfiguration einzufügen, müssen Sie die Plattformversion `1.4.0` oder höher (Linux) oder `1.0.0` (Windows) verwenden. Weitere Informationen finden Sie unter [Fargate-Plattformversionen für Amazon ECS](platform-fargate.md).
+ Bei Amazon ECS-Aufgaben auf EC2 sollte Folgendes berücksichtigt werden:
  + Um einen geheimen Schlüssel mithilfe eines bestimmten JSON-Schlüssels oder einer Secret-Version einzufügen, muss Ihre Container-Instance Version `1.37.0` oder höher des Container-Agenten haben. Wir empfehlen jedoch, die neueste Version des Container-Agenten zu verwenden. Informationen zum Überprüfen Ihrer Agenten-Version und zum Aktualisieren auf die neueste Version finden Sie unter [Überprüfen des Amazon-ECS-Container-Agenten](ecs-agent-update.md).

    Um den vollständigen Inhalt eines Secrets als Umgebungsvariable einzufügen oder ein Secret in eine Protokollkonfiguration einzufügen, muss Ihre Container-Instance Version `1.22.0` oder höher des Container-Agenten haben.
+ Verwenden Sie Schnittstellen-VPC-Endpunkte, um die Sicherheitskontrollen zu verbessern und über ein privates Subnetz eine Verbindung zu Secrets Manager herzustellen. Sie müssen die Schnittstellen-VPC-Endpunkte für den Secrets Manager erstellen. Informationen über den VPC-Endpunkt finden Sie unter [VPC-Endpunkte erstellen](https://docs.aws.amazon.com/secretsmanager/latest/userguide/setup-create-vpc.html) im *AWS Secrets Manager -Benutzerhandbuch*. Weitere Informationen zur Verwendung von Secrets Manager und Amazon VPC finden Sie unter [So stellen Sie in einer Amazon-VPC eine Verbindung zu Secrets Manager her](https://aws.amazon.com/blogs//security/how-to-connect-to-aws-secrets-manager-service-within-a-virtual-private-cloud/).
+ Für Windows-Aufgaben, die für die Verwendung des `awslogs`-Protokolltreibers konfiguriert sind, müssen Sie auch die `ECS_ENABLE_AWSLOGS_EXECUTIONROLE_OVERRIDE`-Umgebungsvariable für die Container-Instance festlegen. Verwenden Sie die folgende Syntax:

  ```
  <powershell>
  [Environment]::SetEnvironmentVariable("ECS_ENABLE_AWSLOGS_EXECUTIONROLE_OVERRIDE", $TRUE, "Machine")
  Initialize-ECSAgent -Cluster <cluster name> -EnableTaskIAMRole -LoggingDrivers '["json-file","awslogs"]'
  </powershell>
  ```
+ Ihre Aufgabendefinition muss eine Aufgabenausführungsrolle mit den zusätzlichen Berechtigungen für Secrets Manager verwenden. Weitere Informationen finden Sie unter [IAM-Rolle für die Amazon-ECS-Aufgabenausführung](task_execution_IAM_role.md).

## Erstellen Sie das AWS Secrets Manager Geheimnis
<a name="secrets-envvar-secrets-manager-create-secret"></a>

Sie können die Secrets Manager-Konsole verwenden, um ein Secret für Ihre sensiblen Daten zu erstellen. Weitere Informationen finden Sie im *AWS Secrets Manager Benutzerhandbuch* unter [Create an AWS Secrets Manager Secret](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html).

## Fügen Sie die Umgebungsvariable zur Container-Definition hinzu
<a name="secrets-envvar-secrets-manager-update-container-definition"></a>

Innerhalb der Containerdefinition können Sie Folgendes angeben:
+ Das `secrets`-Objekt, das den Namen der Umgebungsvariablen enthält, die im Container festgelegt werden soll
+ Der Amazon-Ressourcenname (ARN) des Secrets Manager-Secrets
+ Zusätzliche Parameter, die die sensiblen Daten enthalten, die dem Container angezeigt werden sollen

Das folgende Beispiel zeigt die vollständige Syntax, die für das Secrets Manager-Secret angegeben werden muss.

```
arn:aws:secretsmanager:region:aws_account_id:secret:secret-name:json-key:version-stage:version-id
```

Im folgenden Abschnitt werden die zusätzlichen Parameter beschrieben. Diese Parameter sind optional, aber wenn Sie sie nicht verwenden, müssen Sie die Doppelpunkte einschließen, damit `:` die Standardwerte verwendet. Beispiele finden Sie unten für weiteren Kontext.

`json-key`  
Gibt den Namen des Schlüssels in einem Schlüssel-Wert-Paar mit dem Wert an, den Sie als Umgebungsvariablenwert festlegen möchten. Nur Werte im JSON-Format werden unterstützt. Wenn Sie keinen JSON-Schlüssel angeben, wird der vollständige Inhalt des Secrets verwendet.

`version-stage`  
Gibt die Phasenbeschriftung der Version eines Secrets an, die Sie verwenden möchten. Wenn eine Versionsphasenbeschriftung angegeben ist, können Sie keine Versions-ID angeben. Wenn keine Versionsphase angegeben wird, besteht das Standardverhalten darin, das Secret Schlüssel mit der `AWSCURRENT`-Phasenbeschriftung abzurufen.  
Phasenbeschriftungen werden verwendet, um verschiedene Versionen eines Secrets zu verfolgen, wenn sie aktualisiert oder rotiert werden. Jede Version eines Secrets hat eine oder mehrere Phasenbeschriftungen und eine ID.

`version-id`  
Gibt die eindeutige ID der Version des Secrets an, die Sie verwenden möchten. Wenn eine Versions-ID angegeben wird, können Sie keine Versionsphasenbeschriftung angeben. Wenn keine Versions-ID angegeben wird, besteht das Standardverhalten darin, den geheimen Schlüssel mit der `AWSCURRENT`-Phasenbeschriftung abzurufen.  
Versionen IDs werden verwendet, um den Überblick über verschiedene Versionen eines Geheimnisses zu behalten, wenn sie entweder aktualisiert oder ausgetauscht werden. Jede Version eines Secrets hat eine ID. Weitere Informationen erhalten Sie unter [Zentrale Begriffe und Konzepte für AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/terms-concepts.html#term_secret) im *AWS Secrets Manager -Benutzerhandbuch*.

### Beispiel-Containerdefinitionen
<a name="secrets-examples"></a>

Die folgenden Beispiele zeigen, wie Sie auf Secrets Manager-Secrets in Ihren Containerdefinitionen verweisen können.

**Example Verweisen auf ein vollständiges Secret**  
Im Folgenden finden Sie einen Ausschnitt einer Aufgabendefinition mit dem Format beim Verweisen auf den vollständigen Text eines Secrets Manager-Secret.  

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:secret_name-AbCdEf"
    }]
  }]
}
```
Um innerhalb des Containers auf den Wert dieses Geheimnisses zuzugreifen, müssten Sie den `$environment_variable_name` aufrufen.

**Example Verweisen auf vollständige Secrets**  
Im Folgenden finden Sie einen Ausschnitt einer Aufgabendefinition mit dem Format beim Verweisen auf den vollständigen Text mehrerer Secrets-Manager-Geheimnisse.  

```
{
  "containerDefinitions": [{
     "secrets": [
      {
        "name": "environment_variable_name1",
         "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:secret_name-AbCdEf"
      },
      {
        "name": "environment_variable_name2",
         "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:secret_name-abcdef"
      },
      {
        "name": "environment_variable_name3",
        "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:secret_name-ABCDEF"
      }
    ]
  }]
}
```
Um innerhalb des Containers auf den Wert dieses Geheimnisses zuzugreifen, müssten Sie `$environment_variable_name1`, `$environment_variable_name2`, und `$environment_variable_name3` aufrufen.

**Example Verweisen auf einen bestimmten Schlüssel innerhalb eines Secrets**  
Im Folgenden wird ein Beispiel für die Ausgabe eines [get-secret-value](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/get-secret-value.html)Befehls gezeigt, der den Inhalt eines Secrets zusammen mit der zugehörigen Staging-Bezeichnung der Version und der zugehörigen Versions-ID anzeigt.  

```
{
    "ARN": "arn:aws:secretsmanager:region:aws_account_id:secret:appauthexample-AbCdEf",
    "Name": "appauthexample",
    "VersionId": "871d9eca-18aa-46a9-8785-981ddEXAMPLE",
    "SecretString": "{\"username1\":\"password1\",\"username2\":\"password2\",\"username3\":\"password3\"}",
    "VersionStages": [
        "AWSCURRENT"
    ],
    "CreatedDate": 1581968848.921
}
```
Verweisen Sie auf einen bestimmten Schlüssel aus der vorherigen Ausgabe in einer Containerdefinition, indem Sie den Schlüsselnamen am Ende des ARN angeben.  

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:appauthexample-AbCdEf:username1::"
    }]
  }]
}
```

**Example Verweisen auf eine bestimmte Secret-Version**  
Im Folgenden wird eine Beispielausgabe eines [describe-secret ](https://docs.aws.amazon.com/cli/latest/reference/secretsmanager/describe-secret.html)-Befehls gezeigt, der den unverschlüsselten Inhalt eines Secrets zusammen mit den Metadaten für alle Versionen des Secrets anzeigt.  

```
{
    "ARN": "arn:aws:secretsmanager:region:aws_account_id:secret:appauthexample-AbCdEf",
    "Name": "appauthexample",
    "Description": "Example of a secret containing application authorization data.",
    "RotationEnabled": false,
    "LastChangedDate": 1581968848.926,
    "LastAccessedDate": 1581897600.0,
    "Tags": [],
    "VersionIdsToStages": {
        "871d9eca-18aa-46a9-8785-981ddEXAMPLE": [
            "AWSCURRENT"
        ],
        "9d4cb84b-ad69-40c0-a0ab-cead3EXAMPLE": [
            "AWSPREVIOUS"
        ]
    }
}
```
Verweisen Sie auf eine bestimmte Versionsphasenbeschriftung aus der vorherigen Ausgabe in einer Containerdefinition, indem Sie den Schlüsselnamen am Ende des ARN angeben.  

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:appauthexample-AbCdEf::AWSPREVIOUS:"
    }]
  }]
}
```
Verweisen Sie auf eine bestimmte Versions-ID der vorherigen Ausgabe in einer Containerdefinition, indem Sie den Schlüsselnamen am Ende des ARN angeben.  

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:appauthexample-AbCdEf:::9d4cb84b-ad69-40c0-a0ab-cead3EXAMPLE"
    }]
  }]
}
```

**Example Verweisen auf einen bestimmten Schlüssel und eine Versionsphasenbeschriftung eines Secrets**  
Im Folgenden wird gezeigt, wie Sie sowohl auf einen bestimmten Schlüssel innerhalb eines Secrets als auch auf eine bestimmte Versionsphasenbeschriftung verweisen.  

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:appauthexample-AbCdEf:username1:AWSPREVIOUS:"
    }]
  }]
}
```
Verwenden Sie die folgende Syntax, um einen bestimmten Schlüssel und eine Versions-ID anzugeben.  

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:appauthexample-AbCdEf:username1::9d4cb84b-ad69-40c0-a0ab-cead3EXAMPLE"
    }]
  }]
}
```

Informationen zum Erstellen einer Aufgabendefinition mit dem in einer Umgebungsvariable angegebenen Geheimnis finden Sie unter [Erstellen einer Amazon-ECS-Aufgabendefinition mit der Konsole](create-task-definition.md). 

# Systems-Manager-Parameter über Amazon-ECS-Umgebungsvariablen weitergeben
<a name="secrets-envvar-ssm-paramstore"></a>

Amazon ECS ermöglicht es Ihnen, vertrauliche Daten in Ihre Container einzufügen, indem Sie Ihre sensiblen Daten in AWS Systems Manager Parameter Store-Parametern speichern und sie dann in Ihrer Container-Definition referenzieren.

Folgendes sollte beachtet werden, wenn eine Umgebungsvariable zum Einfügen eines System-Manager-Geheimnisses in einen Container verwendet wird.
+ Sensible Daten werden beim ersten Start des Containers an diesen übergeben. Wenn das Secret anschließend aktualisiert oder rotiert wird, erhält der Container nicht automatisch den aktualisierten Wert. Sie müssen eine neue Aufgabe starten. Alternativ können Sie, wenn Ihre Aufgabe Teil eines Services ist, den Service aktualisieren und die Option **Force new deployment (Neue Bereitstellung erzwingen)** auswählen, um den Service zu zwingen, eine neue Aufgabe zu starten.
+ Bei Amazon ECS-Aufgaben sollte Folgendes beachtet werden: AWS Fargate
  + Um den vollständigen Inhalt eines Secrets als Umgebungsvariable oder in eine Protokollkonfiguration einzufügen, müssen Sie die Plattformversion `1.3.0` oder höher verwenden. Weitere Informationen finden Sie unter [Fargate-Plattformversionen für Amazon ECS](platform-fargate.md).
  + Um einen bestimmten JSON-Schlüssel oder eine Version eines Geheimnisses als Umgebungsvariable oder in eine Protokollkonfiguration einzufügen, müssen Sie die Plattformversion `1.4.0` oder höher (Linux) oder `1.0.0` (Windows) verwenden. Weitere Informationen finden Sie unter [Fargate-Plattformversionen für Amazon ECS](platform-fargate.md).
+ Bei Amazon ECS-Aufgaben auf EC2 sollte Folgendes berücksichtigt werden:
  + Um einen geheimen Schlüssel mithilfe eines bestimmten JSON-Schlüssels oder einer Secret-Version einzufügen, muss Ihre Container-Instance Version `1.37.0` oder höher des Container-Agenten haben. Wir empfehlen jedoch, die neueste Version des Container-Agenten zu verwenden. Informationen zum Überprüfen Ihrer Agenten-Version und zum Aktualisieren auf die neueste Version finden Sie unter [Überprüfen des Amazon-ECS-Container-Agenten](ecs-agent-update.md).

    Um den vollständigen Inhalt eines Secrets als Umgebungsvariable einzufügen oder ein Secret in eine Protokollkonfiguration einzufügen, muss Ihre Container-Instance Version `1.22.0` oder höher des Container-Agenten haben.
+ Verwenden Sie Schnittstellen-VPC-Endpunkte, um die Sicherheitskontrollen zu verbessern. Sie müssen die Schnittstellen-VPC-Endpunkte für Systems Manager erstellen. Weitere Informationen über den VPC-Endpunkt finden Sie unter [Die Sicherheit von EC2-Instances mithilfe von VPC-Endpunkten für Systems Manager verbessern](https://docs.aws.amazon.com/systems-manager/latest/userguide/setup-create-vpc.html) im *Benutzerhandbuch für AWS Systems Manager *.
+ Ihre Aufgabendefinition muss eine Aufgabenausführungsrolle mit den zusätzlichen Berechtigungen für Systems Manager Parameter Store verwenden. Weitere Informationen finden Sie unter [IAM-Rolle für die Amazon-ECS-Aufgabenausführung](task_execution_IAM_role.md).
+ Für Windows-Aufgaben, die für die Verwendung des `awslogs`-Protokolltreibers konfiguriert sind, müssen Sie auch die `ECS_ENABLE_AWSLOGS_EXECUTIONROLE_OVERRIDE`-Umgebungsvariable für die Container-Instance festlegen. Verwenden Sie die folgende Syntax:

  ```
  <powershell>
  [Environment]::SetEnvironmentVariable("ECS_ENABLE_AWSLOGS_EXECUTIONROLE_OVERRIDE", $TRUE, "Machine")
  Initialize-ECSAgent -Cluster <cluster name> -EnableTaskIAMRole -LoggingDrivers '["json-file","awslogs"]'
  </powershell>
  ```

## Den Systems-Manager-Parameter erstellen
<a name="secrets-envvar-ssm-paramstore-create-parameter"></a>

Sie können die Systems-Manager-Konsole verwenden, um einen Parameter des Systems Manager Parameter Stores für Ihre sensiblen Daten zu erstellen. Weitere Informationen finden Sie im *AWS Systems Manager -Benutzerhandbuch* unter [Erstellen eines Systems-Manager-Parameters (Konsole)](https://docs.aws.amazon.com/systems-manager/latest/userguide/parameter-create-console.html) oder [Erstellen eines Systems-Manager-Parameters (AWS CLI)](https://docs.aws.amazon.com/systems-manager/latest/userguide/param-create-cli.html).

## Fügen Sie die Umgebungsvariable zur Container-Definition hinzu
<a name="secrets-ssm-paramstore-update-container-definition"></a>

Geben Sie innerhalb Ihrer Container-Definition in der Aufgabendefinition `secrets` an, und geben Sie dabei den Namen der im Container einzustellenden Umgebungsvariable und den vollständigen ARN des Parameters von Systems Manager Parameter Store an, der die sensiblen Daten enthält, die dem Container präsentiert werden sollen. Weitere Informationen finden Sie unter [secrets](task_definition_parameters.md#ContainerDefinition-secrets).

Im Folgenden finden Sie einen Ausschnitt einer Aufgabendefinition mit dem Format beim Verweisen auf einen Systems Manager Parameter Store-Parameter. Wenn sich der Systems Manager Parameter Store-Parameter in der gleichen Region wie die Aufgabe befindet, die Sie starten, können Sie entweder den vollständigen ARN oder den Namen des Parameters verwenden. Wenn der Parameter in einer anderen Region existiert, geben Sie den vollen ARN an.

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:ssm:region:aws_account_id:parameter/parameter_name"
    }]
  }]
}
```

Informationen zum Erstellen einer Aufgabendefinition mit dem in einer Umgebungsvariable angegebenen Geheimnis finden Sie unter [Erstellen einer Amazon-ECS-Aufgabendefinition mit der Konsole](create-task-definition.md).

## Aktualisieren Sie Ihre Anwendung, um die Geheimnisse des Systems-Manager-Parameter-Speichers programmgesteuert abzurufen
<a name="secrets-ssm-paramstore-update-app"></a>

Informationen zum Abrufen der sensiblen Daten, die im Parameter Store-Parameter von Systems Manager gespeichert sind, finden Sie unter [Codebeispiele für die Verwendung durch Systems Manager AWS SDKs](https://docs.aws.amazon.com/code-library/latest/ug/ssm_code_examples.html) in der *AWS SDK-Codebeispiel-Codebibliothek*.

# Geheimnisse für die Amazon-ECS-Protokollierungskonfiguration weitergeben
<a name="secrets-logconfig"></a>

Sie können den `secretOptions`-Parameter in `logConfiguration` verwenden, um sensible Daten zu übergeben, die für die Protokollierung verwendet werden.

Sie können das Geheimnis in Secrets Manager oder Systems Manager speichern.

## Secrets Manager verwenden
<a name="secrets-logconfig-secrets-manager"></a>

Bei der Angabe von `logConfiguration` können Sie `secretOptions` in Ihrer Containerdefinition mit dem Namen der im Container festzulegenden Protokolltreiberoption und dem vollständigen ARN des Secrets Manager-Secrets angeben, in dem die sensiblen Daten enthalten sind, die dem Container zur Verfügung gestellt werden sollen. Weitere Informationen zum Erstellen von Geheimnissen finden Sie unter [Erstellen eines AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html).

Im Folgenden finden Sie einen Ausschnitt einer Aufgabendefinition mit dem Format beim Verweisen auf ein Secrets Manager-Secret.

```
{
  "containerDefinitions": [{
    "logConfiguration": [{
      "logDriver": "splunk",
      "options": {
        "splunk-url": "https://your_splunk_instance:8088"
      },
      "secretOptions": [{
        "name": "splunk-token",
        "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:secret_name-AbCdEf"
      }]
    }]
  }]
}
```

## Fügen Sie die Umgebungsvariable zur Container-Definition hinzu
<a name="secrets-envvar-ssm-paramstore-update-container-definition"></a>

Geben Sie in Ihrer Containerdefinition `secrets` mit dem Namen der im Container zu setzenden Umgebungsvariablen und dem Namen oder dem ARN des Systems Manager-Parameter Store-Parameters an, der die sensiblen Daten enthält, die dem Container präsentiert werden sollen. Weitere Informationen finden Sie unter [secrets](task_definition_parameters.md#ContainerDefinition-secrets).

Im Folgenden finden Sie einen Ausschnitt einer Aufgabendefinition mit dem Format beim Verweisen auf einen Systems Manager Parameter Store-Parameter. Wenn sich der Systems Manager Parameter Store-Parameter in der gleichen Region wie die Aufgabe befindet, die Sie starten, können Sie entweder den vollständigen ARN oder den Namen des Parameters verwenden. Wenn der Parameter in einer anderen Region existiert, geben Sie den vollen ARN an.

```
{
  "containerDefinitions": [{
    "secrets": [{
      "name": "environment_variable_name",
      "valueFrom": "arn:aws:ssm:region:aws_account_id:parameter/parameter_name"
    }]
  }]
}
```

Informationen zum Erstellen einer Aufgabendefinition mit dem in einer Umgebungsvariable angegebenen Geheimnis finden Sie unter [Erstellen einer Amazon-ECS-Aufgabendefinition mit der Konsole](create-task-definition.md).

## Verwenden von Systems Manager
<a name="secrets-logconfig-ssm-paramstore"></a>

Sie können vertrauliche Daten in eine Protokollkonfiguration einfügen. Beim Angeben von `logConfiguration` können Sie `secretOptions` in Ihrer Containerdefinition mit dem Namen der im Container festzulegenden Protokolltreiberoption und dem vollständigen ARN des Systems Manager-Parameter Store-Parameters angeben, in denen die sensiblen Daten enthalten sind, die dem Container präsentiert werden sollen.

**Wichtig**  
Wenn sich der Systems Manager Parameter Store-Parameter in der gleichen Region wie die Aufgabe befindet, die Sie starten, können Sie entweder den vollständigen ARN oder den Namen des Parameters verwenden. Wenn der Parameter in einer anderen Region existiert, geben Sie den vollen ARN an.

Im Folgenden finden Sie einen Ausschnitt einer Aufgabendefinition mit dem Format beim Verweisen auf einen Systems Manager Parameter Store-Parameter.

```
{
  "containerDefinitions": [{
    "logConfiguration": [{
      "logDriver": "fluentd",
      "options": {
        "tag": "fluentd demo"
      },
      "secretOptions": [{
        "name": "fluentd-address",
        "valueFrom": "arn:aws:ssm:region:aws_account_id:parameter:/parameter_name"
      }]
    }]
  }]
}
```

# Angeben sensibler Daten mithilfe von Secrets-Manager-Geheimnissen in Amazon ECS
<a name="specifying-sensitive-data-tutorial"></a>

Amazon ECS ermöglicht es Ihnen, vertrauliche Daten in Ihre Container einzufügen, indem Sie Ihre sensiblen Daten in AWS Secrets Manager Geheimnissen speichern und dann in Ihrer Container-Definition auf sie verweisen. Weitere Informationen finden Sie unter [Sensible Daten an einen Amazon-ECS-Container übergeben](specifying-sensitive-data.md).

Das folgende Tutorial zeigt, wie Sie ein Secrets-Manager-Geheimnis erstellen, in einer Amazon-ECS-Aufgabendefinition auf das Geheimnis verweisen und es dann überprüfen, indem Sie die Umgebungsvariable in einem Container abfragen, um den Inhalt des Geheimnisses anzuzeigen.

## Voraussetzungen
<a name="specifying-sensitive-data-tutorial-prereqs"></a>

In diesem Tutorial wird davon ausgegangen, dass die folgenden Voraussetzungen erfüllt wurden:
+ Die Schritte in [Einrichtung für die Verwendung von Amazon ECS](get-set-up-for-amazon-ecs.md) wurden ausgeführt.
+ Ihr Benutzer hat die erforderlichen IAM-Berechtigungen zum Erstellen der Secrets-Manager- und Amazon-ECS-Ressourcen.

## Schritt 1: Erstellen eines Secrets Manager-Secrets
<a name="specifying-sensitive-data-tutorial-create-secret"></a>

Sie können die Secrets Manager-Konsole verwenden, um ein Secret für Ihre sensiblen Daten zu erstellen. In diesem Tutorial erstellen wir ein grundlegendes Secret zum Speichern eines Benutzernamens und eines Passworts zum späteren Verweisen in einem Container. Weitere Informationen finden Sie unter [Create an AWS Secrets Manager Secret](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html) im *AWS Secrets Manager Benutzerhandbuch*.

Die ** key/value Paare, die in diesem Secret gespeichert werden sollen**, entsprechen dem Wert der Umgebungsvariablen in Ihrem Container am Ende des Tutorials.

Speichern Sie den **Secret ARN** (Geheimen ARN), um ihn in späteren Schritten in Ihrer IAM-Richtlinie für die Aufgabenausführung und der Aufgabendefinition zu verwenden.

## Schritt 2: Hinzufügen der Geheimnis-Berechtigungen zur Aufgabenausführungsrolle
<a name="specifying-sensitive-data-tutorial-update-iam"></a>

Damit Amazon ECS sensible Daten aus Ihrem Secrets-Manager-Geheimnis abrufen kann, benötigen Sie die Geheimnis-Berechtigungen für die Aufgabenausführungsrolle. Weitere Informationen finden Sie unter [Berechtigungen für Secrets Manager oder Systems Manager](task_execution_IAM_role.md#task-execution-secrets).

## Schritt 3: Erstellen einer Aufgabendefinition
<a name="specifying-sensitive-data-tutorial-create-taskdef"></a>

Sie können die Amazon-ECS-Konsole verwenden, um eine Aufgabendefinition zu erstellen, die auf ein Secrets Manager-Secret verweist.

**So erstellen Sie eine Aufgabendefinition, die ein Secret angibt**

Verwenden Sie die IAM-Konsole zum Aktualisieren Ihrer Aufgabenausführungsrolle mit den erforderlichen Berechtigungen.

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 im Navigationsbereich **Task definitions** (Aufgabendefinitionen) aus.

1. Wählen Sie **Create new task definition** (Neue Aufgabendefinition erstellen), **Create new task definition with JSON** (Neue Aufgabendefinition mit JSON) erstellen.

1. Geben Sie in das JSON-Editor-Feld den folgenden JSON-Text für die Aufgabendefinition ein. Achten Sie darauf, dass Sie den vollständigen ARN des Secrets-Manager-Geheimnisses, das Sie in Schritt 1 erstellt haben, und die Aufgabenausführungsrolle, die Sie im Schritt 2 aktualisiert haben, angeben. Wählen Sie **Speichern**.

1. 

   ```
   {
       "executionRoleArn": "arn:aws:iam::aws_account_id:role/ecsTaskExecutionRole",
       "containerDefinitions": [
           {
               "entryPoint": [
                   "sh",
                   "-c"
               ],
               "portMappings": [
                   {
                       "hostPort": 80,
                       "protocol": "tcp",
                       "containerPort": 80
                   }
               ],
               "command": [
                   "/bin/sh -c \"echo '<html> <head> <title>Amazon ECS Sample App</title> <style>body {margin-top: 40px; background-color: #333;} </style> </head><body> <div style=color:white;text-align:center> <h1>Amazon ECS Sample App</h1> <h2>Congratulations!</h2> <p>Your application is now running on a container in Amazon ECS.</p> </div></body></html>' >  /usr/local/apache2/htdocs/index.html && httpd-foreground\""
               ],
               "cpu": 10,
               "secrets": [
                   {
                       "valueFrom": "arn:aws:secretsmanager:region:aws_account_id:secret:username_value",
                       "name": "username_value"
                   }
               ],
               "memory": 300,
               "image": "public.ecr.aws/docker/library/httpd:2.4",
               "essential": true,
               "name": "ecs-secrets-container"
           }
       ],
       "family": "ecs-secrets-tutorial"
   }
   ```

1. Wählen Sie **Erstellen** aus.

## Schritt 4: Erstellen eines Clusters
<a name="specifying-sensitive-data-tutorial-create-cluster"></a>

Verwenden Sie die Amazon-ECS-Konsole zum Erstellen eines Clusters, der eine Container-Instance zum Ausführen der Aufgabe enthält. Wenn Sie bereits über einen Cluster mit mindestens einer registrierten Container-Instance und den Ressourcen zum Ausführen einer Instance der für dieses Tutorial erstellten Aufgabendefinition verfügen, können Sie direkt zum nächsten Schritt gehen.

Für dieses Tutorial erstellen wir einen Cluster mit einer `t2.micro`-Container-Instance unter Verwendung des Amazon-ECS-optimierten Amazon Linux 2-AMI.

Informationen zum Erstellen eines Clusters für EC2 finden Sie unter [Erstellen eines Amazon-ECS-Clusters für Amazon-EC2-Workloads](create-ec2-cluster-console-v2.md).

## Schritt 5: Führen Sie eine Aufgabe aus
<a name="specifying-sensitive-data-tutorial-run-task"></a>

Sie können die Amazon-ECS-Konsole verwenden, um eine Aufgabe mithilfe der Aufgabendefinition auszuführen, die Sie erstellt haben. In diesem Tutorial führen wir eine Aufgabe mit EC2 aus und verwenden dazu den Cluster, den wir im vorherigen Schritt erstellt haben. 

Informationen zum Ausführen einer Aufgabe finden Sie unter [Ausführen einer Anwendung als Amazon-ECS-Aufgabe](standalone-task-create.md).

## Schritt 6: Überprüfen
<a name="specifying-sensitive-data-tutorial-verify"></a>

Anhand folgender Schritte können Sie überprüfen, ob alle Schritte erfolgreich abgeschlossen wurden und die Umgebungsvariable in Ihrem Container ordnungsgemäß erstellt wurde.

**Überprüfen, ob die Umgebungsvariable erstellt wurde**

1. Suchen Sie nach der öffentlichen IP-Adresse oder DNS-Adresse für Ihre Container-Instance.

   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 im Navigationsbereich **Cluster** und dann den von Ihnen erstellten Cluster aus.

   1. Wählen Sie **Infrastruktur** und dann die Container-Instance aus.

   1. Zeichnen Sie die **öffentliche IP** oder das **öffentliche DNS** für Ihre Instance auf.

1. Stellen Sie auf einem macOS- oder Linux-Computer mit dem folgenden Befehl eine Verbindung mit Ihrer Instance her und ersetzen Sie den Pfad zu Ihrem privaten Schlüssel und die öffentliche Adresse für Ihre Instance:

   ```
   $ ssh -i /path/to/my-key-pair.pem ec2-user@ec2-198-51-100-1.compute-1.amazonaws.com
   ```

   Weitere Informationen zur Verwendung eines Windows-Computers finden Sie unter [Herstellen einer Verbindung mit Ihrer Linux-Instance mit PuTTY](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/connect-linux-inst-from-windows.html) im *Amazon-EC2-Benutzerhandbuch*.
**Wichtig**  
Weitere Informationen zu Problemen beim Herstellen der Verbindung mit Ihrer Instance finden Sie unter [Beheben von Verbindungsproblemen mit Ihrer Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/TroubleshootingInstancesConnecting.html) im *Benutzerhandbuch für Amazon EC2*.

1. Erstellen Sie eine Liste der Container, die auf der Instance ausgeführt werden. Notieren Sie die Container-ID für `ecs-secrets-tutorial`-Container.

   ```
   docker ps
   ```

1. Stellen Sie mithilfe der Container-ID aus der Ausgabe des vorherigen Schritts eine Verbindung mit dem `ecs-secrets-tutorial`-Container her.

   ```
   docker exec -it container_ID /bin/bash
   ```

1. Verwenden Sie den `echo`-Befehl, um den Wert der Umgebungsvariable zu drucken.

   ```
   echo $username_value
   ```

   Wenn das Tutorial erfolgreich war, sollten Sie die folgende Meldung sehen:

   ```
   password_value
   ```
**Anmerkung**  
Alternativ können Sie alle Umgebungsvariablen in Ihrem Container mithilfe des Befehls `env` (oder `printenv`) auflisten.

## Schritt 7: Bereinigen
<a name="specifying-sensitive-data-tutorial-cleanup"></a>

Wenn Sie mit diesem Tutorial fertig sind, sollten Sie die zugehörigen Ressourcen bereinigen, um zu vermeiden, dass Gebühren für ungenutzte Ressourcen anfallen.

**So bereinigen Sie die Ressourcen**

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

1. Klicken Sie im Navigationsbereich auf **Cluster**.

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

1. Wählen Sie **Delete Cluster** (Cluster löschen) aus. 

1. Geben Sie im Bestätigungsfeld **Löschen *cluster name*** ein und wählen Sie dann **Löschen** aus.

1. Öffnen Sie unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/) die IAM-Konsole.

1. Wählen Sie im Navigationsbereich **Rollen**. 

1. Durchsuchen Sie die Liste der Rollen für `ecsTaskExecutionRole` und wählen Sie diese aus.

1. Wähle „**Berechtigungen**“ und dann das **X** neben „**ECSSecretsTutorial**“. Wählen Sie **Remove (Entfernen)** aus.

1. Öffnen Sie die Secrets Manager Manager-Konsole unter [https://console.aws.amazon.com/secretsmanager/](https://console.aws.amazon.com/secretsmanager/).

1. Wählen Sie das von Ihnen erstellte **username\$1value**-Secret und **Actions (Aktionen)**, **Delete secret (Secret löschen)**.