Beispiele für Bind-Mounts für Amazon ECS

In den folgenden Beispielen werden häufige Anwendungsfälle für die Verwendung eines Bind-Mounts für Ihre Container behandelt.

So weisen Sie einer Fargate-Aufgabe einen erhöhten flüchtigen Speicher zu

Für Amazon-ECS-Aufgaben, die auf Fargate mit Plattformversion 1.4.0 oder höher (Linux) oder 1.0.0 (Windows) gehostet werden können Sie mehr als die Standardmenge des flüchtigen Speichers für die zu verwendenden Container in Ihrer Aufgabe zuweisen. Dieses Beispiel kann in die anderen Beispiele integriert werden, um flüchtigen Speicher für Ihre Fargate-Aufgaben zuzuweisen.

Definieren Sie in der Aufgabendefinition ein ephemeralStorage-Objekt. sizeInGiB muss eine Ganzzahl zwischen den Werten von 21 und 200 sein und wird in GiB ausgedrückt.
```
"ephemeralStorage": {
    "sizeInGiB": integer
}
```

So stellen Sie ein leeres Daten-Volume für einen oder mehrere Container bereit

In einigen Fällen möchten Sie den Containern in einer Aufgabe einen Scratchspace bereitstellen. Möglicherweise besitzen Sie z. B. zwei Datenbank-Container, die während einer Aufgabe auf denselben Scratch-Dateispeicherort zugreifen müssen. Dies kann mit einem Bind-Mount erreicht werden.

Definieren Sie im Abschnitt volumes der Aufgabendefinition ein Bind-Mount mit dem Namen database_scratch.
```
  "volumes": [
    {
      "name": "database_scratch"
    }
  ]
```

Erstellen Sie im Abschnitt containerDefinitions die Datenbank-Containerdefinitionen, damit sie das Volume mounten.


"containerDefinitions": [
    {
      "name": "database1",
      "image": "my-repo/database",
      "cpu": 100,
      "memory": 100,
      "essential": true,
      "mountPoints": [
        {
          "sourceVolume": "database_scratch",
          "containerPath": "/var/scratch"
        }
      ]
    },
    {
      "name": "database2",
      "image": "my-repo/database",
      "cpu": 100,
      "memory": 100,
      "essential": true,
      "mountPoints": [
        {
          "sourceVolume": "database_scratch",
          "containerPath": "/var/scratch"
        }
      ]
    }
  ]

So stellen Sie einen Pfad und seinen Inhalt in einer Dockerdatei einem Container zur Verfügung

In diesem Beispiel haben Sie eine Dockerdatei, die Daten schreibt, die Sie in einem Container mounten möchten. Dieses Beispiel funktioniert für Aufgaben, die auf Fargate oder Amazon-EC2-Instances gehostet werden.

Erstellen Sie eine Docker-Datei. Im folgenden Beispiel wird das öffentliche Amazon Linux 2-Container-Image verwendet und eine Datei mit dem Namen examplefile im /var/log/exported-Verzeichnis, das wir innerhalb des Containers einhängen möchten. Die VOLUME-Direktive sollte einen absoluten Pfad angeben.
```
FROM public.ecr.aws/amazonlinux/amazonlinux:latest
RUN mkdir -p /var/log/exported
RUN touch /var/log/exported/examplefile
VOLUME ["/var/log/exported"]
```
Standardmäßig sind die Volume-Berechtigungen auf 0755 und der Besitzer als root festgelegt. Diese Berechtigungen können in der Dockerdatei geändert werden. Im folgenden Beispiel wird der Besitzer des /var/log/exported-Verzeichnis auf node festgelegt.
```
FROM public.ecr.aws/amazonlinux/amazonlinux:latest
RUN yum install -y shadow-utils && yum clean all
RUN useradd node
RUN mkdir -p /var/log/exported && chown node:node /var/log/exported					    
USER node
RUN touch /var/log/exported/examplefile
VOLUME ["/var/log/exported"]
```
Definieren Sie im Abschnitt volumes der Aufgabendefinition ein Volume mit dem Namen application_logs.
```
  "volumes": [
    {
      "name": "application_logs"
    }
  ]
```

Erstellen Sie im Abschnitt containerDefinitions die Containerdefinitionen der Anwendung, damit sie den Speicher mounten. Der containerPath-Wert muss mit dem absoluten Pfad übereinstimmen, der in der VOLUME-Richtlinie aus der Dockerfile angegeben ist.


  "containerDefinitions": [
    {
      "name": "application1",
      "image": "my-repo/application",
      "cpu": 100,
      "memory": 100,
      "essential": true,
      "mountPoints": [
        {
          "sourceVolume": "application_logs",
          "containerPath": "/var/log/exported"
        }
      ]
    },
    {
      "name": "application2",
      "image": "my-repo/application",
      "cpu": 100,
      "memory": 100,
      "essential": true,
      "mountPoints": [
        {
          "sourceVolume": "application_logs",
          "containerPath": "/var/log/exported"
        }
      ]
    }
  ]

So stellen Sie ein leeres Daten-Volume für einen Container bereit, der mit dem Lebenszyklus der Host-Amazon-EC2-Instance verknüpft ist

Bei Aufgaben, die auf Amazon-EC2-Instances gehostet werden, können Sie Bind-Mounts verwenden und die Daten an den Lebenszyklus der Host-Amazon-EC2-Instance binden. Das geschieht mithilfe des host-Parameters und durch Angeben eines sourcePath-Werts. Alle Dateien, die im sourcePath vorhanden sind, werden den Containern im containerPath-Wert angezeigt. Alle Dateien, die in den containerPath-Wert geschrieben werden, werden in den sourcePath-Wert auf der Host-Amazon-EC2-Instance geschrieben.

Wichtig

Amazon ECS synchronisiert Ihren Speicher nicht über Amazon-EC2-Instances hinweg. Aufgaben, die persistenten Speicher nutzen, können auf eine beliebige Amazon-EC2-Instance in Ihrem Cluster mit verfügbarer Kapazität platziert werden. Wenn Ihre Aufgaben persistenten Speicher benötigen, nachdem sie beendet und neu gestartet wurden, geben Sie beim Starten der Aufgabe mit dem AWS CLI-Befehl start-task immer dieselbe Amazon-EC2-Instance an. Sie können Amazon EFS Volumes auch für persistenten Speicher verwenden. Weitere Informationen finden Sie unter Amazon-EFS-Volumes mit Amazon ECS verwenden.

Definieren Sie im Abschnitt volumes der Aufgabendefinition ein Bind-Mount mit name- und sourcePath-Werten. Im folgenden Beispiel enthält die Host-Amazon-EC2-Instance Daten unter/ecs/webdata, die Sie im Container montieren möchten.
```
  "volumes": [
    {
      "name": "webdata",
      "host": {
        "sourcePath": "/ecs/webdata"
      }
    }
  ]
```

Definieren Sie im Abschnitt containerDefinitions einen Container mit einem mountPoints-Wert, der auf den Namen des definierten Bind-Mounts verweist, und mit dem containerPath-Wert, auf dem das Bind-Mount auf dem Container gemountet werden soll.


  "containerDefinitions": [
    {
      "name": "web",
      "image": "public.ecr.aws/docker/library/nginx:latest",
      "cpu": 99,
      "memory": 100,
      "portMappings": [
        {
          "containerPort": 80,
          "hostPort": 80
        }
      ],
      "essential": true,
      "mountPoints": [
        {
          "sourceVolume": "webdata",
          "containerPath": "/usr/share/nginx/html"
        }
      ]
    }
  ]

So mounten Sie ein definiertes Volume auf mehreren Containern an verschiedenen Standorten

Sie können ein Daten-Volume in einer Aufgabendefinition definieren und das Volume an verschiedenen Speicherorten auf verschiedenen Containern mounten. Angenommen, Ihr Host-Container besitzt einen Website-Datenordner in /data/webroot. Möglicherweise möchten Sie dieses Daten-Volume schreibgeschützt auf zwei verschiedenen Web-Servern mounten, die über verschiedene Basis-Verzeichnisse verfügen.

Definieren Sie im Abschnitt volumes der Aufgabendefinition ein Daten-Volume mit dem Namen webroot und dem Quellpfad /data/webroot.


  "volumes": [
    {
      "name": "webroot",
      "host": {
        "sourcePath": "/data/webroot"
      }
    }
  ]

Definieren Sie im Abschnitt containerDefinitions für jeden Webserver einen Container mit mountPoints-Werten, die das webroot-Volume dem containerPath-Wert zuordnen, der auf das Basisverzeichnis des betreffenden Containers verweist.


  "containerDefinitions": [
    {
      "name": "web-server-1",
      "image": "my-repo/ubuntu-apache",
      "cpu": 100,
      "memory": 100,
      "portMappings": [
        {
          "containerPort": 80,
          "hostPort": 80
        }
      ],
      "essential": true,
      "mountPoints": [
        {
          "sourceVolume": "webroot",
          "containerPath": "/var/www/html",
          "readOnly": true
        }
      ]
    },
    {
      "name": "web-server-2",
      "image": "my-repo/sles11-apache",
      "cpu": 100,
      "memory": 100,
      "portMappings": [
        {
          "containerPort": 8080,
          "hostPort": 8080
        }
      ],
      "essential": true,
      "mountPoints": [
        {
          "sourceVolume": "webroot",
          "containerPath": "/srv/www/htdocs",
          "readOnly": true
        }
      ]
    }
  ]

So mounten Sie mit `volumesFrom` Volumes aus einem anderen Container

Für Aufgaben, die auf Amazon-EC2-Instances gehostet werden, können Sie ein oder mehrere Volumes in einem Container definieren und dann den volumesFrom-Parameter in einer anderen Containerdefinition innerhalb derselben Aufgabe verwenden, um einer Mounting für alle Volumes von sourceContainer an ihrem ursprünglich definierten Mounting-Punkt herzustellen. Der Parameter volumesFrom gilt für alle Volumes, die in der Aufgabendefinition definiert sind, und für solche Volumes, die im Image mit einer Dockerfile integriert sind.

(Optional) Um ein Volume freizugeben, das in ein Image integriert ist, verwenden Sie die VOLUME-Anweisung in der Dockerfile. Im folgenden Beispiel verwendet die Dockerfile ein httpd-Image, fügt ein Volume hinzu und mountet es unter dockerfile_volume im Stammverzeichnis von Apache. Es ist der Ordner, der vom httpd-Webserver verwendet wird.
```
FROM httpd
VOLUME ["/usr/local/apache2/htdocs/dockerfile_volume"]
```
Sie können ein Image mit dieser Dockerfile erstellen und direkt in ein Repository, wie z. B. den Docker-Hub, übertragen und in Ihrer Aufgabendefinition verwenden. Das in den folgenden Schritten verwendete my-repo/httpd_dockerfile_volume-Beispiel-Image wurde mit der oben genannten Dockerfile erstellt.
Erstellen Sie eine Aufgabendefinition, die Ihre Volumes und Mounting-Punkte für die Container definiert. In diesem volumes-Beispielabschnitt erstellen Sie ein leeres Volume namens empty, das vom Docker-Daemon verwaltet wird. Auch ein Host-Volume namens host_etc ist definiert. Es exportiert den /etc-Ordner auf der Host-Container-Instance.
```
{
  "family": "test-volumes-from",
  "volumes": [
    {
      "name": "empty",
      "host": {}
    },
    {
      "name": "host_etc",
      "host": {
        "sourcePath": "/etc"
      }
    }
  ],
```
Erstellen Sie im Abschnitt der Containerdefinitionen einen Container, der die zuvor definierten Volumes mountet. In diesem Beispiel mountet der web-Container die Volumes empty und host_etc. Dies ist der Container, der das mit einem Volume in der Dockerfile erstellte Image verwendet.
```
"containerDefinitions": [
    {
      "name": "web",
      "image": "my-repo/httpd_dockerfile_volume",
      "cpu": 100,
      "memory": 500,
      "portMappings": [
        {
          "containerPort": 80,
          "hostPort": 80
        }
      ],
      "mountPoints": [
        {
          "sourceVolume": "empty",
          "containerPath": "/usr/local/apache2/htdocs/empty_volume"
        },
        {
          "sourceVolume": "host_etc",
          "containerPath": "/usr/local/apache2/htdocs/host_etc"
        }
      ],
      "essential": true
    },
```
Erstellen Sie einen anderen Container, der mit volumesFrom alle Volumes mountet, die dem Container web zugeordnet sind. Alle Volumes im web-Container werden ebenfalls im busybox-Container gemountet. Das schließt das in der Dockerfile angegebene Volume ein, das zum Erstellen des my-repo/httpd_dockerfile_volume-Images verwendet wurde.
```
    {
      "name": "busybox",
      "image": "busybox",
      "volumesFrom": [
        {
          "sourceContainer": "web"
        }
      ],
      "cpu": 100,
      "memory": 500,
      "entryPoint": [
        "sh",
        "-c"
      ],
      "command": [
        "echo $(date) > /usr/local/apache2/htdocs/empty_volume/date && echo $(date) > /usr/local/apache2/htdocs/host_etc/date && echo $(date) > /usr/local/apache2/htdocs/dockerfile_volume/date"
      ],
      "essential": false
    }
  ]
}
```
Wenn diese Aufgabe ausgeführt wird, mounten die beiden Container die Volumes, und der command im busybox-Container schreibt das Datum und die Uhrzeit in eine Datei. Diese Datei heißt date in jedem der Volume-Ordner. Die Ordner sind dann auf der Website sichtbar, die durch den Container web angezeigt wird.

Anmerkung
Da der busybox-Container einen Kurzbefehl ausführt und dann beendet wird, muss er in der Containerdefinition auf "essential": false gesetzt werden. Andernfalls wird die gesamte Aufgabe gestoppt, wenn er beendet wird.

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Ein Bind-Mount in einer Aufgabendefinition angeben

Verwalten des Container-Auslagerungsspeicherplatzes