Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Creazione di un ambiente Docker ECS gestito con la console Elastic Beanstalk

Questo tutorial descrive in dettaglio la configurazione del contenitore e la preparazione del codice sorgente per un ambiente Docker ECS gestito che utilizza due contenitori.

I contenitori, un'PHPapplicazione e un proxy nginx, vengono eseguiti fianco a fianco su ciascuna istanza di Amazon Elastic Compute Cloud (EC2Amazon) in un ambiente Elastic Beanstalk. Dopo aver creato l'ambiente e aver verificato che le applicazioni sono in esecuzione, puoi connetterti a un'istanza di container per vedere come interagiscono.

Definisci ECS contenitori Docker gestiti

La prima fase per la creazione di un nuovo ambiente Docker consiste nel creare una directory per i dati dell'applicazione. Questa cartella può essere posizionata ovunque nel computer locale e avere qualsiasi nome a scelta. Oltre a un file di configurazione del container, la cartella includerà il contenuto che caricherai in Elastic Beanstalk e distribuirai nell'ambiente in uso.

Il file utilizzato da Elastic Beanstalk per configurare i contenitori su un'istanza EC2 Amazon JSON è un file di testo in formato denominato v2. Dockerrun.aws.json Le versioni ECS gestite della piattaforma Docker utilizzano il formato versione 2 di questo file. Questo formato può essere utilizzato solo con la piattaforma Docker ECS gestita, in quanto differisce notevolmente dalle altre versioni dei file di configurazione che supportano i rami della piattaforma Docker che non sono gestiti da. ECS

Crea un file di testo Dockerrun.aws.json v2 con questo nome nella radice dell'applicazione e aggiungi il testo seguente:

{
  "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"
        }
      ]
    }
  ]
}

Questa configurazione di esempio definisce due contenitori, un sito PHP Web con un proxy nginx davanti. Questi due container verranno eseguiti affiancati nei container Docker su ogni istanza nell'ambiente Elastic Beanstalk, con accesso al contenuto condiviso (il contenuto del sito Web) dai volumi sull'istanza host, anch'essi definiti in questo file. I container stessi vengono creati da immagini ospitate in repository ufficiali su Docker Hub. L'ambiente risultante avrà il seguente aspetto:

I volumi definiti nella configurazione corrispondono al contenuto che creerai successivamente e caricherai come parte del tuo bundle di origine dell'applicazione. I container accedono al contenuto sull'host montando i volumi nella sezione mountPoints delle definizioni del container.

Per ulteriori informazioni sul formato di Dockerrun.aws.json v2 e sui relativi parametri, vedere. Formato della definizione del container

Aggiunta di contenuto

Successivamente aggiungerai alcuni contenuti per il tuo PHP sito da mostrare ai visitatori e un file di configurazione per il proxy nginx.

php-app/index.php

<h1>Hello World!!!</h1>
<h3>PHP Version <pre><?= phpversion()?></pre></h3>

php-app/static.html

<h1>Hello World!</h1>
<h3>This is a static HTML page.</h3>

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;
  }
}

Distribuzione in Elastic Beanstalk

La cartella dell'applicazione ora contiene i file seguenti:

├── Dockerrun.aws.json
├── php-app
│   ├── index.php
│   └── static.html
└── proxy
    └── conf.d
        └── default.conf

Questo è tutto ciò di cui hai bisogno per creare l'ambiente Elastic Beanstalk. Crea un archivio .zip dei file e delle cartelle sopra indicati (senza includere la cartella di progetto di primo livello). Per creare l'archivio in Esplora risorse, seleziona il contenuto della cartella di progetto, fai clic con il pulsante destro del mouse, scegli Send to (Invia a), quindi fai clic su Compressed (zipped) Folder (Cartella compressa (zip).

Carica quindi il bundle di origine in Elastic Beanstalk e crea un ambiente. Per Platform (Piattaforma), selezionare Docker. Per Platform branch, seleziona ECSin esecuzione su Amazon Linux 2023 a 64 bit.

La console Elastic Beanstalk ti reindirizza al pannello di controllo di gestione per il nuovo ambiente. In questa schermata viene mostrato lo stato dell'ambiente e gli eventi generati dal servizio Elastic Beanstalk. Quando lo stato è Verde, fai clic sul pulsante URL accanto al nome dell'ambiente per visualizzare il nuovo sito Web.

Connessione a un'istanza di container

Successivamente ti connetterai a un'EC2istanza Amazon nel tuo ambiente Elastic Beanstalk per vedere alcune parti mobili in azione.

Il modo più semplice per connettersi a un'istanza nel tuo ambiente è utilizzare l'EB. CLI Per usarlo, installa l'EB CLI, se non l'hai già fatto. Dovrai anche configurare il tuo ambiente con una coppia di EC2 SSH chiavi Amazon. A tale scopo, utilizza la pagina di configurazione della sicurezza della console o il comando CLI EB eb init. Per connetterti a un'istanza di ambiente, usa il comando EB CLI eb ssh.

Ora che sei connesso a un'EC2istanza Amazon che ospita i tuoi container docker, puoi vedere come sono configurate le cose. Esegui ls su /var/app/current:

[ec2-user@ip-10-0-0-117 ~]$ ls /var/app/current
Dockerrun.aws.json  php-app  proxy

Questa directory contiene i file dal bundle di origine caricato in Elastic Beanstalk durante la creazione dell'ambiente.

[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

Questo è il punto in cui vengono creati i log sull'istanza di container e raccolte da Elastic Beanstalk. Elastic Beanstalk crea un volume in questa directory per ogni container, che monti nella posizione del container in cui vengono scritti i log.

È anche possibile esaminare il Docker per vedere i container in esecuzione con 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

Questo mostra i due container in esecuzione che hai distribuito, oltre all'agente Amazon ECS Container che ha coordinato la distribuzione.

Ispeziona l'agente Amazon ECS Container

EC2Le istanze Amazon in un ambiente Docker ECS gestito su Elastic Beanstalk eseguono un processo agente in un contenitore Docker. Questo agente si connette al ECS servizio Amazon per coordinare le distribuzioni dei container. Queste distribuzioni vengono eseguite come attività in AmazonECS, configurate nei file di definizione delle attività. Elastic Beanstalk crea questi file in base al file Dockerrun.aws.json caricato in un bundle di origine.

Controlla lo stato dell'agente del contenitore con una richiesta HTTP get a: 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)"
}

Questa struttura mostra il nome del ECS cluster Amazon e il ARN (Amazon Resource Name) dell'istanza del cluster (l'EC2istanza Amazon a cui sei connesso).

Per ulteriori informazioni, invia una richiesta HTTP get ahttp://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"
                  }
               ]
            }
         ]
      }
   ]
}

Questa struttura descrive l'attività che viene eseguita per distribuire i due container Docker dal progetto di esempio di questo tutorial. Sono visualizzate le seguenti informazioni:

Ulteriori informazioni sono disponibili presso il ECS servizio Amazon stesso, che puoi chiamare utilizzando il AWS Command Line Interface. Per istruzioni sull'utilizzo AWS CLI con Amazon ECS e informazioni generali su AmazonECS, consulta la Amazon ECS User Guide.