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. # Plateformes traditionnelles Ce chapitre répertorie le contenu lié aux anciennes plateformes Docker qui ne sont plus prises en charge par AWS Elastic Beanstalk. Les sujets répertoriés ici restent dans ce document à titre de référence pour tous les clients qui utilisaient ces fonctionnalités ou composants avant leur départ à la retraite. **Topics** + [ # Migration vers Elastic Beanstalk Docker exécuté sur Amazon Linux 2 depuis un Docker multi-conteneurs exécuté sur Amazon Linux ](docker-multicontainer-migration.md) + [ # GlassFish Conteneurs Docker préconfigurés sur Elastic Beanstalk ](create_deploy_dockerpreconfig.md) # Migration vers Elastic Beanstalk Docker exécuté sur Amazon Linux 2 depuis un Docker multi-conteneurs exécuté sur Amazon Linux Avant la sortie de la branche de plateforme *ECS s'exécutant sur Amazon Linux 2 64 bits*, Elastic Beanstalk a proposé un autre processus de migration vers Amazon Linux 2 pour les clients disposant d'environnements basés sur la branche de plateforme *Docker multiconteneurs s'exécutant sur Amazon Linux 64 bits*. Cette rubrique décrit ce processus de migration et reste dans ce document comme référence pour tous les clients ayant terminé ce processus de migration. Nous recommandons désormais aux clients disposant d'environnements basés sur la branche de plateforme *Docker multiconteneurs s'exécutant sur Amazon Linux 64 bits* de migrer vers la branche de plateforme *ECS s'exécutant sur Amazon Linux 2 64 bits*. Contrairement au processus de migration alternatif, cette approche continue d'utiliser Amazon ECS pour coordonner les déploiements de conteneurs vers des environnements Docker gérés par ECS. Cet aspect permet une approche plus simple. Aucune modification du code source n'est requise, et le même `Dockerrun.aws.json` v2 est pris en charge. Pour de plus amples informations, veuillez consulter [Migration de votre application Elastic Beanstalk depuis AL1 Docker multi-conteneurs géré par ECS vers ECS sur Amazon Linux 2023](migrate-to-ec2-AL2-platform.md). ## Migration héritée de Docker multiconteneurs sur Amazon Linux vers la branche de plateforme Docker Amazon Linux 2 Vous pouvez migrer vos applications qui s'exécutent sur la [plateforme Docker multiconteneurs sur l'AMI Amazon Linux](create_deploy_docker_ecs.md) vers la plateforme Docker Amazon Linux 2. La plateforme Docker multiconteneurs sur l'AMI Amazon Linux nécessite de spécifier des images d'application prédéfinies à exécuter en tant que conteneurs. Après la migration, cette limitation ne s'applique plus, car la plateforme Docker Amazon Linux 2 permet également à Elastic Beanstalk de créer vos images de conteneur pendant le déploiement. Vos applications continueront à s'exécuter dans des environnements multiconteneurs tout en profitant des avantages supplémentaires que procure l'outil Docker Compose. Docker Compose est un outil qui permet de définir et d'exécuter des applications Docker multiconteneurs. Pour en savoir plus sur Docker Compose et savoir comment l'installer, veuillez consulter les sites Docker [Overview of Docker Compose](https://docs.docker.com/compose/) et [Install Docker Compose](https://docs.docker.com/compose/install/). ### le fichier `docker-compose.yml` ; L'outil Docker Compose utilise le fichier `docker-compose.yml` pour la configuration de vos services d'application. Ce fichier remplace votre fichier `Dockerrun.aws.json v2` dans votre répertoire de projet d'application et dans le bundle de fichiers source de l'application. Vous créez le fichier `docker-compose.yml` manuellement et il s'avérera utile de référencer votre fichier `Dockerrun.aws.json v2` pour la plupart des valeurs de paramètre. Voici un exemple de fichier `docker-compose.yml` et le fichier `Dockerrun.aws.json v2` correspondant pour la même application. Pour de plus amples informations sur le fichier `docker-compose.yml`, veuillez consulter [Compose file reference](https://docs.docker.com/compose/compose-file/). Pour de plus amples informations sur le fichier `Dockerrun.aws.json v2`, veuillez consulter [`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/fr_fr/elasticbeanstalk/latest/dg/docker-multicontainer-migration.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/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"
        }
      ]
    }
  ]
}
| ### Considérations supplémentaires sur la migration La plateforme Docker Amazon Linux 2 et la plateforme AMI multiconteneurs Amazon Linux implémentent les propriétés d'environnement différemment. Ces deux plateformes ont également des répertoires de journaux différents créés par Elastic Beanstalk pour chacun de leurs conteneurs. Après avoir effectué la migration à partir de la plateforme Docker multi-conteneur AMI Amazon Linux, vous devez être conscient de ces différentes implémentations pour votre nouvel environnement de plateforme Docker Amazon Linux 2. | **Area** | **Plateforme Docker sur Amazon Linux 2 avec Docker Compose** | **Plateforme Docker multiconteneurs sur l'AMI Amazon Linux** | | --- | --- | --- | | Propriétés de l'environnement | Pour que vos conteneurs puissent accéder aux propriétés de l'environnement, vous devez ajouter une référence au fichier `.env` dans le fichier `docker-compose.yml`. Elastic Beanstalk génère le fichier `.env`, répertoriant chaque propriété en tant que variable d'environnement. Pour plus d'informations, consultez [Référencement de variables d'environnement dans les conteneurs](create_deploy_docker.container.console.md#docker-env-cfg.env-variables). | Elastic Beanstalk peut transmettre directement les propriétés de l'environnement au conteneur. Votre code qui s'exécute dans le conteneur peut accéder à ces propriétés en tant que variables d'environnement sans configuration supplémentaire. | | Répertoires de journaux | Pour chaque conteneur, Elastic Beanstalk crée un répertoire de journal appelé `/var/log/eb-docker/containers/` (ou `${EB_LOG_BASE_DIR}/`). Pour plus d'informations, consultez [Journalisation personnalisée des conteneurs Docker avec Docker Compose](create_deploy_docker.container.console.md#docker-env-cfg.dc-customized-logging). | Pour chaque conteneur, Elastic Beanstalk crée un répertoire de journal appelé `/var/log/containers/`. Pour de plus amples informations, veuillez consulter le champ `mountPoints` dans [Format des définitions de conteneur](create_deploy_docker_v2config.md#create_deploy_docker_v2config_dockerrun_format). | ### Etapes de la migration **Pour migrer vers la plateforme Docker Amazon Linux 2** 1. Créez le fichier `docker-compose.yml ` de votre application, en fonction de son fichier `Dockerrun.aws.json v2` existant. Pour de plus amples informations, veuillez consulter la section ci-dessu [le fichier `docker-compose.yml` ;](#docker-multicontainer-migration.files). 1. Dans le répertoire racine de votre dossier de projet d'application, remplacez le fichier `Dockerrun.aws.json v2` par le fichier `docker-compose.yml` que vous venez de créer. La structure de votre répertoire doit être la suivante. ``` ~/myApplication |-- docker-compose.yml |-- .ebextensions |-- php-app |-- proxy ``` 1. Utilisez la commande **eb init** pour configurer votre répertoire local pour le déploiement vers Elastic Beanstalk. ``` ~/myApplication$ eb init -p docker application-name ``` 1. Utilisez la commande **eb create** pour créer un environnement et déployer votre image Docker. ``` ~/myApplication$ eb create environment-name ``` 1. Si votre application est une application web, après le lancement de votre environnement, utilisez la commande **eb open** pour l'afficher dans un navigateur web. ``` ~/myApplication$ eb open environment-name ``` 1. Vous pouvez afficher l'état de votre environnement nouvellement créé à l'aide de la commande **eb status**. ``` ~/myApplication$ eb status environment-name ``` # GlassFish Conteneurs Docker préconfigurés sur Elastic Beanstalk **Note** [Le 18 juillet 2022,](https://docs.aws.amazon.com/elasticbeanstalk/latest/relnotes/release-2022-07-18-linux-al1-retire.html) **Elastic Beanstalk a défini le statut de toutes les branches de la plateforme sur la base de l'AMI AL1 Amazon Linux () comme étant supprimées.** Pour plus d'informations sur la migration vers une branche de plateforme Amazon Linux 2023 actuelle et entièrement prise en charge, consultez [Migration de votre application Elastic Beanstalk Linux vers Amazon Linux 2023 ou Amazon Linux 2](using-features.migration-al.md). La branche de la GlassFish plateforme Docker préconfigurée qui s'exécute sur l'AMI Amazon Linux (AL1) n'est plus prise en charge. Pour migrer votre GlassFish application vers une plateforme Amazon Linux 2023 prise en charge, déployez GlassFish et votre code d'application sur une image Docker Amazon Linux 2023. Pour de plus amples informations, veuillez consulter la rubrique [Déploiement d'une GlassFish application sur la plateforme Docker : une voie de migration vers Amazon Linux 2023](#docker-glassfish-tutorial). ## Prise en main des conteneurs Docker préconfigurés – sur l'AMI Amazon Linux (antérieure à Amazon Linux 2) Cette section décrit comment développer localement un exemple d'application, puis déployer l'application dans Elastic Beanstalk à l'aide d'un conteneur Docker préconfiguré. ### Configuration de votre environnement de développement local Pour cette présentation, nous utilisons un GlassFish exemple d'application. **Configuration de votre environnement** 1. Créez un dossier pour l'exemple d'application. ``` ~$ mkdir eb-preconf-example ~$ cd eb-preconf-example ``` 1. Téléchargez le code de l'exemple d'application dans le nouveau dossier. ``` ~$ wget https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/samples/docker-glassfish-v1.zip ~$ unzip docker-glassfish-v1.zip ~$ rm docker-glassfish-v1.zip ``` ### Développement et test en local **Pour développer un exemple d' GlassFish application** 1. Ajoutez un `Dockerfile` au dossier racine de votre application. Dans le fichier, spécifiez l'image de base AWS Elastic Beanstalk Docker à utiliser pour exécuter votre conteneur Docker préconfiguré local. Vous déploierez ensuite votre application sur une version de plateforme Docker préconfigurée Elastic GlassFish Beanstalk. Choisissez l'image de base Docker que cette version de plateforme utilise. Pour déterminer l'image Docker actuelle de la version de plateforme, consultez la section [Docker préconfiguré](https://docs.aws.amazon.com/elasticbeanstalk/latest/platforms/platforms-supported.html#platforms-supported.dockerpreconfig) de la page *Plateformes AWS Elastic Beanstalk prises en charge* dans le guide *Plateformes AWS Elastic Beanstalk *. **Example \$1/E/Dockerfile b-preconf-example** ``` # For Glassfish 5.0 Java 8 FROM amazon/aws-eb-glassfish:5.0-al-onbuild-2.11.1 ``` Pour plus d'informations sur l'utilisation d'un `Dockerfile`, consultez [Préparation de votre image Docker pour le déploiement sur Elastic Beanstalk](single-container-docker-configuration.md). 1. Développez l'image Docker. ``` ~/eb-preconf-example$ docker build -t my-app-image . ``` 1. Exécutez le conteneur Docker à partir de l'image. **Note** Vous devez inclure l'indicateur `-p` pour mapper le port 8080 sur le conteneur au port localhost 3000. Les conteneurs Docker Elastic Beanstalk exposent toujours l'application sur le port 8080 sur le conteneur. Les indicateurs `-it` exécutent l'image comme un processus interactif. L'indicateur `--rm` supprime le système de fichiers conteneur lorsque le conteneur s'arrête. Vous pouvez inclure le cas échéant l'indicateur `-d` pour exécuter l'image comme un démon. ``` $ docker run -it --rm -p 3000:8080 my-app-image ``` 1. Pour voir l'exemple d'application, tapez l'URL suivante dans votre navigateur web. ``` http://localhost:3000 ``` ![\[GlassFish Exemple d'application affiché dans un navigateur Web\]](http://docs.aws.amazon.com/fr_fr/elasticbeanstalk/latest/dg/images/dockerpreconfig-webpage.png) ### Déploiement sur Elastic Beanstalk Après avoir testé votre application, vous êtes prêt à la déployer dans Elastic Beanstalk. **Pour déployer votre application sur Elastic Beanstalk** 1. Dans le dossier racine de votre application, renommez le `Dockerfile` `Dockerfile.local`. Cette étape est obligatoire pour qu'Elastic Beanstalk utilise le fichier `Dockerfile` qui contient les instructions correctes pour permettre à Elastic Beanstalk de développer une image Docker personnalisée sur chaque instance Amazon EC2 dans votre environnement Elastic Beanstalk. **Note** Vous n'avez pas besoin d'effectuer cette étape si votre `Dockerfile` inclut des instructions qui modifient l'image Docker de base de la version de plateforme. Vous n'avez pas besoin d'utiliser un `Dockerfile` si votre `Dockerfile` contient seulement une ligne `FROM` pour spécifier l'image de base à partir de laquelle développer le conteneur. Dans ce cas, le `Dockerfile` est redondant. 1. Créez un groupe source d'application. ``` ~/eb-preconf-example$ zip myapp.zip -r * ``` 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**, sous **Preconfigured – Docker (Préconfiguré – Docker)**, choisissez **Glassfish**. 1. Pour **Code de l'application**, choisissez **Charger votre code** puis **Charger**. 1. Choisissez **Fichier local**, **Browse**, puis ouvrez le groupe source d'application que vous venez de créer. 1. Choisissez **Upload**. 1. Choisissez **Vérifier et lancer**. 1. Vérifiez les paramètres disponibles et choisissez **Créer une application**. 1. Lorsque l'environnement est créé, vous pouvez afficher l'application déployée. Choisissez l'URL de l'environnement qui s'affiche en haut du tableau de bord de la console. ## Déploiement d'une GlassFish application sur la plateforme Docker : une voie de migration vers Amazon Linux 2023 L'objectif de ce didacticiel est de fournir aux clients utilisant la GlassFish plateforme Docker préconfigurée (basée sur l'AMI Amazon Linux) un chemin de migration vers Amazon Linux 2023. Vous pouvez migrer votre GlassFish application vers Amazon Linux 2023 en GlassFish déployant le code de votre application sur une image Docker Amazon Linux 2023. Ce didacticiel explique comment utiliser la plateforme AWS Elastic Beanstalk Docker pour déployer une application basée sur le [serveur d'applications Java EE dans un GlassFish environnement](https://www.oracle.com/middleware/technologies/glassfish-server.html) Elastic Beanstalk. Nous illustrons deux approches de création d'une image Docker : + **Simple** : fournissez le code source de votre GlassFish application et laissez Elastic Beanstalk créer et exécuter une image Docker dans le cadre du provisionnement de votre environnement. Ceci est facile à configurer, au prix d'une augmentation du temps de mise en service des instances. + **Avancé** – Créez une image Docker personnalisée contenant votre code d'application et vos dépendances, et fournissez-la à Elastic Beanstalk afin de l'utiliser dans votre environnement. Cette approche est légèrement plus impliquée et réduit le temps de mise en service des instances dans votre environnement. ### Conditions préalables Ce tutoriel suppose que vous ayez quelques connaissances des opérations Elastic Beanstalk de base, de l'interface de ligne de commande Elastic Beanstalk (EB CLI) et de Docker. Si ce n'est pas déjà fait, suivez les instructions dans [Découvrez comment démarrer avec Elastic Beanstalk](GettingStarted.md) pour lancer votre premier environnement Elastic Beanstalk. Ce tutoriel utilise [l'interface de ligne de commande (CLI) EB](eb-cli3.md), mais vous pouvez également créer des environnements et télécharger des applications à l'aide de la console Elastic Beanstalk. Pour suivre ce tutoriel, vous aurez également besoin des composants Docker suivants : + Une installation locale en état de fonctionnement de Docker. Pour de plus amples informations, veuillez consulter [Get Docker](https://docs.docker.com/install/) (Obtenir Docker) sur le site web de documentation de Docker. + Accès à Docker Hub. Vous devez créer un ID Docker pour accéder au Docker Hub. Pour de plus amples informations, veuillez consulter [Share the application](https://docs.docker.com/get-started/04_sharing_app/) (Partager l'application) sur le site Web de documentation de Docker. Pour en savoir plus sur la configuration des environnements Docker sur des plateformes Elastic Beanstalk, consultez [Préparation de votre image Docker pour le déploiement sur Elastic Beanstalk](single-container-docker-configuration.md) dans ce même chapitre. ### Exemple simple : fournissez votre code d'application Il s'agit d'un moyen simple de déployer votre GlassFish application. Vous fournissez au code source de votre application le fichier `Dockerfile` inclus dans ce tutoriel. Elastic Beanstalk crée une image Docker qui inclut votre application et la pile logicielle. GlassFish Ensuite, Elastic Beanstalk exécute l'image sur les instances de votre environnement. Cette approche présente un problème, à savoir qu'Elastic Beanstalk crée l'image Docker localement chaque fois qu'il crée une instance pour votre environnement. La génération de l'image augmente le temps de mise en service de l'instance. Cet impact n'est pas limité à la création initiale de l'environnement. Il se produit également lors des actions de montée en charge. **Pour lancer un environnement avec un exemple d' GlassFish application** 1. Téléchargez l'exemple `docker-glassfish-al2-v1.zip`, puis développez le fichier `.zip` dans un répertoire de votre environnement de développement. ``` ~$ curl https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/samples/docker-glassfish-al2-v1.zip --output docker-glassfish-al2-v1.zip ~$ mkdir glassfish-example ~$ cd glassfish-example ~/glassfish-example$ unzip ../docker-glassfish-al2-v1.zip ``` La structure de votre répertoire doit être la suivante. ``` ~/glassfish-example |-- Dockerfile |-- Dockerrun.aws.json |-- glassfish-start.sh |-- index.jsp |-- META-INF | |-- LICENSE.txt | |-- MANIFEST.MF | `-- NOTICE.txt |-- robots.txt `-- WEB-INF `-- web.xml ``` Les fichiers suivants sont essentiels à la création et à l'exécution d'un conteneur Docker dans votre environnement : + `Dockerfile` – Fournit des instructions que Docker utilise pour créer une image avec votre application et les dépendances requises. + `glassfish-start.sh` – Script shell exécuté par l'image Docker pour démarrer votre application. + `Dockerrun.aws.json`— Fournit une clé de journalisation pour inclure le journal du serveur GlassFish d'applications dans les [requêtes du fichier journal](using-features.logging.md). Si les GlassFish journaux ne vous intéressent pas, vous pouvez omettre ce fichier. 1. Configurez votre répertoire local pour le déploiement sur Elastic Beanstalk. ``` ~/glassfish-example$ eb init -p docker glassfish-example ``` 1. (Facultatif) Utilisez la commande **eb local run** pour créer et exécuter votre conteneur en local. ``` ~/glassfish-example$ eb local run --port 8080 ``` **Note** Pour en savoir plus sur la commande **eb local**, consultez [**eb local**](eb3-local.md). La commande n'est pas prise en charge sur Windows. Vous pouvez également créer et exécuter votre conteneur avec les commandes **docker build** et **docker run**. Pour plus d'informations, consultez la [documentation Docker](https://docs.docker.com/). 1. (Facultatif) Lorsque votre conteneur est en cours d'exécution, utilisez la commande **eb local open** pour afficher votre application dans un navigateur web. Vous pouvez également ouvrir [http://localhost:8080/](http://localhost:8080/) dans un navigateur web. ``` ~/glassfish-example$ eb local open ``` 1. Utilisez la commande **eb create** pour créer un environnement et déployer votre application. ``` ~/glassfish-example$ eb create glassfish-example-env ``` 1. Après le lancement de votre environnement, utilisez la commande **eb open** pour l'afficher dans un navigateur web. ``` ~/glassfish-example$ eb open ``` Lorsque vous avez terminé l'exemple, arrêtez l'environnement et supprimez les ressources associées. ``` ~/glassfish-example$ eb terminate --all ``` ### Exemple avancé : fournir une image Docker préconstruite Il s'agit d'une méthode plus avancée pour déployer votre GlassFish application. Sur la base du premier exemple, vous créez une image Docker contenant le code de votre application et la pile GlassFish logicielle, puis vous la transférez vers Docker Hub. Après avoir effectué cette étape unique, vous pouvez lancer des environnements Elastic Beanstalk basés sur votre image personnalisée. Lorsque vous lancez un environnement et que vous fournissez votre image Docker, les instances de votre environnement téléchargent et utilisent cette image directement et n'ont pas besoin de créer une image Docker. Par conséquent, le temps de mise en service de l'instance est réduit. **Remarques** Les étapes suivantes créent une image Docker disponible publiquement. Vous utiliserez les commandes Docker de votre installation Docker locale, ainsi que vos informations d'identification Docker Hub. Pour plus d'informations, consultez la section *Prérequis* précédente de cette rubrique. **Pour lancer un environnement avec une image Docker d' GlassFish application prédéfinie** 1. Téléchargez et développez l'exemple `docker-glassfish-al2-v1.zip` comme dans l'[exemple simple](#docker-glassfish-tutorial.simple) précédent. Si vous avez terminé cet exemple, vous pouvez utiliser le répertoire que vous possédez déjà. 1. Créez une image Docker et poussez-la vers Docker Hub. Entrez votre identifiant Docker pour vous *docker-id* connecter à Docker Hub. ``` ~/glassfish-example$ docker build -t docker-id/beanstalk-glassfish-example:latest . ~/glassfish-example$ docker push docker-id/beanstalk-glassfish-example:latest ``` **Note** Avant de transmettre votre image, il se peut que vous deviez exécuter **docker login**. Vous serez invité à saisir vos informations d'identification Docker Hub si vous exécutez la commande sans paramètres. 1. Créez un répertoire supplémentaire. ``` ~$ mkdir glassfish-prebuilt ~$ cd glassfish-prebuilt ``` 1. Copiez l'exemple suivant dans un fichier nommé `Dockerrun.aws.json`. **Example `~/glassfish-prebuilt/Dockerrun.aws.json`** ``` { "AWSEBDockerrunVersion": "1", "Image": { "Name": "docker-username/beanstalk-glassfish-example" }, "Ports": [ { "ContainerPort": 8080, "HostPort": 8080 } ], "Logging": "/usr/local/glassfish5/glassfish/domains/domain1/logs" } ``` 1. Configurez votre répertoire local pour le déploiement sur Elastic Beanstalk. ``` ~/glassfish-prebuilt$ eb init -p docker glassfish-prebuilt$ ``` 1. (Facultatif) Utilisez la commande **eb local run** pour exécuter votre conteneur localement. ``` ~/glassfish-prebuilt$ eb local run --port 8080 ``` 1. (Facultatif) Lorsque votre conteneur est en cours d'exécution, utilisez la commande **eb local open** pour afficher votre application dans un navigateur web. Vous pouvez également ouvrir [http://localhost:8080/](http://localhost:8080/) dans un navigateur web. ``` ~/glassfish-prebuilt$ eb local open ``` 1. Utilisez la commande **eb create** pour créer un environnement et déployer votre image Docker. ``` ~/glassfish-prebuilt$ eb create glassfish-prebuilt-env ``` 1. Après le lancement de votre environnement, utilisez la commande **eb open** pour l'afficher dans un navigateur web. ``` ~/glassfish-prebuilt$ eb open ``` Lorsque vous avez terminé l'exemple, arrêtez l'environnement et supprimez les ressources associées. ``` ~/glassfish-prebuilt$ eb terminate --all ```