As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Criação de um ambiente Docker gerenciado pelo ECS com o console do Elastic Beanstalk

Este tutorial detalha a configuração do contêiner e a preparação do código-fonte para um ambiente Docker gerenciado pelo ECS que usa dois contêineres.

Os contêineres, uma aplicação PHP e um proxy nginx, são executados lado a lado em cada uma das instâncias do Amazon Elastic Compute Cloud (Amazon EC2) em um ambiente do Elastic Beanstalk. Depois de criar o ambiente e verificar se os aplicativos estão funcionando, conecte-se a uma instância de contêiner para ver como tudo isso se encaixa.

Definir contêineres do Docker gerenciado pelo ECS

O primeiro passo na criação de um novo ambiente do Docker é criar um diretório para os dados do aplicativo. Essa pasta pode estar localizada em qualquer lugar da sua máquina local e ter qualquer nome que você escolher. Além de um arquivo de configuração de contêiner, essa pasta terá o conteúdo do qual o upload será feito para o Elastic Beanstalk e implantado no ambiente.

O arquivo que o Elastic Beanstalk usa para configurar os contêineres em uma instância do Amazon EC2 é um arquivo de texto formatado em JSON chamado Dockerrun.aws.json v2. As versões da plataforma Docker gerenciada pelo ECS usam um formato de versão 2 desse arquivo. Esse formato apenas pode ser usado com a plataforma Docker gerenciada pelo ECS, pois difere significativamente das outras versões de arquivo de configuração compatíveis com as ramificações da plataforma Docker que não são gerenciadas pelo ECS.

Crie um arquivo de texto Dockerrun.aws.json v2 com esse nome na raiz da sua aplicação e adicione o seguinte texto:

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

Este exemplo de configuração define dois contêineres, um site em PHP com proxy nginx na frente dele. Esses dois contêineres serão executados lado a lado nos contêineres do Docker em cada instância do ambiente do Elastic Beanstalk, acessando conteúdo compartilhado (conteúdo do site) dos volumes na instância do host, que também são definidos nesse arquivo. Os contêineres são criados a partir de imagens hospedadas em repositórios oficiais no Docker Hub. O ambiente resultante se parece com este:

Os volumes definidos na configuração correspondem ao conteúdo que você vai criar em seguida e fazer upload como parte do pacote de origem do aplicativo. Os contêineres acessam o conteúdo no host montando volumes na seção mountPoints das definições de contêiner.

Para obter mais informações sobre o formato Dockerrun.aws.json v2 e seus parâmetros, consulte Formato de definição de contêiner.

Adicionar conteúdo

Em seguida, você vai adicionar conteúdo para seu site PHP exibir para os visitantes, e um arquivo de configuração para o 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;
  }
}

Implantar no Elastic Beanstalk

Agora, a sua pasta do aplicativo contém os seguintes arquivos:

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

Isso é tudo de que você precisa para criar o ambiente do Elastic Beanstalk. Crie um arquivamento .zip dos arquivos e pastas acima (não incluindo a pasta do projeto de nível superior). Para criar o arquivamento no Windows Explorer, selecione o conteúdo da pasta do projeto, clique com o botão direito do mouse, selecione Enviar para e clique em Pasta compactada (zipada)

Depois, faça upload do pacote de origem para o Elastic Beanstalk e crie o ambiente. Em Platform (Plataforma), selecione Docker. Em Ramificação da plataforma, selecione Docker de vários contêineres em execução no Amazon Linux de 64 bits.

O console do Elastic Beanstalk redireciona você para o painel de gerenciamento do novo ambiente. Essa tela mostra o status de integridade do ambiente e saída de eventos pelo serviço do Elastic Beanstalk. Quando o status estiver verde, clique no URL ao lado do nome do ambiente para ver seu novo site.

Conectar-se a uma instância de contêiner

Depois, você vai se conectar a uma instância do Amazon EC2 no ambiente do Elastic Beanstalk para ver algumas das partes móveis em ação.

A maneira mais fácil de se conectar a uma instância em seu ambiente é usar a CLI do EB. Para usá-la, instale a CLI do EB, se você ainda não tiver feito isso. Também será necessário configurar o ambiente com um par de chaves SSH do Amazon EC2. Para fazer isso, use a página de configuração de segurança do console ou o comando eb init da CLI do EB. Use o comando eb ssh da CLI do EB para se conectar a uma instância do ambiente.

Agora que você se conectou à instância do Amazon EC2 que hospeda os contêineres do docker, poderá ver como as coisas são configuradas. Execute ls em /var/app/current:

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

Esse diretório contém os arquivos do pacote de origem do qual você fez upload para o Elastic Beanstalk durante a criação do 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

Este é o local em que os logs são criados na instância de contêiner e coletados pelo Elastic Beanstalk. O Elastic Beanstalk cria um volume nesse diretório para cada contêiner, que é montado no local do contêiner onde os logs são gravados.

Você também pode dar uma olhada no Docker para ver os contêineres em execução com 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

Isso mostra os dois contêineres implantados em execução, bem como o agente de contêiner do Amazon ECS que coordenou a implantação.

Inspecionar o agente de contêiner do Amazon ECS

As instâncias do Amazon EC2 em um ambiente do Docker gerenciado pelo ECS no Elastic Beanstalk executam um processo de agente em um contêiner do Docker. Esse agente se conecta ao Amazon ECS Service para coordenar implantações de contêiner. Essas implantações são executadas como tarefas no Amazon ECS, que são configuradas nos arquivos de definição de tarefas. O Elastic Beanstalk cria esses arquivos de definição de tarefas com base no Dockerrun.aws.json cujo upload será feito em um pacote de origem.

Verifique o status do agente de contêiner com uma solicitação HTTP get para 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)"
}

Essa estrutura mostra o nome do cluster do Amazon ECS e o ARN (Nome de recurso da Amazon) da instância do cluster (instância do Amazon EC2 à qual você está conectado).

Para obter mais informações, faça uma solicitação HTTP get ao 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"
                  }
               ]
            }
         ]
      }
   ]
}

Essa estrutura descreve a tarefa que é executada para implantar os dois contêineres do Docker deste projeto de exemplo deste tutorial. São exibidas as seguintes informações:

Mais informações estão disponíveis no próprio serviço Amazon ECS, que você pode chamar usando o AWS Command Line Interface. Para obter instruções sobre como usar a AWS CLI com o Amazon ECS e informações sobre o Amazon ECS em geral, consulte o Manual do usuário do Amazon ECS.