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.
# Docker-Volumes mit Amazon ECS verwenden
Bei der Verwendung von Docker-Volumes kann der integrierte `local`-Treiber oder ein Drittanbieter-Volume-Treiber verwendet werden. Docker-Volumes werden von Docker verwaltet und es wird ein Verzeichnis in `/var/lib/docker/volumes` auf der Container-Instance erstellt, die die Volume-Daten enthält.
Um Docker-Volumes zu verwenden, geben Sie eine `dockerVolumeConfiguration` in Ihrer Aufgabendefinition an. Weitere Informationen finden Sie unter [Volumes](https://docs.docker.com/engine/storage/volumes/) in der Docker-Dokumentation.
Einige häufige Anwendungsfälle für Docker-Volumes sind folgende:
+ Das Bereitstellen von persistenten Daten-Volumes für die Nutzung mit Containern
+ Die gemeinsame Verwendung eines definierten Daten-Volumes an unterschiedlichen Orten auf verschiedenen Containern auf derselben Container-Instance
+ Das Definieren eines leeren, nicht persistenten Daten-Volumes und dessen Mounten auf mehreren Containern innerhalb der gleichen Aufgabe
+ Um Ihrer Aufgabe ein Datenvolumen zur Verfügung zu stellen, das von einem Drittanbietertreiber verwaltet wird
## Überlegungen zur Verwendung von Docker-Volumes
Bei der Verwendung von Docker-Volumes sollte Folgendes berücksichtigt werden:
+ Docker-Volumes werden nur unterstützt, wenn der EC2-Launchtyp oder externe Instances verwendet werden.
+ Windows-Container unterstützen nur die Verwendung des `local`-Treibers.
+ Wenn ein Drittanbieter-Treiber verwendet wird, stellen Sie sicher, dass dieser installiert und auf der Container-Instance aktiv ist, bevor der Container-Agent gestartet wird. Wenn der Drittanbieter-Treiber nicht aktiv ist, bevor Sie den Agenten starten, können Sie den Container-Agenten neu starten, indem Sie einen der folgenden Befehle verwenden:
+ Für das Amazon-ECS-optimierte Amazon Linux 2-AMI:
```
sudo systemctl restart ecs
```
+ Für das Amazon-ECS-optimierte Amazon Linux AMI:
```
sudo stop ecs && sudo start ecs
```
Informationen zur Angabe eines Docker-Volumes in einer Aufgabendefinition finden Sie unter [Ein Docker-Volume in einer Amazon-ECS-Aufgabendefinition angeben](specify-volume-config.md).
# Ein Docker-Volume in einer Amazon-ECS-Aufgabendefinition angeben
Bevor Ihre Container Daten-Volumes verwenden können, müssen Sie das Volume und die Konfigurationen der Mounting-Punkte in Ihrer Aufgabendefinition angeben. Dieser Abschnitt beschreibt die Volume-Konfiguration für einen Container. Für Aufgaben, die ein Docker-Volume verwenden, geben Sie eine `dockerVolumeConfiguration` an. Für Aufgaben, die ein Bind-Mount-Host-Volume verwenden, geben Sie einen `host` und optionalen `sourcePath` an.
Das folgende JSON-Codefragment der Aufgabendefinition zeigt die Syntax für die Objekte `volumes` und `mountPoints` für einen Container.
```
{
"containerDefinitions": [
{
"mountPoints": [
{
"sourceVolume": "string",
"containerPath": "/path/to/mount_volume",
"readOnly": boolean
}
]
}
],
"volumes": [
{
"name": "string",
"dockerVolumeConfiguration": {
"scope": "string",
"autoprovision": boolean,
"driver": "string",
"driverOpts": {
"key": "value"
},
"labels": {
"key": "value"
}
}
}
]
}
```
`name`
Typ: Zeichenfolge
Erforderlich: Nein
Der Name des Volumes. Bis zu 255 Buchstaben (Groß- und Kleinbuchstaben), Ziffern, Bindestriche (`-`) und Unterstriche (`_`) sind erlaubt. Auf diesen Namen wird im Parameter `sourceVolume` des `mountPoints`-Objekts der Container-Definition verwiesen.
`dockerVolumeConfiguration`
Typ: [DockerVolumeConfiguration](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DockerVolumeConfiguration.html)Objekt
Erforderlich: Nein
Dieser Parameter wird nur bei der Verwendung von Docker-Volumes angegeben. Docker-Volumes werden nur unterstützt, wenn Aufgaben auf EC2-Instances ausgeführt werden. Windows-Container unterstützen nur die Verwendung des `local`-Treibers. Um Bind-Mounts zu verwenden, geben Sie stattdessen einen `host` an.
`scope`
Typ: Zeichenfolge
Zulässige Werte: `task` \$1 `shared`
Erforderlich: Nein
Der Bereich für das Docker-Volume, der den Lebenszyklus bestimmt. Docker-Volumes, die auf eine `task` beschränkt sind, werden automatisch beim Starten der Aufgabe bereitgestellt und beim Stoppen dieser vernichtet. Docker-Volumes, die als `shared` angewendet werden, bleiben erhalten, nachdem die Aufgabe gestoppt wird.
`autoprovision`
Typ: Boolescher Wert
Standardwert: `false`
Erforderlich: Nein
Wenn dieser Wert `true` lautet, wird das Docker-Volume erstellt, wenn es nicht bereits vorhanden ist. Dieses Feld wird nur verwendet, wenn `scope` den Wert `shared` aufweist. Wenn `scope`-Wert `task` ist, muss dieser Parameter weggelassen werden.
`driver`
Typ: Zeichenfolge
Erforderlich: Nein
Der zu verwendende Docker-Volume-Treiber. Der Treiberwert muss mit dem von Docker bereitgestellten Treibernamen übereinstimmen, da dieser Name für die Aufgabenplatzierung verwendet wird. Wenn der Treiber mit der Docker-Plug-In-CLI installiert wurde, rufen Sie mit `docker plugin ls` den Treibernamen aus der Container-Instance ab. Wenn der Treiber mit einem anderen Verfahren installiert wurde, rufen Sie den Treibernamen mit der Docker-Plug-In-Erkennung ab.
`driverOpts`
Typ: Zeichenfolge
Erforderlich: Nein
Eine Zuordnung von Docker-Treiber-spezifischen Optionen für die Übergabe. Dieser Parameter ist im Bereich Ein Volume erstellen von Docker der Option `DriverOpts` zugeordnet.
`labels`
Typ: Zeichenfolge
Erforderlich: Nein
Benutzerdefinierte Metadaten, die Ihrem Docker-Volume hinzugefügt werden sollen.
`mountPoints`
Typ: Objekt-Array
Erforderlich: Nein
Die Mounting-Punkte für die Daten-Volumes in Ihrem Container. Dieser Parameter ist in der create-container-Docker-API der Option `Volumes` zugeordnet und die Option `--volume` ist der Docker-Ausführung zugeordnet.
Windows-Container können ganze Verzeichnisse auf dem gleichen Laufwerk wie `$env:ProgramData` einbinden. Windows-Container können keine Verzeichnisse auf einem anderen Laufwerk mounten, und es ist kein laufwerksübergreifender Mounting-Punkt möglich. Sie müssen Mounting-Punkte angeben, um ein Amazon-EBS-Volume direkt an eine Amazon-ECS-Aufgabe anzuhängen.
`sourceVolume`
Typ: Zeichenfolge
Erforderlich: Ja, wenn `mountPoints` verwendet werden
Der Name des einzubindenden Volumes.
`containerPath`
Typ: Zeichenfolge
Erforderlich: Ja, wenn `mountPoints` verwendet werden
Der Pfad in dem Container, in dem das Volume eingebunden wird.
`readOnly`
Typ: Boolesch
Erforderlich: Nein
Wenn dieser Wert `true` lautet, verfügt der Container über schreibgeschützten Zugriff auf das Volume. Lautet der Wert `false`, dann verfügt der Container über Schreibzugriff auf das Volume. Der Standardwert ist `false`.
Behalten Sie für Aufgaben, die auf EC2-Instances unter dem Windows-Betriebssystem ausgeführt werden, den Standardwert von `false` bei.
# Besipiel-Docker-Volumes für Amazon ECS
Die folgenden Beispiele zeigen, wie kurzlebigen Speicher für einen Container und ein gemeinsam genutztes Volume für mehrere Container bereitgestellt wird und wie persistenter NFS-Speicher für einen Container bereitgestellt wird.
**So stellen Sie flüchtigen Speicher für einen Container mit einem Docker-Volume bereit**
In diesem Beispiel verwendet ein Container ein leeres Daten-Volume, das nach Beendigung der Aufgabe entsorgt wird. Ein Beispielanwendungsfall ist, dass Sie z. B. einen Container besitzen, der während einer Aufgabe auf irgendeinen Scratch-Dateispeicherort zugreifen muss. Diese Aufgabe kann mit einem Docker-Volume gelöst werden.
1. Definieren Sie im Abschnitt `volumes` der Aufgabendefinition ein Daten-Volume mit `name`- und `DockerVolumeConfiguration`-Werten. In diesem Beispiel geben wir den Umfang als `task` an, sodass das Volume gelöscht wird, nachdem die Aufgabe angehalten wurde. Zudem wird der `local`-Treiber verwendet.
```
"volumes": [
{
"name": "scratch",
"dockerVolumeConfiguration" : {
"scope": "task",
"driver": "local",
"labels": {
"scratch": "space"
}
}
}
]
```
1. Definieren Sie im Abschnitt `containerDefinitions` einen Container mit `mountPoints`-Werten, die auf den Namen des definierten Volumes und den Wert `containerPath` verweisen, um das Volume auf den Container zu mounten.
```
"containerDefinitions": [
{
"name": "container-1",
"mountPoints": [
{
"sourceVolume": "scratch",
"containerPath": "/var/scratch"
}
]
}
]
```
**So stellen Sie persistenten Speicher für mehrere Container mit einem Docker-Volume bereit**
In diesem Beispiel möchten Sie, dass ein freigegebenes Volume für mehrere Container verwendet werden soll und es soll bestehen bleiben, nachdem jede einzelne Aufgabe gestoppt wurde, die es verwendet. Der integrierte `local`-Treiber wird verwendet, damit das Volume weiterhin mit dem Lebenszyklus der Container-Instance verknüpft ist.
1. Definieren Sie im Abschnitt `volumes` der Aufgabendefinition ein Daten-Volume mit `name`- und `DockerVolumeConfiguration`-Werten. In diesem Beispiel geben Sie einen `shared`-Geltungsbereich an, damit das Volume bestehen bleibt. Legen Sie die automatische Bereitstellung auf `true` fest, damit das Volume zur Verwendung erstellt wird. Verwenden Sie dann auch den integrierten `local`-Treiber.
```
"volumes": [
{
"name": "database",
"dockerVolumeConfiguration" : {
"scope": "shared",
"autoprovision": true,
"driver": "local",
"labels": {
"database": "database_name"
}
}
}
]
```
1. Definieren Sie im Abschnitt `containerDefinitions` einen Container mit `mountPoints`-Werten, die auf den Namen des definierten Volumes und den Wert `containerPath` verweisen, um das Volume auf den Container zu mounten.
```
"containerDefinitions": [
{
"name": "container-1",
"mountPoints": [
{
"sourceVolume": "database",
"containerPath": "/var/database"
}
]
},
{
"name": "container-2",
"mountPoints": [
{
"sourceVolume": "database",
"containerPath": "/var/database"
}
]
}
]
```
**So stellen Sie NFS-persistenten Speicher für einen Container mit einem Docker-Volume bereit**
In diesem Beispiel verwendet ein Container ein NFS-Daten-Volume, das beim Start der Aufgabe automatisch gemountet und beim Beenden der Aufgabe automatisch getrennt wird. Dies verwendet den in Docker integrierten `local`-Treiber. Ein Beispiel für einen Anwendungsfall ist, dass Sie möglicherweise über einen lokalen NFS-Speicher verfügen und von einer ECS-Anywhere-Aufgabe aus darauf zugreifen müssen. Dies kann mit einem Docker-Volume mit NFS-Treiberoption erreicht werden.
1. Definieren Sie im Abschnitt `volumes` der Aufgabendefinition ein Daten-Volume mit `name`- und `DockerVolumeConfiguration`-Werten. Geben Sie in diesem Beispiel einen `task`-Bereich an, damit das Volume nach Beendigung der Aufgabe getrennt wird. Verwenden Sie den `local`-Treiber und konfigurieren Sie `driverOpts` mit den `type`-, `device`-, and `o`-Optionen entsprechend. Ersetzen Sie `NFS_SERVER` durch den NFS-Serverendpunkt.
```
"volumes": [
{
"name": "NFS",
"dockerVolumeConfiguration" : {
"scope": "task",
"driver": "local",
"driverOpts": {
"type": "nfs",
"device": "$NFS_SERVER:/mnt/nfs",
"o": "addr=$NFS_SERVER"
}
}
}
]
```
1. Definieren Sie im `containerDefinitions`-Abschnitt einen Container mit `mountPoints`-Werten, die auf den Namen des definierten Volumes und den `containerPath`-Wert verweisen, um das Volume im Container bereitzustellen.
```
"containerDefinitions": [
{
"name": "container-1",
"mountPoints": [
{
"sourceVolume": "NFS",
"containerPath": "/var/nfsmount"
}
]
}
]
```