Bind-Mount-Beispiele für Amazon ECS

Die folgenden Beispiele behandeln die häufigsten Anwendungsfälle für die Verwendung eines Bind-Mounts für Ihre Container.

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 Datenvolume 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 EC2 Amazon-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"
        }
      ]
    }
  ]

Um ein leeres Datenvolumen für einen Container bereitzustellen, das an den Lebenszyklus der EC2 Host-Amazon-Instance gebunden ist

Für Aufgaben, die auf EC2 Amazon-Instances gehostet werden, können Sie Bind-Mounts verwenden und die Daten an den Lebenszyklus der EC2 Host-Amazon-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 EC2 Host-Amazon-Instance geschrieben.

Wichtig

Amazon ECS synchronisiert Ihren Speicher nicht zwischen EC2 Amazon-Instances. Aufgaben, die persistenten Speicher verwenden, können auf jeder EC2 Amazon-Instance in Ihrem Cluster platziert werden, die über verfügbare Kapazität verfügt. Wenn Ihre Aufgaben nach dem Stoppen und Neustarten persistenten Speicher benötigen, geben Sie beim Start der Aufgabe immer dieselbe EC2 Amazon-Instance mit dem Befehl AWS CLI start-task an. Sie können Amazon EFS Volumes auch für persistenten Speicher verwenden. Weitere Informationen finden Sie unter Verwenden Sie Amazon EFS-Volumes mit Amazon ECS.

Definieren Sie im Abschnitt volumes der Aufgabendefinition ein Bind-Mount mit name- und sourcePath-Werten. Im folgenden Beispiel enthält die EC2 Host-Amazon-Instance Daten/ecs/webdata, die Sie im Container mounten 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 Datenvolume 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 Datenvolume schreibgeschützt auf zwei verschiedenen Webservern mounten, die über verschiedene Basisverzeichnisse verfügen.

Definieren Sie im Abschnitt volumes der Aufgabendefinition ein Datenvolume 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 EC2 Amazon-Instances gehostet werden, können Sie ein oder mehrere Volumes in einem Container definieren und dann den volumesFrom Parameter in einer anderen Container-Definition innerhalb derselben Aufgabe verwenden, um alle Volumes von den sourceContainer an ihren ursprünglich definierten Einhängepunkten aus zu mounten. 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 dem vorherigen Dockerfile erstellt.
Erstellen Sie eine Aufgabendefinition, die Ihre Volumes und Mountingpunkte 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

Geben Sie einen Bind-Mount in einer Aufgabendefinition an

Verwaltung des Container-Swap-Speicherplatzes