AWS ECS: Como executar Docker, Clusters e Tarefas

Image for post
Image for post
Criando Clusters, Serviços e Tarefas com Docker no AWS ECS

Existem muitos serviços de computação diferentes no Amazon Web Services. Existe a rota Serverless com o AWS Lambda, na qual você pode provisionar sua carga de trabalho e executá-la somente quando necessário. O Elastic Compute Cloud (EC2) permite executar qualquer carga de trabalho dentro de máquinas virtuais pelas quais você paga por hora.

Hoje, porém, muitas pessoas estão criando cargas de trabalho em contêineres usando o Docker. Então, que opções você tem para executar seus contêineres na AWS? Nesta postagem, criaremos uma imagem de exemplo em Docker. Em seguida, criaremos a infraestrutura da AWS para hospedar essa imagem e executá-la por meio do AWS Elastic Container Service (ECS). A partir daí, exploraremos como você pode implantar novas versões da sua imagem diretamente do seu terminal.

Vamos começar criando um contêiner do de exemplo do Docker para podermos realizar o deploy.

Imagem de exemplo do Docker

Para nosso propósito, vamos criar um aplicativo Node.js utilizando Express que contenha uma única rota. Vamos começar iniciando o projeto. Executamos yarn init e para o ponto de entrada, usaremos server.js:

Depois que o projeto for configurado, vamos instalar o express no projeto:

Legal! Agora podemos prosseguir e configurar a nossa rota adicionando o seguinte ao arquivo ‌server.js:

Agora que temos nossa API express de exemplo, vamos em frente e configurar nosso Dockerfile. Aqui está o que o nosso Dockerfile vai acabar parecendo:

Para verificar a integridade, vamos construir esta imagem e lançar um contêiner com ela:

Ótimo! Vemos que, quando executamos o contêiner na porta 8080, podemos chamar nossa rota via curl e receber de volta a resposta Sample Endpoint.

Agora que temos uma imagem do Docker para criar e implementar, vamos configurar um registro de contêiners na AWS para o qual podemos enviar nossas imagens.

Publicando imagens do Docker no Elastic Container Repository (ECR)

Para continuar com o nosso aprendizado da AWS, vamos configurar um repositório de ECR na AWS. Usaremos este repositório para hospedar nossa imagem do Docker. Antes de podermos fazer isso, você precisará ter a CLI da AWS instalada e configurada. Também usaremos o AWS CDKpara representar nossa infraestrutura como código, então também configure sua CLI.

A CLI e o CDK da AWS estão instalados e configurados? Legal, vamos inicializar nosso projeto CDK para começar a representar nossa infraestrutura em Typescript. Crie um novo diretório chamado infrastructure na raiz do seu repositório. Em seguida, inicialize um novo projeto via CDK:

Agora temos um projeto CDK dentro de nossa pasta infrastructure. O arquivo-chave que iremos adicionar a nossa infraestrutura é lib/infrastructure-stack.ts.

Para começar, vamos adicionar nosso recurso de repositório ECR. Primeiro, precisamos adicionar o módulo ECR ao nosso projeto CDK:

Agora podemos provisionar nosso repositório de ECR, atualizando nosso infrastructure-stack.ts para ficar assim:

Para implantar nossa infraestrutura CDK, precisamos executar o comando deploy em nossa linha de comando:

Agora temos um repositório de ECR em nossa conta da AWS para hospedar nossa nova imagem do Docker. Com o nosso repositório criado, precisamos fazer o login antes de empurrar nossa nova imagem. Para fazer isso, executamos o comando abaixo dentro dos backticks, para que o comando docker login seja chamado uma vez que o get-login retornar:

Agora que estamos todos logados, podemos marcar e enviar nossa imagem para o nosso novo repositório do ECR. Pegue o repositoryUri do seu repositório no comando describe-repositories acima. Vamos usar isso na tag e no comando push abaixo:

Ótimo, nossa imagem do Docker está em nosso repositório ECR. Agora podemos prosseguir para implantá-lo e executá-lo via Elastic Container Service (ECS).

Configurando nossa infraestrutura de ECS

Antes de podermos executar um contêiner Docker em nossa conta da AWS usando nossa nova imagem, precisamos criar a infraestrutura na qual ele será executado. Nesse artigo, focaremos na execução de nosso contêiner no Elastic Container Service (ECS) fornecido pela AWS.

O ECS é um serviço de orquestração de contêiner fornecido pela AWS. Isso elimina a necessidade de gerenciar a infraestrutura, o planejamento e o dimensionamento de cargas de trabalho em contêiner.

O ECS consiste em três termos principais que devem ser lembrados ao pensar no serviço.

  • Cluster: este é o grupo lógico de instâncias subjacentes do EC2 em que nossos contêineres estão sendo executados. Não temos acesso a essas instâncias e a AWS as gerencia em nosso nome.
  • Serviço (Service): um processo de longa duração, como um servidor web ou banco de dados, é executado como um serviço em nosso cluster. Podemos definir quantos contêineres devem estar em execução para este serviço.
  • Definição da Tarefa (Task Definition): Esta é a definição do nosso contêiner que pode ser executado no cluster individualmente ou por meio de um serviço. Quando uma definição de tarefa está sendo executada em nosso cluster, geralmente a chamamos de tarefa, portanto, um contêiner em execução === uma tarefa no ECS.

A ordem dessas definições também são relevantes. Podemos pensar no cluster como o nível mais baixo do serviço, as instâncias do EC2 em que nossos contêineres são executados. Enquanto uma tarefa é uma instância do nosso contêiner em execução em uma ou mais dessas instâncias.

Com essa terminologia em nossa memória, vamos realmente provisionar nossa infraestrutura. Vamos atualizar o nosso infrastructure-stack.tspara ter os recursos necessários para o cluster do ECS. Primeiro, precisamos adicionar alguns outros módulos.

Agora podemos adicionar os recursos necessários ao nosso cluster que executará nossa nova imagem do Docker. Nosso infrastructure-stack.tsdeve ficar:

A primeira coisa que notamos é que primeiro definimos nosso cluster do ECS app-cluster,. Em seguida, precisamos adicionar uma instância ao nosso cluster app-scaling-group. Esse é um grupo de escalonamento automático de tipos de instância t2.micro nos quais nossos contêineres podem executar. Em seguida, usamos um padrão de balanceamento de carga de serviço fornecido pelo módulo ecsPatterns.

Observe que apontamos nosso serviço ECS para a imagem hospedada em nosso repositório ECR. Nós também definimos o containerPort que 8080 é a porta que nosso aplicativo express está sendo executado no interior do recipiente.

Esse padrão cria um balanceador de carga voltado para o público que poderemos chamar por curl ou em nosso navegador da web. Esse balanceador de carga encaminhará chamadas para nosso contêiner em execução na porta 8080 dentro de nosso serviço ECS.

Implementamos essas alterações por meio de outro comando deploy. Desta vez, vamos especificar — require-approval never para não sermos avisados ​​sobre as alterações do IAM.

Usando o módulo AWS CDK para o Elastic Container Service, criamos todos os recursos necessários para o nosso novo cluster. Como você pode ver na saída, uma nova VPC com sub-redes associadas foi criada em nosso nome. Esse é um bom benefício de uma ferramenta como o CDK, que criou padrões sensíveis para o nosso novo cluster sem precisar especificá-los.

Agora devemos ver que criamos um novo cluster ECS com nosso serviço executando nossa definição de tarefa atual. O CDK nos ajudou, produzindo a URL do nosso balanceador de carga de serviço. Vamos pegar essa URL e verificar se nosso contêiner está executando e aceitando tráfego:

Para onde ir daqui?

Agora que nosso contêiner inicial está sendo executado em nosso cluster ECS, podemos dar um passo atrás e explorar para onde podemos ir daqui.

Atualmente, nossa definição de tarefa do ECS está configurada para apontar para a tag latest da imagem do Docker que publicamos. Isso significa que podemos atualizar nossa imagem e as alterações podem ser implantadas em nosso cluster. Vamos atualizar a resposta que retornamos da nossa API:

Agora vamos criar e enviar uma nova versão da nossa imagem do Docker:

Agora temos uma nova versão da nossa imagem enviada para o nosso repositório. Mas ela não foi implantada em nosso serviço em execução em nosso cluster. Para captar a alteração em nosso cluster, precisamos reiniciar o serviço para que ele puxe a tag latest da nossa imagem.

Felizmente, podemos fazer isso com uma chamada de CLI da AWS em nossa linha de comando:

Depois que nossa nova imagem é lançada no serviço (que pode levar alguns minutos), podemos usar curl novamente e ver nossa nova resposta:

Conclusão

Agora, realizamos todo o exercício de criar uma imagem do Docker, provisionar um cluster do ECS e executar nossa imagem dentro do cluster. Nós até demonstramos como podemos atualizar nossa imagem e implantar novas versões em nosso serviço em execução.

Você pode seguir muitas direções. O próximo nível para o DevOps seria configurar um pipeline de CI / CD que permita implantar continuamente suas novas imagens no cluster do ECS. Tenho uma postagem no blog que se concentra na criação de imagens do Docker usando o AWS CodePipeline e o CodeBuild para você começar.

A partir daí, pode valer a pena reduzir os tempos de implantação ao iniciar uma nova imagem em nosso cluster ECS. A razão pela qual isso não é instantâneo é que o balanceador de carga associado ao nosso serviço tem que drenar as conexões ativas. Isso nos permite implementar de forma incremental novas versões para o nosso serviço sem interromper o serviço existente imediatamente. Isso é ideal para uma implantação imperceptível, mas significa que nosso tempo de implantação demoram um pouco mais.

Quer conferir meus outros projetos?

Eu sou um grande fã da comunidade DEV. Se você tiver alguma dúvida ou quiser conversar sobre idéias diferentes relacionadas à refatoração, entre em contato no Twitter ou envie um comentário abaixo.

Fora dos blogs, criei um curso Learn AWS Using It. No curso, nos concentramos em aprender o Amazon Web Services, para hospedar, proteger e fornecer sites estáticos. É um problema simples, com muitas soluções, mas é perfeito para aumentar sua compreensão da AWS. Recentemente, adicionei dois novos capítulos de bônus ao curso, focados na infraestrutura como código e implantação contínua.

Também organizo meu próprio boletim semanal. O boletim Learn By Doing é repleto de artigos impressionantes sobre nuvem, codificação e DevOps a cada semana. Inscreva-se para obtê-lo em sua caixa de entrada.

Written by

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store