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.
# Migration von Multi-Container-Docker auf Amazon Linux zu Elastic Beanstalk Docker auf Amazon Linux 2
Vor der Veröffentlichung des Plattformzweigs *ECS auf Amazon Linux 2 mit 64 Bit* bot Elastic Beanstalk einen alternativen Migrationspfad zu Amazon Linux 2 für Kunden mit Umgebungen an, die auf dem Plattformzweig *Multi-Container-Docker auf Amazon Linux mit 64 Bit* basierten. Dieses Thema beschreibt diesen Migrationspfad und bleibt in diesem Dokument als Referenz für alle Kunden, die diesen Migrationspfad abgeschlossen haben.
Wir empfehlen jetzt Kunden mit Umgebungen, die auf dem Plattformzweig *Multi-Container-Docker auf Amazon Linux mit 64 Bit* basieren, zum Plattformzweig *ECS auf Amazon Linux 2 mit 64 Bit* zu migrieren. Im Gegensatz zum alternativen Migrationspfad verwendet dieser Ansatz weiterhin Amazon ECS, um Container-Bereitstellungen in ECS-verwalteten Docker-Umgebungen zu koordinieren. Dieser Aspekt erlaubt einen einfacheren Ansatz. Es sind keine Änderungen am Quellcode erforderlich und dasselbe `Dockerrun.aws.json` v2 wird unterstützt. Weitere Informationen finden Sie unter [Migrieren Sie Ihre Elastic Beanstalk Beanstalk-Anwendung von ECS-verwaltetem Multi-Container-Docker auf ECS AL1 auf Amazon Linux 2023](migrate-to-ec2-AL2-platform.md).
## Legacy-Migration von Multi-Container-Docker auf Amazon Linux zum Docker-Plattformzweig Amazon Linux 2
Sie können Ihre Anwendungen, die auf der [Multicontainer-Docker-Plattform unter Amazon Linux AMI ausgeführt werden](create_deploy_docker_ecs.md), zur Amazon Linux 2 Docker-Plattform migrieren. Bei der Multicontainer-Docker-Plattform unter Amazon Linux AMI müssen vordefinierte Anwendungsimages für die Ausführung als Container angegeben werden. Nach der Migration besteht diese Einschränkung nicht mehr, da die Amazon Linux 2 Docker-Plattform die Erstellung Ihrer Container-Images mit Elastic Beanstalk auch während der Bereitstellung ermöglicht. Ihre Anwendungen werden weiterhin in Umgebungen mit mehreren Containern ausgeführt – mit den zusätzlichen Vorteilen des Docker Compose-Tools.
Docker Compose ist ein Tool zum Definieren und Ausführen von Multi-Container-Docker-Anwendungen. Weitere Informationen zu Docker Compose und zur Installation von Docker Compose finden Sie auf den Docker-Websites [Overview of Docker Compose](https://docs.docker.com/compose/) und [Install Docker Compose](https://docs.docker.com/compose/install/).
### Die Datei `docker-compose.yml`
Das Docker Compose-Tool verwendet die `docker-compose.yml`-Datei für die Konfiguration Ihrer Anwendungsservices. Diese Datei ersetzt die `Dockerrun.aws.json v2`-Datei in Ihrem Anwendungsprojektverzeichnis und Anwendungsquellpaket. Die `docker-compose.yml`-Datei muss zwar manuell erstellt werden, die meisten der Parameterwerte können Sie jedoch Ihrer `Dockerrun.aws.json v2`-Datei entnehmen.
Im Anschluss finden Sie ein Beispiel für eine `docker-compose.yml`-Datei und die entsprechende `Dockerrun.aws.json v2`-Datei für die gleiche Anwendung. Weitere Informationen zur `docker-compose.yml`-Datei finden Sie in der [Referenz zu Compose-Dateien](https://docs.docker.com/compose/compose-file/). Weitere Informationen zur `Dockerrun.aws.json v2`-Datei finden Sie unter [`Dockerrun.aws.json` v2](create_deploy_docker_v2config.md#create_deploy_docker_v2config_dockerrun).
| **`docker-compose.yml`** | **`Dockerrun.aws.json v2`** |
| --- | --- |
| [See the AWS documentation website for more details](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/docker-multicontainer-migration.html) | [See the AWS documentation website for more details](http://docs.aws.amazon.com/de_de/elasticbeanstalk/latest/dg/docker-multicontainer-migration.html) |
| version: '2.4'
services:
php-app:
image: "php:fpm"
volumes:
- "./php-app:/var/www/html:ro"
- "${EB_LOG_BASE_DIR}/php-app:/var/log/sample-app"
mem_limit: 128m
environment:
Container: PHP
nginx-proxy:
image: "nginx"
ports:
- "80:80"
volumes:
- "./php-app:/var/www/html:ro"
- "./proxy/conf.d:/etc/nginx/conf.d:ro"
- "${EB_LOG_BASE_DIR}/nginx-proxy:/var/log/nginx"
mem_limit: 128m
links:
- php-app
|
| {
"AWSEBDockerrunVersion": 2,
"volumes": [
{
"name": "php-app",
"host": {
"sourcePath": "/var/app/current/php-app"
}
},
{
"name": "nginx-proxy-conf",
"host": {
"sourcePath": "/var/app/current/proxy/conf.d"
}
}
],
"containerDefinitions": [
{
"name": "php-app",
"image": "php:fpm",
"environment": [
{
"name": "Container",
"value": "PHP"
}
],
"essential": true,
"memory": 128,
"mountPoints": [
{
"sourceVolume": "php-app",
"containerPath": "/var/www/html",
"readOnly": true
}
]
},
{
"name": "nginx-proxy",
"image": "nginx",
"essential": true,
"memory": 128,
"portMappings": [
{
"hostPort": 80,
"containerPort": 80
}
],
"links": [
"php-app"
],
"mountPoints": [
{
"sourceVolume": "php-app",
"containerPath": "/var/www/html",
"readOnly": true
},
{
"sourceVolume": "nginx-proxy-conf",
"containerPath": "/etc/nginx/conf.d",
"readOnly": true
},
{
"sourceVolume": "awseb-logs-nginx-proxy",
"containerPath": "/var/log/nginx"
}
]
}
]
}
|
### Weitere Überlegungen zur Migration
Die Docker-Amazon-Linux-2-Plattform und die Multi-Container-Docker-Amazon-Linux-AMI-Plattform implementieren Umgebungseigenschaften unterschiedlich. Diese beiden Plattformen haben auch unterschiedliche Protokollverzeichnisse, die Elastic Beanstalk für jeden ihrer Container erstellt. Nachdem Sie von der Amazon-Linux-AMI-Multi-Container-Docker-Plattform migriert haben, müssen Sie sich dieser verschiedenen Implementierungen für Ihre neue Amazon-Linux-2-Docker-Plattformumgebung bewusst sein.
| **Area** | **Docker-Plattform auf Amazon Linux 2 mit Docker Compose** | **Multi-Container-Docker-Plattform unter Amazon Linux AMI** |
| --- | --- | --- |
| Umgebungseigenschaften | Damit Ihre Container auf Umgebungseigenschaften zugreifen können, müssen Sie einen Verweis auf die `.env`-Datei in der `docker-compose.yml`-Datei hinzufügen. Elastic Beanstalk generiert die `.env`-Datei und listet jede der Eigenschaften als Umgebungsvariable auf. Weitere Informationen finden Sie unter [Verweisen auf Umgebungsvariablen in Containern](create_deploy_docker.container.console.md#docker-env-cfg.env-variables). | Elastic Beanstalk kann Umgebungseigenschaften direkt an den Container übergeben. Der im Container ausgeführte Code kann auf diese Eigenschaften ohne zusätzliche Konfiguration in Form von Umgebungsvariablen zugreifen. |
| Protokollverzeichnisse | Für jeden Container erstellt Elastic Beanstalk ein Protokollverzeichnis namens `/var/log/eb-docker/containers/{{}}` (oder `${EB_LOG_BASE_DIR}/`). Weitere Informationen finden Sie unter [Benutzerdefinierte Protokollierung für Docker-Container mit Docker Compose](create_deploy_docker.container.console.md#docker-env-cfg.dc-customized-logging). | Für jeden Container erstellt Elastic Beanstalk ein Protokollverzeichnis namens `/var/log/containers/{{}}`. Weitere Informationen finden Sie im Feld `mountPoints` unter [Format der Containerdefinition](create_deploy_docker_v2config.md#create_deploy_docker_v2config_dockerrun_format). |
### Migrationsschritte
**So migrieren Sie zur Amazon Linux 2 Docker-Plattform**
1. Erstellen Sie auf der Grundlage der vorhandenen `docker-compose.yml `-Datei die `Dockerrun.aws.json v2`-Datei für Ihre Anwendung. Weitere Informationen finden Sie weiter oben im Abschnitt [Die Datei `docker-compose.yml`](#docker-multicontainer-migration.files).
1. Ersetzen Sie im Stammverzeichnis Ihres Anwendungsprojektordners die `Dockerrun.aws.json v2`-Datei durch die soeben erstellte `docker-compose.yml`-Datei.
Ihre Verzeichnisstruktur sollte wie folgt aussehen.
```
~/myApplication
|-- docker-compose.yml
|-- .ebextensions
|-- php-app
|-- proxy
```
1. Verwenden Sie den Befehl **eb init**, um Ihr lokales Verzeichnis für die Bereitstellung in Elastic Beanstalk zu konfigurieren.
```
~/myApplication$ eb init -p docker {{application-name}}
```
1. Verwenden Sie den Befehl **eb create**, um eine Umgebung zu erstellen und Ihr Docker-Image bereitzustellen.
```
~/myApplication$ eb create {{environment-name}}
```
1. Wenn es sich bei Ihrer App um eine Webanwendung handelt, verwenden Sie nach dem Start der Umgebung den Befehl **eb open**, um sie in einem Webbrowser anzuzeigen.
```
~/myApplication$ eb open {{environment-name}}
```
1. Den Status Ihrer neu erstellten Umgebung können Sie mithilfe des Befehls **eb status** anzeigen.
```
~/myApplication$ eb status {{environment-name}}
```