Tutorial: Criar um pipeline com a origem do Amazon ECR e a implantação do ECS para CodeDeploy

Como criar uma imagem

1. Conecte-se à sua instância do Linux na qual o Docker esteja instalado.

   Expanda uma imagem para nginx. Esse comando fornece a imagem nginx:latest:

   docker pull nginx

2. Executar docker images. A imagem deve estar presente na lista.

   docker images

Para criar um repositório do Amazon ECR e enviar a imagem

1. Crie um repositório do Amazon ECR para armazenar sua imagem . Anote o repositoryUri apresentado na saída.

   aws ecr create-repository --repository-name nginx

   Resultado:

   {
       "repository": {
           "registryId": "aws_account_id",
           "repositoryName": "nginx",
           "repositoryArn": "arn:aws:ecr:us-east-1:aws_account_id:repository/nginx",
           "createdAt": 1505337806.0,
           "repositoryUri": "aws_account_id.dkr.ecr.us-east-1.amazonaws.com/nginx"
       }
   }

2. Marque a imagem com o valor repositoryUri da etapa anterior.

   docker tag nginx:latest aws_account_id.dkr.ecr.us-east-1.amazonaws.com/nginx:latest

3. Execute o comando aws ecr get-login-password, como mostrado neste exemplo para a região us-west-2 e o ID da conta 111122223333.

   aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin 111122223333.dkr.ecr.us-west-2.amazonaws.com/nginx

4. Envie a imagem ao Amazon ECR utilizando o repositoryUri da etapa anterior.

   docker push 111122223333.dkr.ecr.us-east-1.amazonaws.com/nginx:latest

Criar uma definição de tarefa para sua imagem

1. Crie um arquivo denominado taskdef.json com os conteúdos a seguir. Para image, insira o nome da imagem, como nginx. Esse valor é atualizado quando o pipeline é executado.

   nota

   Certifique-se de que a função de execução especificada na definição de tarefas contenha a AmazonECSTaskExecutionRolePolicy. Para obter mais informações, consulte Perfil do IAM de execução de tarefas do Amazon ECS no Guia do desenvolvedor do Amazon ECS.

   {
       "executionRoleArn": "arn:aws:iam::account_ID:role/ecsTaskExecutionRole",
       "containerDefinitions": [
           {
               "name": "sample-website",
               "image": "nginx",
               "essential": true,
               "portMappings": [
                   {
                       "hostPort": 80,
                       "protocol": "tcp",
                       "containerPort": 80
                   }
               ]
           }
       ],
       "requiresCompatibilities": [
           "FARGATE"
       ],
       "networkMode": "awsvpc",
       "cpu": "256",
       "memory": "512",
       "family": "ecs-demo"
   }

2. Registre sua definição de tarefas com o arquivo taskdef.json.

   aws ecs register-task-definition --cli-input-json file://taskdef.json

3. Após o registro da definição de tarefas, edite o arquivo para remover o nome da imagem e incluir o texto do espaço reservado <IMAGE1_NAME> no campo de imagem.

   {
       "executionRoleArn": "arn:aws:iam::account_ID:role/ecsTaskExecutionRole",
       "containerDefinitions": [
           {
               "name": "sample-website",
               "image": "<IMAGE1_NAME>",
               "essential": true,
               "portMappings": [
                   {
                       "hostPort": 80,
                       "protocol": "tcp",
                       "containerPort": 80
                   }
               ]
           }
       ],
       "requiresCompatibilities": [
           "FARGATE"
       ],
       "networkMode": "awsvpc",
       "cpu": "256",
       "memory": "512",
       "family": "ecs-demo"
   }

Criar um arquivo AppSpec

• O arquivo AppSpec é utilizado em implantações do CodeDeploy. O arquivo, que inclui campos opcionais, usa o seguinte formato:

  version: 0.0
  Resources:
    - TargetService:
        Type: AWS::ECS::Service
        Properties:
          TaskDefinition: "task-definition-ARN"
          LoadBalancerInfo:
            ContainerName: "container-name"
            ContainerPort: container-port-number
  # Optional properties
          PlatformVersion: "LATEST"
          NetworkConfiguration:
              AwsvpcConfiguration:
                Subnets: ["subnet-name-1", "subnet-name-2"]
                SecurityGroups: ["security-group"]
                AssignPublicIp: "ENABLED"
  Hooks:
  - BeforeInstall: "BeforeInstallHookFunctionName"
  - AfterInstall: "AfterInstallHookFunctionName"
  - AfterAllowTestTraffic: "AfterAllowTestTrafficHookFunctionName"
  - BeforeAllowTraffic: "BeforeAllowTrafficHookFunctionName"
  - AfterAllowTraffic: "AfterAllowTrafficHookFunctionName"

  Para obter mais informações sobre o arquivo AppSpec, incluindo exemplos, consulte CodeDeploy AppSpec File Reference.

  Crie um arquivo denominado appspec.yaml com os conteúdos a seguir. Para TaskDefinition, não altere o texto do espaço reservado <TASK_DEFINITION>. Esse valor é atualizado quando o pipeline é executado.

  version: 0.0
  Resources:
    - TargetService:
        Type: AWS::ECS::Service
        Properties:
          TaskDefinition: <TASK_DEFINITION>
          LoadBalancerInfo:
            ContainerName: "sample-website"
            ContainerPort: 80

Para enviar arquivos ao repositório do CodeCommit

1. Envie ou faça upload dos arquivos no repositório do CodeCommit. Esses arquivos são o artefato de origem gerado pelo assistente Criar pipeline para a ação de implantação no CodePipeline. Os arquivos devem ter a seguinte aparência em seu diretório local:

   /tmp
     |my-demo-repo
       |-- appspec.yaml
       |-- taskdef.json

2. Selecione o método que deseja utilizar para carregar seus arquivos:

   1. Usar a linha de comando git a partir de um repositório clonado no computador local:

      1. Altere diretórios para o repositório local:

         (For Linux, macOS, or Unix) cd /tmp/my-demo-repo
         (For Windows) cd c:\temp\my-demo-repo

      2. Execute o seguinte comando para organizar todos os seus arquivos de uma só vez:

         git add -A

      3. Execute o seguinte comando para confirmar os arquivos com uma mensagem de confirmação:

         git commit -m "Added task definition files"

      4. Execute o seguinte comando para enviar os arquivos do repositório local ao repositório do CodeCommit:

         git push

   2. Para usar o console do CodeCommit para fazer upload dos arquivos:

      1. Abra o console do CodeCommit e selecione o repositório na lista Repositórios.

      2. Selecione Add file (Adicionar arquivo) e clique em Upload file (Carregar arquivo).

      3. Clique em Choose file (Selecionar arquivo) e localize o arquivo. Informe seu nome de usuário e endereço de e-mail para confirmar a alteração. Escolha Commit changes (Confirmar alterações).

      4. Repita essa etapa para cada arquivo que deseja carregar.

Verificar sua VPC padrão e sub-redes públicas

1. Faça login no Console de gerenciamento da AWS e abra o console da Amazon VPC em https://console.aws.amazon.com/vpc/.

2. Verifique a VPC padrão a ser usada. No painel de navegação, escolha Your VPCs (Suas VPCs). Observe qual VPC exibe Sim na coluna de VPC padrão. Essa é a VPC padrão. Contém sub-redes padrão a serem selecionadas.

3. Selecione Subnets (Sub-redes). Selecione duas sub-redes que exibam Yes (Sim) na coluna de Default subnet (Sub-rede padrão).

   nota

   Anote seus IDs de sub-rede. Você precisará deles posteriormente neste tutorial.

4. Selecione as sub-redes e escolha a guia Description (Descrição). Verifique se as sub-redes que você deseja utilizar se encontram em diferentes zonas de disponibilidade.

5. Selecione as sub-redes e escolha a guia Route Table (Tabela de rotas). Para verificar se cada sub-rede que deseja utilizar é uma sub-rede pública, confirme se uma linha de gateway está presente na tabela de rotas.

Para criar um Application Load Balancer do Amazon EC2

1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon EC2 em https://console.aws.amazon.com/ec2/.

2. No painel de navegação, selecione Load Balancers.

3. Selecione Criar load balancer.

4. Selecione Application Load Balancer e clique em Create (Criar).

5. Em Name (Nome), informe o nome do load balancer.

6. Em Scheme (Esquema), selecione Internet-facing (Voltado para a Internet).

7. Em IP address type (Tipo de endereço IP), selecione ipv4.

8. Configure duas portas do listener para seu load balancer:

   1. Em Load Balancer Protocol (Protocolo do load balancer), selecione HTTP. Em Load Balancer Port (Porta do load balancer), insira 80.

   2. Escolha Add listener.

   3. Em Load Balancer Protocol (Protocolo do load balancer) para o segundo listener, selecione HTTP. Em Load Balancer Port (Porta do load balancer), insira 8080.

9. Em Availability Zones (Zonas de disponibilidade), em VPC, selecione a VPC padrão. A seguir, escolha as duas sub-redes padrão que deseja utilizar.

10. Selecione Next: Configure Security Settings (Próximo: Definir configurações de segurança).

11. Selecione Next: Configure Security Groups (Próximo: Configurar grupos de segurança).

12. Clique em Select an existing security group (Selecionar um grupo de segurança existente) e anote o ID do grupo de segurança.

13. Selecione Next: Configure Routing (Próximo: Configurar roteamento).

14. Em Target group (Grupo de destino), selecione New target group (Novo grupo de destino) e configure o primeiro grupo de destino:

    1. Em Nome, informe o nome do grupo de destino (por exemplo, target-group-1).

    2. Em Tipo de destino, selecione IP.

    3. Em Protocolo: Selecione HTTP. Em Porta, insira 80.

    4. Selecione Next: Register Targets (Próximo: Registrar destinos).

15. Selecione Next: Review (Próximo: Análise) e Create (Criar).

Criar um grupo de destino para seu load balancer.

1. Após a provisão do balanceador de carga, abra o console do Amazon EC2. No painel de navegação, selecione Grupos de destino.

2. Selecione Criar grupo de destino.

3. Em Nome, informe o nome do grupo de destino (por exemplo, target-group-2).

4. Em Tipo de destino, selecione IP.

5. Em Protocolo: Selecione HTTP. Em Porta, insira 8080.

6. Em VPC, escolha a VPC padrão.

7. Escolha Criar.

   nota

   Para que sua implantação seja executada, é necessário ter dois grupos de destino criados para seu load balancer. Somente é necessário anotar o ARN do seu primeiro grupo de destino. O ARN é usado no arquivo JSON create-service na próxima etapa.

Atualizar o load balancer para incluir o segundo grupo de destino

1. Abra o console do Amazon EC2. No painel de navegação, selecione Load Balancers.

2. Selecione seu load balancer e clique na guia Listeners. Escolha o listener com a porta 8080 e selecione Edit (Editar).

3. Selecione o ícone de lápis próximo a Forward to (Avançar para) Escolha o segundo grupo de destino e selecione a marca de verificação. Selecione Update (Atualizar) para salvar as atualizações.

Para criar um cluster do Amazon ECS

1. Abra o console clássico do Amazon ECS em https://console.aws.amazon.com/ecs/.

2. No painel de navegação, escolha Clusters.

3. Selecione Criar cluster.

4. Selecione o modelo de cluster Somente redes que utiliza o AWS Fargate e, depois, selecione Próxima etapa.

5. Insira um nome de cluster na página Configure cluster (Configurar cluster). Você pode adicionar uma tag opcional para o seu recurso. Escolha Criar.

Para criar um serviço do Amazon ECS

Use o AWS CLI para criar seu serviço no Amazon ECS.

1. Crie um arquivo JSON e o nomeie como create-service.json. Cole a seguinte informação no arquivo JSON.

   No campo taskDefinition, ao registrar uma definição de tarefa no Amazon ECS, você atribui uma família a ela. Isso é semelhante a um nome para várias versões da definição da tarefa, especificado com um número de revisão. Neste exemplo, use “ecs-demo:1” para a família e o número de revisão no seu arquivo. Use os nomes de sub-rede, o grupo de segurança e valor do grupo de destino que você criou com seu load balancer em Etapa 3: Criar o Application Load Balancer e os grupos de destino .

   nota

   É necessário incluir o ARN do grupo de destino nesse arquivo. Abra o console do Amazon EC2 e, no painel de navegação, em BALANCEAMENTO DE CARGA, selecione Grupos de destino. Escolha o primeiro grupo de destino. Copie o ARN da guia Description (Descrição).

   {
       "taskDefinition": "family:revision-number",
       "cluster": "my-cluster",
       "loadBalancers": [
           {
               "targetGroupArn": "target-group-arn",
               "containerName": "sample-website",
               "containerPort": 80
           }
       ],
       "desiredCount": 1,
       "launchType": "FARGATE",
       "schedulingStrategy": "REPLICA",
       "deploymentController": {
           "type": "CODE_DEPLOY"
       },
       "networkConfiguration": {
           "awsvpcConfiguration": {
               "subnets": [
                   "subnet-1",
                   "subnet-2"
               ],
               "securityGroups": [
                   "security-group"
               ],
               "assignPublicIp": "ENABLED"
           }
       }
   }

2. Execute o comando create-service especificando o arquivo JSON:

   Importante

   Não se esqueça de incluir file:// antes do nome de arquivo. Ele é obrigatório nesse comando.

   Este exemplo cria um serviço denominado my-service.

   nota

   Este comando de exemplo cria um serviço denominado my-service. Se você já tem um serviço com esse nome, o comando retornará um erro.

   aws ecs create-service --service-name my-service --cli-input-json file://create-service.json

   A saída retorna os campos de descrição para seu serviço.

3. Execute o comando describe-services para verificar se o serviço foi criado corretamente.

   aws ecs describe-services --cluster cluster-name --services service-name

Para criar um aplicativo CodeDeploy

1. Abra o console do CodeDeploy e selecione Criar aplicação.

2. Em Application name (Nome do aplicativo), informe o nome que deseja utilizar.

3. Em Compute platform (Plataforma de computação), selecione Amazon ECS.

4. Escolha Criar aplicativo.

Para criar um grupo de implantação do CodeDeploy

1. Na guia da página do aplicativo Deployment groups (Grupos de implantação), selecione Create deployment group (Criar grupo de implantação).

2. Em Nome do grupo de implantação digite um nome que descreva o grupo de implantação.

3. Em Perfil de serviço, escolha um perfil de serviço que conceda acesso do CodeDeploy ao Amazon ECS. Para criar uma nova função de serviço, siga estas etapas:

   1. Abra o console do IAM em https://console.aws.amazon.com/iam/.

   2. No painel do console, escolha Roles (Funções).

   3. Selecione Criar perfil.

   4. Em Selecionar tipo de entidade confiável, selecione AWS service (Serviço da AWS). Em Choose a use case (Escolher um caso de uso), selecione CodeDeploy. Em Select your use case (Selecione seu caso de uso), selecione CodeDeploy - ECS. Escolha Próximo: Permissões. A política gerenciada AWSCodeDeployRoleForECS já está anexada à função.

   5. Selecione Next: Tags (Próximo: tags) e Next: Review (Próximo: revisar).

   6. Insira um nome para a função (por exemplo, CodeDeployECSRole) e escolha Create role (Criar função).

4. Em Configuração de ambiente, selecione os nomes de cluster e serviço do Amazon ECS.

5. Em Balanceadores de carga, escolha o nome do balanceador de carga que distribui o tráfego para seu serviço do Amazon ECS.

6. Em Production listener port (Porta do listener de produção), escolha a porta e o protocolo para o listener que fornece o tráfego de produção para seu serviço do Amazon ECS. Em Test listener port (Porta do listener de teste), escolha a porta e o protocolo para o listener de teste.

7. Em Nome do grupo de destino 1 e Nome do grupo de destino 2, escolha os grupos de destino utilizados para rotear o tráfego durante a implantação. Certifique-se de que esses são os grupos de destino criados para o load balancer.

8. Selecione Redirecionar o tráfego imediatamente para determinar por quanto tempo após uma implantação bem-sucedida será possível redirecionar o tráfego à tarefa atualizada do Amazon ECS.

9. Selecione Criar grupo de implantação.

Criar um pipeline de dois estágios com o assistente

1. Faça login no Console de gerenciamento da AWS e abra o console do CodePipeline em http://console.aws.amazon.com/codesuite/codepipeline/home.

2. Na página Welcome (Bem-vindo), Getting started (Conceitos básicos) ou Pipelines, selecione Create pipeline (Criar pipeline).

3. Na página Etapa 1: Escolher opção de criação, em Opções de criação, selecione a opção Criar pipeline personalizado. Escolha Próximo.

4. Em Etapa 2: Escolher as configurações do pipeline, em Nome do pipeline, insira MyImagePipeline.

5. O CodePipeline disponibiliza pipelines dos tipos V1 e V2, que apresentam características e custos diferentes. O tipo V2 é o único tipo que você pode escolher no console. Para ter mais informações, consulte Pipeline types. Para obter informações sobre preços do CodePipeline, consulte Preços.

6. Em Perfil de serviço, escolha Novo perfil de serviço para permitir que o CodePipeline crie um perfil de serviço no IAM.

7. Deixe as configurações em Advanced settings (Configurações avançadas) como padrão e escolha Next (Próximo).

8. Em Etapa 3: Adicionar etapa de origem, em Provedor de origem, escolha AWS CodeCommit. Em Nome do repositório, selecione o nome do repositório do CodeCommit criado em Etapa 1: criar um repositório do CodeCommit. Em Nome do ramo, selecione o nome do ramo que contém a última atualização do código.

   Escolha Próximo.

9. Em Etapa 4: Adicionar etapa de compilação, escolha Ignorar etapa de compilação e aceite a mensagem de aviso escolhendo Ignorar novamente. Escolha Próximo.

10. Em Etapa 5: Adicionar etapa de teste, escolha Ignorar etapa de teste e aceite a mensagem de aviso escolhendo Ignorar novamente.

    Escolha Próximo.

11. Em Etapa 6: Adicionar etapa de implantação:

    1. Em Deploy provider (Fornecedor de implantação), selecione Amazon ECS (Blue/Green) (Amazon ECS [Azul/Verde]). Em Application name (Nome do aplicativo), informe ou selecione o nome de um aplicativo da lista, como codedeployapp. Em Deployment group (Grupo de implantação), informe ou selecione o nome de um grupo de implantação da lista, como codedeploydeplgroup.

       nota

       O nome "Deploy" é o nome padrão dado ao estágio criado em Step 4: Deploy (Etapa 4: implantar), assim como "Source" ("Origem) é o nome dado ao primeiro estágio do pipeline.

    2. Em Amazon ECS task definition (Definição de tarefa do Amazon ECS), selecione SourceArtifact. No campo, insira taskdef.json.

    3. Em Arquivo AppSpec do AWS CodeDeploy, selecione SourceArtifact. No campo, insira appspec.yaml.

       nota

       Nesse momento, não forneça informações em Dynamically update task definition image (Atualização dinâmica da imagem de definição de tarefas).

    4. Escolha Próximo.

12. Em Etapa 7: Revisar, revise as informações e, então selecione Criar pipeline.

Como adicionar uma ação de origem do Amazon ECR ao pipeline

Visualize o pipeline e adicione uma ação de origem do Amazon ECR ao pipeline.

1. Selecione seu pipeline. No canto superior esquerdo, selecione Edit (Editar).

2. No estágio de origem, clique em Edit stage (Editar estágio).

3. Adicione uma ação paralela ao selecionar + Adicionar ação ao lado da ação de origem do CodeCommit.

4. Em Action name (Nome da ação), informe um nome (por exemplo, Image).

5. Em Action provider (Provedor de ação), selecione Amazon ECR.

   

6. Em Nome do repositório, selecione o nome do repositório do Amazon ECR.

7. Em Image tag (Tag da imagem), especifique o nome da imagem e a versão, caso seja diferente da última.

8. Em Output artifacts (Artefatos de saída), escolha o artefato de saída padrão (por exemplo, MyImage) que contém o nome da imagem e as informações de URI do repositório que o próximo estágio deve utilizar.

9. Escolha Save (Salvar) na tela de ação. Escolha Done (Concluído) na tela de estágio. Escolha Save (Salvar) no pipeline. Uma mensagem mostra a regra do Amazon CloudWatch Events a ser criada para a ação de origem do Amazon ECR.

Como conectar os artefatos de origem à ação de implantação

1. Selecione Editar no estágio de implantação e escolha o ícone para editar a ação Amazon ECS (azul/verde).

2. Role até a parte inferior do painel. Em Input artifacts (Artefatos de entrada), selecione Add (Adicionar). Adicione o artefato de origem do novo repositório do Amazon ECR (por exemplo, MyImage).

3. Em Task Definition (Definição de tarefas), selecione SourceArtifact e, depois, verifique se taskdef.json foi inserido.

4. Em Arquivo AppSpec do AWS CodeDeploy, selecione SourceArtifact e, depois, verifique se appspec.yaml foi inserido.

5. Na Dynamically update task definition image (Atualização dinâmica da imagem de definição de tarefas), em Input Artifact with Image URI (Artefato de entrada com URI de imagem), selecione MyImage e, depois, insira o texto do espaço reservado utilizado no arquivo taskdef.json: IMAGE1_NAME Escolha Salvar.

6. No painel do AWS CodePipeline, selecione Save pipeline change (Salvar alteração do pipeline) e, em seguida, Save change (Salvar alteração). Visualize seu pipeline atualizado.

   Depois que esse pipeline de exemplo é criado, a configuração da ação para as entradas do console é exibida na estrutura do pipeline da seguinte forma:

   "configuration": {
     "AppSpecTemplateArtifact": "SourceArtifact",
     "AppSpecTemplatePath": "appspec.yaml",
     "TaskDefinitionTemplateArtifact": "SourceArtifact",
     "TaskDefinitionTemplatePath": "taskdef.json",
     "ApplicationName": "codedeployapp",
     "DeploymentGroupName": "codedeploydeplgroup",
     "Image1ArtifactName": "MyImage",
     "Image1ContainerName": "IMAGE1_NAME"
   },
   

7. Para enviar suas alterações e iniciar uma compilação do pipeline, selecione Liberar alteração e, depois, Liberar.

8. Selecione a ação de implantação para visualizá-la no CodeDeploy e veja o andamento da mudança de tráfego.

   nota

   Você pode ver uma etapa de implantação que mostra um tempo de espera opcional. Por padrão, o CodeDeploy aguarda uma hora após uma implantação bem-sucedida para encerrar o conjunto de tarefas original. Você pode usar esse tempo para reverter ou encerrar a tarefa, mas a sua implantação só será concluída quando o conjunto de tarefas for encerrado.