Conceitos básicos do Amazon ECS usando AWS Copilot

Conceitos básicos do Amazon ECS usando AWS Copilot para implantação de uma aplicação do Amazon ECS.

Pré-requisitos

Antes de começar, certifique-se de que os seguintes pré-requisitos sejam atendidos:

• Configure uma conta da AWS. Para obter mais informações, consulte Configuração para usar o Amazon ECS.

• Instale a CLI do AWS Copilot. No momento, as versões oferecem suporte aos sistemas Linux e macOS. Para obter mais informações, consulte Instalar a CLI do AWS Copilot.

• Instale e configure a AWS CLI. Para obter mais informações, consulte Interface da linha de comando da AWS.

• Execute aws configure para configurar um perfil padrão que a CLI do AWS Copilot usará para gerenciar as aplicações e serviços.

• Instale e execute o Docker. Para obter mais informações, consulte Conceitos básicos do Docker.

Implantar a aplicação usando um comando

Certifique-se de ter instalado a ferramenta da linha de comando da AWS e de já ter executado aws configure antes de começar.

Implante a aplicação usando o comando a seguir.

git clone https://github.com/aws-samples/amazon-ecs-cli-sample-app.git demo-app && \ 
cd demo-app &&                               \
copilot init --app demo                      \
  --name api                                 \
  --type 'Load Balanced Web Service'         \
  --dockerfile './Dockerfile'                \
  --port 80                                  \
  --deploy

Implantar a aplicação detalhadamente

Etapa 1: configurar as credenciais

Execute aws configure para configurar um perfil padrão que a CLI do AWS Copilot use para gerenciar as aplicações e serviços.

aws configure

Etapa 2: clonar a aplicação de demonstração

Clone uma aplicação simples do Flask e do Dockerfile.

git clone https://github.com/aws-samples/amazon-ecs-cli-sample-app.git demo-app

Etapa 3: configurar a aplicação

1. A partir do diretório demo-app, execute o comando init.

   Para usuários do Windows, execute o comando init da pasta que contém o arquivo copilot.exe baixado.

   copilot init

   O AWS Copilot orienta você durante a configuração da primeira aplicação e serviço com uma série de prompts de terminal, começando com next step (próxima etapa). Se você já tiver usado o AWS Copilot para implantar aplicações, será solicitado a escolher uma delas em uma lista de nomes de aplicações.

2. Nomeie a aplicação.

   What would you like to name your application? [? for help]

   Enter demo.

Etapa 4: configurar um serviço do ECS na aplicação de demonstração

1. Você será solicitado a escolher um tipo de serviço. Você está criando uma aplicação simples do Flask queserve a uma API pequena.

   Which service type best represents your service's architecture? [Use arrows to move, type to filter, ? for more help]
      > Load Balanced Web Service
        Backend Service
        Scheduled Job

   Choose Load Balanced Web Service .

2. Forneça um nome para o serviço.

   What do you want to name this Load Balanced Web Service? [? for help]

   Enter api para o nome do serviço.

3. Selecione um arquivo do Docker.

   Which Dockerfile would you like to use for api? [Use arrows to move, type to filter, ? for more help]
      > ./Dockerfile
        Use an existing image instead

   Choose Dockerfile.

   Para usuários do Windows, insira o caminho para o Dockerfile na demo-app folder (*`...\demo-app\Dockerfile`*\.).

4. Defina a porta.

   Which port do you want customer traffic sent to? [? for help] (80)

   Enter 80 ou aceitar padrão.

5. Você verá um log mostrando os recursos da aplicação que estão sendo criados.

   Creating the infrastructure to manage services under application demo.

6. Depois que os recursos da aplicação forem criados, implante um ambiente de teste.

   Would you like to deploy a test environment? [? for help] (y/N)

   Enter y.

   Proposing infrastructure changes for the test environment.

7. Você verá um log exibindo o status da implantação da aplicação.

   Note: It's best to run this command in the root of your Git repository.
   Welcome to the Copilot CLI! We're going to walk you through some questions
   to help you get set up with an application on ECS. An application is a collection of
   containerized services that operate together.
   
   Use existing application: No
   Application name: demo
   Workload type: Load Balanced Web Service
   Service name: api
   Dockerfile: ./Dockerfile
   no EXPOSE statements in Dockerfile ./Dockerfile
   Port: 80
   Ok great, we'll set up a Load Balanced Web Service named api in application demo listening on port 80.
   
   ✔ Created the infrastructure to manage services under application demo.
   
   ✔ Wrote the manifest for service api at copilot/api/manifest.yml
   Your manifest contains configurations like your container size and port (:80).
   
   ✔ Created ECR repositories for service api.
   
   All right, you're all set for local development.
   Deploy: Yes
   
   ✔ Created the infrastructure for the test environment.
   - Virtual private cloud on 2 availability zones to hold your services     [Complete]
   - Virtual private cloud on 2 availability zones to hold your services     [Complete]
     - Internet gateway to connect the network to the internet               [Complete]
     - Public subnets for internet facing services                           [Complete]
     - Private subnets for services that can't be reached from the internet  [Complete]
     - Routing tables for services to talk with each other                   [Complete]
   - ECS Cluster to hold your services                                       [Complete]
   ✔ Linked account aws_account_id and region region to application demo.
   
   ✔ Created environment test in region region under application demo.                         
   Environment test is already on the latest version v1.0.0, skip upgrade.
   [+] Building 0.8s (7/7) FINISHED
    => [internal] load .dockerignore                                                                                  0.1s
    => => transferring context: 2B                                                                                    0.0s
    => [internal] load build definition from Dockerfile                                                               0.0s
    => => transferring dockerfile: 37B                                                                                0.0s
    => [internal] load metadata for docker.io/library/nginx:latest                                                    0.7s
    => [internal] load build context                                                                                  0.0s
    => => transferring context: 32B                                                                                   0.0s
    => [1/2] FROM docker.io/library/nginx@sha256:aeade65e99e5d5e7ce162833636f692354c227ff438556e5f3ed0335b7cc2f1b     0.0s
    => CACHED [2/2] COPY index.html /usr/share/nginx/html                                                             0.0s
    => exporting to image                                                                                             0.0s
    => => exporting layers                                                                                            0.0s
    => => writing image sha256:3ee02fd4c0f67d7bd808ed7fc73263880649834cbb05d5ca62380f539f4884c4                       0.0s
    => => naming to aws_account_id.dkr.ecr.region.amazonaws.com/demo/api:cee7709                                      0.0s
   WARNING! Your password will be stored unencrypted in /home/user/.docker/config.json.
   Configure a credential helper to remove this warning. See
   https://docs.docker.com/engine/reference/commandline/login/#credentials-store
   
   Login Succeeded
   The push refers to repository [aws_account_id.dkr.ecr.region.amazonaws.com/demo/api]
   592a5c0c47f1: Pushed
   6c7de695ede3: Pushed
   2f4accd375d9: Pushed
   ffc9b21953f4: Pushed
   cee7709: digest: sha_digest
   
   ✔ Deployed api, you can access it at http://demo-Publi-1OQ8VMS2VC2WG-561733989.region.elb.amazonaws.com.

Etapa 5: verificar se a aplicação está sendo executada

Visualize o status da aplicação usando os comandos a seguir.

Liste todas as suas aplicações do AWS Copilot.

copilot app ls

Mostre as informações sobre os ambientes e serviços na aplicação.

copilot app show

Mostre informações sobre os ambientes.

copilot env ls

Mostre informações sobre o serviço, incluindo endpoints, capacidade e recursos relacionados.

copilot svc show

Lista de todos os serviços em uma aplicação.

copilot svc ls

Mostre os logs de um serviço implantado.

copilot svc logs

Mostre o status do serviço.

copilot svc status

Liste os comandos e as opções disponíveis.

copilot --help

copilot init --help

Etapa 6. Aprender a criar um pipeline de CI/CD

As instruções podem ser encontradas no Workshop do ECS detalhando como automatizar totalmente um pipeline de CI/CD e um fluxo de trabalho do git usando o AWS Copilot.

Etapa 7: limpar

Execute o comando a seguir para excluir e limpar todos os recursos.

copilot app delete