Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Création d'un environnement Docker géré par ECS avec la console Elastic Beanstalk
Ce didacticiel détaille la configuration des conteneurs et la préparation du code source pour un environnement Docker géré par ECS qui utilise deux conteneurs.
Les conteneurs, une application PHP et un proxy nginx, s'exécutent côte à côte sur chacune des instances Amazon Elastic Compute Cloud ( EC2Amazon) dans un environnement Elastic Beanstalk. Après avoir créé l'environnement et vérifié que les applications sont en cours d'exécution, vous allez vous connecter à une instance de conteneur pour voir comment tout fonctionne ensemble.
**Topics**
+ [Définir les conteneurs Docker gérés par ECS](#create_deploy_docker_ecstutorial_config)
+ [Ajout de contenu](#create_deploy_docker_ecstutorial_code)
+ [Déploiement sur Elastic Beanstalk](#create_deploy_docker_ecstutorial_deploy)
+ [Connexion à une instance de conteneur](#create_deploy_docker_ecstutorial_connect)
+ [Mise à jour de l'agent du conteneur Amazon ECS](#create_deploy_docker_ecstutorial_connect_inspect)
## Définir les conteneurs Docker gérés par ECS
La première étape de la création d'un environnement Docker consiste à créer un répertoire pour vos données d'application. Ce dossier peut être situé n'importe où sur votre ordinateur local et porter le nom de votre choix. En plus d'un fichier de configuration de conteneur, ce dossier inclut le contenu que vous téléchargez sur Elastic Beanstalk et que vous déployez dans votre environnement.
**Note**
L'ensemble du code de ce didacticiel est disponible dans le référentiel awslabs à l' GitHub adresse. [https://github.com/awslabs/eb-docker-nginx-proxy](https://github.com/awslabs/eb-docker-nginx-proxy)
Le fichier utilisé par Elastic Beanstalk pour configurer les conteneurs sur une instance EC2 Amazon est un fichier texte au format JSON nommé v2. `Dockerrun.aws.json` Les versions de la plateforme Docker gérée par ECS utilisent le format version 2 de ce fichier. Ce format ne peut être utilisé qu'avec la plate-forme Docker gérée par ECS, car il diffère considérablement des autres versions de fichiers de configuration qui prennent en charge les branches de la plate-forme Docker qui ne sont pas gérées par ECS.
Créez un fichier texte `Dockerrun.aws.json` v2 portant ce nom à la racine de votre application et ajoutez le texte suivant :
```
{
"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",
"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"
}
]
}
]
}
```
Cet exemple de configuration définit deux conteneurs, un site web PHP avec un proxy nginx devant. Ces deux conteneurs s'exécutent côte à côte dans des conteneurs Docker sur chaque instance dans votre environnement Elastic Beanstalk, accédant à du contenu partagé (le contenu du site web) à partir de volumes sur l'instance hôte, qui sont aussi définis dans ce fichier. Les conteneurs eux-mêmes sont créés à partir d'images hébergées dans des référentiels officiels sur Docker Hub. Vous obtenez alors un environnement similaire au suivant :
![\[Elastic Beanstalk environment with load balancer, auto scaling group, and two instances running Nginx and PHP-FPM.\]](http://docs.aws.amazon.com/fr_fr/elasticbeanstalk/latest/dg/images/aeb-multicontainer-tutorial.png)
Les volumes définis dans la configuration correspondent au contenu que vous allez créer ensuite et télécharger dans le cadre du groupe source de votre application. Les conteneurs accèdent au contenu sur l'hôte en montant des volumes dans la section `mountPoints` des définitions de conteneur.
Pour plus d'informations sur le format de la `Dockerrun.aws.json` v2 et ses paramètres, consultez[Format des définitions de conteneur](create_deploy_docker_v2config.md#create_deploy_docker_v2config_dockerrun_format).
## Ajout de contenu
Ensuite, vous allez ajouter du contenu à votre site PHP pour l'afficher aux visiteurs, et un fichier de configuration pour le proxy nginx.
**php-app/index.php**
```
Hello World!!!
PHP Version
```
**php-app/static.html**
```
Hello World!
This is a static HTML page.
```
**proxy/conf.d/default.conf**
```
server {
listen 80;
server_name localhost;
root /var/www/html;
index index.php;
location ~ [^/]\.php(/|$) {
fastcgi_split_path_info ^(.+?\.php)(/.*)$;
if (!-f $document_root$fastcgi_script_name) {
return 404;
}
include fastcgi_params;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
fastcgi_param PATH_INFO $fastcgi_path_info;
fastcgi_param PATH_TRANSLATED $document_root$fastcgi_path_info;
fastcgi_pass php-app:9000;
fastcgi_index index.php;
}
}
```
## Déploiement sur Elastic Beanstalk
Votre dossier d'application contient maintenant les fichiers suivants :
```
├── Dockerrun.aws.json
├── php-app
│ ├── index.php
│ └── static.html
└── proxy
└── conf.d
└── default.conf
```
C'est tout ce dont vous avez besoin pour créer l'environnement Elastic Beanstalk. Créez une archive `.zip` des fichiers et dossiers ci-dessus (sans inclure le dossier de projet de niveau supérieur). Pour créer l'archive dans l'Explorateur Windows, sélectionnez le contenu du dossier de projet, effectuez un clic droit, sélectionnez **Envoyer vers**, puis cliquez sur **Dossier compressé**.
**Note**
Pour de plus amples informations sur la structure de fichiers requise et pour obtenir des instructions pour créer des archives dans d'autres environnements, veuillez consulter [Création d'un bundle de sources d'applications Elastic Beanstalk](applications-sourcebundle.md)
Ensuite, téléchargez le bundle de fichiers source sur Elastic Beanstalk et créez votre environnement. Pour **Platform (Plateforme)**, sélectionnez **Docker**. Pour **la branche Platform**, sélectionnez **ECS exécuté sur Amazon Linux 2023 64 bits**.
**Pour lancer un environnement (console)**
1. [Ouvrez la console Elastic Beanstalk à l'aide de ce lien préconfiguré : console.aws.amazon. com/elasticbeanstalk/home\$1/newApplication? Nom de l'application = Tutoriels](https://console.aws.amazon.com/elasticbeanstalk/home#/newApplication?applicationName=tutorials&environmentType=LoadBalanced) et type d'environnement = LoadBalanced
1. Pour **Plateforme**, sélectionnez la plateforme et la branche de plateforme qui correspondent à la langue utilisée par votre application, ou la plateforme Docker pour les applications basées sur des conteneurs.
1. Pour **Application code (Code d'application)**, choisissez **Upload your code (Charger votre code)**.
1. Choisissez **Local file (Fichier local)**, **Choose file (Choisir un fichier)**, puis ouvrez le bundle source.
1. Choisissez **Vérifier et lancer**.
1. Vérifiez les paramètres disponibles et choisissez **Créer une application**.
La console Elastic Beanstalk vous redirige vers le tableau de bord de gestion pour votre nouvel environnement. Cet écran présente l'état de l'environnement et la sortie d'événements par le service Elastic Beanstalk. Quand le statut est vert, cliquez sur l'URL à côté du nom de l'environnement pour voir votre nouveau site web.
## Connexion à une instance de conteneur
Vous allez ensuite vous connecter à une EC2 instance Amazon dans votre environnement Elastic Beanstalk pour voir certains des éléments mobiles en action.
La manière la plus simple de se connecter à une instance dans votre environnement consiste à utiliser l'interface de ligne de commande (CLI) EB. Pour l'utiliser, [installez l'interface de ligne de commande (CLI) EB](eb-cli3.md#eb-cli3-install), si vous ne l'avez pas déjà fait. Vous devrez également configurer votre environnement à l'aide d'une paire de clés Amazon EC2 SSH. Utilisez soit la [page de configuration de la sécurité](using-features.managing.security.md) de la console, soit la commande [eb init](eb3-init.md) de l'interface de ligne de commande (CLI) EB. Pour vous connecter à une instance de l'environnement, utilisez la commande [eb ssh](eb3-ssh.md) de l'interface de ligne de commande (CLI) EB.
Maintenant que vous êtes connecté à une EC2 instance Amazon hébergeant vos conteneurs docker, vous pouvez voir comment les choses sont configurées. Exécutez `ls` sur `/var/app/current` :
```
[ec2-user@ip-10-0-0-117 ~]$ ls /var/app/current
Dockerrun.aws.json php-app proxy
```
Ce répertoire contient les fichiers du groupe source que vous avez téléchargés sur Elastic Beanstalk pendant la création de l'environnement.
```
[ec2-user@ip-10-0-0-117 ~]$ ls /var/log/containers
nginx-proxy nginx-proxy-4ba868dbb7f3-stdouterr.log
php-app php-app-dcc3b3c8522c-stdouterr.log rotated
```
C'est à cet emplacement que les journaux sont créés sur l'instance de conteneur et collectés par Elastic Beanstalk. Elastic Beanstalk crée un volume dans ce répertoire pour chaque conteneur, que vous montez sur l'emplacement du conteneur où les journaux sont écrits.
Vous pouvez également regarder Docker pour voir les conteneurs en cours d'exécution avec `docker ps`.
```
[ec2-user@ip-10-0-0-117 ~]$ sudo docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
4ba868dbb7f3 nginx "/docker-entrypoint.…" 4 minutes ago Up 4 minutes 0.0.0.0:80->80/tcp, :::80->80/tcp ecs-awseb-Tutorials-env-dc2aywfjwg-1-nginx-proxy-acca84ef87c4aca15400
dcc3b3c8522c php:fpm "docker-php-entrypoi…" 4 minutes ago Up 4 minutes 9000/tcp ecs-awseb-Tutorials-env-dc2aywfjwg-1-php-app-b8d38ae288b7b09e8101
d9367c0baad6 amazon/amazon-ecs-agent:latest "/agent" 5 minutes ago Up 5 minutes (healthy) ecs-agent
```
Vous pouvez y voir les deux conteneurs en cours d'exécution que vous avez déployés, ainsi que l'agent de conteneur Amazon ECS qui a coordonné le déploiement.
## Mise à jour de l'agent du conteneur Amazon ECS
EC2 Les instances Amazon d'un environnement Docker géré par ECS sur Elastic Beanstalk exécutent un processus d'agent dans un conteneur Docker. Cet agent se connecte à Amazon ECS service afin de coordonner des déploiements de conteneurs. Ces déploiements sont exécutés comme des tâches dans Amazon ECS, qui sont configurées dans les fichiers de définition de tâche. Elastic Beanstalk crée ces fichiers de définition de tâche en se basant sur le fichier `Dockerrun.aws.json` que vous téléchargez dans un groupe de fichiers source.
Vérifiez le statut de l'agent de conteneur avec une demande get HTTP pour `http://localhost:51678/v1/metadata`:
```
[ec2-user@ip-10-0-0-117 ~]$ curl http://localhost:51678/v1/metadata
{
"Cluster":"awseb-Tutorials-env-dc2aywfjwg",
"ContainerInstanceArn":"arn:aws:ecs:us-west-2:123456789012:container-instance/awseb-Tutorials-env-dc2aywfjwg/db7be5215cd74658aacfcb292a6b944f",
"Version":"Amazon ECS Agent - v1.57.1 (089b7b64)"
}
```
Cette structure indique le nom du cluster Amazon ECS et l'ARN ([Amazon Resource Name](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html)) de l'instance de cluster (l' EC2 instance Amazon à laquelle vous êtes connecté).
Pour plus d'informations, exécutez une requête get HTTP sur `http://localhost:51678/v1/tasks` :
```
[ec2-user@ip-10-0-0-117 ~]$ curl http://localhost:51678/v1/tasks
{
"Tasks":[
{
"Arn":"arn:aws:ecs:us-west-2:123456789012:task/awseb-Tutorials-env-dc2aywfjwg/bbde7ebe1d4e4537ab1336340150a6d6",
"DesiredStatus":"RUNNING",
"KnownStatus":"RUNNING",
"Family":"awseb-Tutorials-env-dc2aywfjwg",
"Version":"1",
"Containers":[
{
"DockerId":"dcc3b3c8522cb9510b7359689163814c0f1453b36b237204a3fd7a0b445d2ea6",
"DockerName":"ecs-awseb-Tutorials-env-dc2aywfjwg-1-php-app-b8d38ae288b7b09e8101",
"Name":"php-app",
"Volumes":[
{
"Source":"/var/app/current/php-app",
"Destination":"/var/www/html"
}
]
},
{
"DockerId":"4ba868dbb7f3fb3328b8afeb2cb6cf03e3cb1cdd5b109e470f767d50b2c3e303",
"DockerName":"ecs-awseb-Tutorials-env-dc2aywfjwg-1-nginx-proxy-acca84ef87c4aca15400",
"Name":"nginx-proxy",
"Ports":[
{
"ContainerPort":80,
"Protocol":"tcp",
"HostPort":80
},
{
"ContainerPort":80,
"Protocol":"tcp",
"HostPort":80
}
],
"Volumes":[
{
"Source":"/var/app/current/php-app",
"Destination":"/var/www/html"
},
{
"Source":"/var/log/containers/nginx-proxy",
"Destination":"/var/log/nginx"
},
{
"Source":"/var/app/current/proxy/conf.d",
"Destination":"/etc/nginx/conf.d"
}
]
}
]
}
]
}
```
Cette structure décrit la tâche qui est exécutée pour déployer les deux conteneurs Docker à partir du projet exemple de ce didacticiel. Les informations suivantes sont affichées :
+ **KnownStatus**— L'`RUNNING`état indique que les conteneurs sont toujours actifs.
+ **Famille** – Nom de la définition de tâche créée par Elastic Beanstalk à partir du fichier `Dockerrun.aws.json`.
+ **Version** – Version de la définition de tâche. Elle est augmentée chaque fois que le fichier de définition de tâche est mis à jour.
+ **Containers** – Informations sur les conteneurs exécutés sur l'instance.
Encore plus d'informations sont disponibles à partir d'Amazon ECS service lui-même, que vous pouvez appeler à l'aide de l AWS Command Line Interface. Pour obtenir des instructions sur l'utilisation AWS CLI avec Amazon ECS et des informations sur Amazon ECS en général, consultez le [guide de l'utilisateur Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ECS_GetStarted.html).