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, um aplicativo PHP e um proxy nginx são executados lado a lado em cada uma das instâncias do Amazon Elastic Compute Cloud ( EC2Amazon) 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.
**Topics**
+ [Definir contêineres do Docker gerenciado pelo ECS](#create_deploy_docker_ecstutorial_config)
+ [Adicionar conteúdo](#create_deploy_docker_ecstutorial_code)
+ [Implantar no Elastic Beanstalk](#create_deploy_docker_ecstutorial_deploy)
+ [Conectar-se a uma instância de contêiner](#create_deploy_docker_ecstutorial_connect)
+ [Inspecionar o agente de contêiner do Amazon ECS](#create_deploy_docker_ecstutorial_connect_inspect)
## 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.
**nota**
Todo o código deste tutorial está disponível no repositório awslabs em. GitHub [https://github.com/awslabs/eb-docker-nginx-proxy](https://github.com/awslabs/eb-docker-nginx-proxy)
O arquivo que o Elastic Beanstalk usa para configurar os contêineres em uma instância da EC2 Amazon é um arquivo de texto em formato JSON chamado v2. `Dockerrun.aws.json` 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:
![\[Elastic Beanstalk environment with load balancer, auto scaling group, and two instances running Nginx and PHP-FPM.\]](http://docs.aws.amazon.com/pt_br/elasticbeanstalk/latest/dg/images/aeb-multicontainer-tutorial.png)
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](create_deploy_docker_v2config.md#create_deploy_docker_v2config_dockerrun_format).
## 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**
```
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;
}
}
```
## 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)**
**nota**
Para obter informações sobre a estrutura de arquivos e instruções necessárias para criar arquivamentos em outros ambientes, consulte [Crie um pacote de origem da aplicação Elastic Beanstalk](applications-sourcebundle.md)
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 2023 de 64 bits**.
**Para iniciar um ambiente (console)**
1. [Abra o console do Elastic Beanstalk com este link pré-configurado: console.aws.amazon. com/elasticbeanstalk/home\$1/newApplication? Nome do aplicativo = Tutoriais](https://console.aws.amazon.com/elasticbeanstalk/home#/newApplication?applicationName=tutorials&environmentType=LoadBalanced) e tipo de ambiente = LoadBalanced
1. Em **Plataforma**, selecione a plataforma e a ramificação da plataforma que correspondem à linguagem usada pelo aplicativo ou a plataforma do Docker para aplicativos baseados em contêiner.
1. Em **Application code (Código do aplicativo)**, escolha **Upload your code (Fazer upload do código)**.
1. Escolha **Local file (Arquivo local)** e **Choose file (Escolher arquivo)** e abra o pacote de origem.
1. Selecione **Review and launch**.
1. Revise as configurações disponíveis e, em seguida, escolha **Create app**.
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
Em seguida, você se conectará a uma EC2 instância da Amazon em seu 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](eb-cli3.md#eb-cli3-install), se você ainda não tiver feito isso. Você também precisará configurar seu ambiente com um par de chaves Amazon EC2 SSH. Para fazer isso, use a [página de configuração de segurança](using-features.managing.security.md) do console ou o comando [eb init](eb3-init.md) da CLI do EB. Use o comando [eb ssh](eb3-ssh.md) da CLI do EB para se conectar a uma instância do ambiente.
Agora que você está conectado a uma EC2 instância da Amazon que hospeda seus contêineres docker, você pode ver como as coisas estã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
EC2 As instâncias da Amazon em um ambiente Docker gerenciado pelo ECS no Elastic Beanstalk executam um processo de agente em um contêiner 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 ([Amazon Resource](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) Name) da instância do cluster (a instância da EC2 Amazon à 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:
+ **KnownStatus**— O `RUNNING` status indica que os contêineres ainda estão ativos.
+ **Família**: o nome da definição de tarefa que o Elastic Beanstalk criou a partir de `Dockerrun.aws.json`.
+ **Versão**: a versão da definição de tarefa. Ela é incrementada cada vez que o arquivo de definição de tarefas é atualizado.
+ **Contêineres**: informações sobre os contêineres em execução na instância.
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 o AWS CLI com o Amazon ECS e informações sobre o Amazon ECS em geral, consulte o Guia do usuário do [Amazon ECS.](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ECS_GetStarted.html)