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

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á.

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

Neste tutorial, você configura um pipeline no AWS CodePipeline que implanta aplicativos de contêiner usando uma implantação azul/verde que oferece suporte a imagens do Docker. Em uma implantação azul/verde, você pode executar a nova versão do seu aplicativo junto com a versão antiga e testar a nova versão antes de redirecionar o tráfego. Você também pode monitorar o processo de implantação e reverter rapidamente caso tenha algum problema.

nota

Este tutorial é para a ação de implantação azul/verde do Amazon ECS para CodeDeploy do CodePipeline. Para obter um tutorial que usa a ação de implantação padrão do Amazon ECS no CodePipeline, consulteTutorial: Implantação padrão do Amazon ECS com CodePipeline.

O pipeline concluído detecta alterações em sua imagem, que é armazenada em um repositório de imagens do, como o Amazon ECR, utilizando o CodeDeploy para rotear e implantar o tráfego para um cluster do Amazon ECS e load balancer. O CodeDeploy usa um ouvinte para redirecionar o tráfego para a porta do contêiner atualizado especificado no arquivo AppSpec. Para obter informações sobre como o load balancer, o listener de produção, os grupos de destino e o aplicativo do Amazon ECS são usados em uma implantação azul/verde, consulteTutorial: Implantar um Amazon ECS Service.

O pipeline também é configurado para usar um local de origem do, como CodeCommit, no qual sua definição de tarefas do Amazon ECS é armazenada. Neste tutorial, você configura cada um dessesAWSRecursos e crie o pipeline com estágios que contêm ações para cada recurso do.

Seu pipeline de entrega contínua compilará e implantará automaticamente as imagens de contêiner sempre que o código-fonte for alterado ou uma nova imagem de base for carregada no Amazon ECR.

Esse fluxo usa os seguintes artefatos:

  • Um arquivo de imagem do Docker que especifica o nome do contêiner e o URI do repositório de seu repositório de imagens do Amazon ECR.

  • Uma definição de tarefa do Amazon ECS que lista o nome da imagem de docker, nome do contêiner, nome do serviço do Amazon ECS e configuração do load balancer.

  • Um arquivo CodeDeploy AppSpec do que especifica o nome do arquivo de definição de tarefas do Amazon ECS, o nome do contêiner do aplicativo atualizado e a porta do contêiner em que o CodeDeploy redireciona o tráfego de produção. Também é capaz de especificar a configuração de rede opcional e as funções Lambda que podem ser executadas durante os ganchos do evento de ciclo de vida da implantação.

nota

Quando você confirmar uma alteração no repositório de imagens do Amazon ECR do, o pipeline criará umimageDetail.jsonpara esse commit. Para mais informações sobre o arquivo imageDetail.json, consulte Arquivo imageDetail.json para ações de implantação azul/verde do Amazon ECS.

Ao criar ou editar seu pipeline e atualizar ou especificar artefatos de origem para o estágio de implantação, certifique-se de apontar para os artefatos de origem com o nome e a versão mais recente que deseja utilizar. Depois de configurar seu pipeline, à medida que forem feitas alterações em sua imagem ou definição de tarefa, pode ser necessário atualizar os arquivos do artefato de origem em seus repositórios e editar o estágio de implantação em seu pipeline.

Prerequisites

É necessário que já tenham sido criados os recursos a seguir:

  • Um repositório CodeCommit. Você pode usar o repositório do AWS CodeCommit que você criou em Tutorial: Criar um pipeline simples (repositório CodeCommit).

  • Execute uma instância do Amazon EC2 Linux e instale o Docker para criar uma imagem, conforme mostrado neste tutorial. Caso já exista uma imagem que deseja usar, ignore esse pré-requisito.

Etapa 1: Criar imagem e enviar para um repositório do Amazon ECR

Nesta seção, você utilizará o Docker para criar uma imagem e usará oAWS CLIPara gerar um repositório do Amazon ECR e enviar a imagem ao repositório.

nota

Caso já exista uma imagem que deseja usar, pule esta etapa.

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 do Docker Hub:

    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 sua 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.

    aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin ACCOUNT_ID.dkr.ecr.us-west-2.amazonaws.com/nginx
  4. Enviar a imagem ao Amazon ECR usando orepositoryUriA partir do passo anterior.

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

Etapa 2: Criar arquivos de origem AppSpec e de definição de tarefas e enviar a um repositório do CodeCommit

Nesta seção, você criará um arquivo JSON de definição de tarefa e registrando-o no Amazon ECS. Em seguida, você criará um arquivo AppSpec para CodeDeploy e utilizará o cliente Git para enviar os arquivos ao repositório CodeCommit.

Criar uma definição de tarefa para sua imagem

  1. Crie um arquivo denominado taskdef.json com o seguinte conteúdo. 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, consulteFunção IAM de execução de tarefas do Amazon ECSnoGuia 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, consulteReferência CodeDeploy arquivos AppSpec.

    Crie um arquivo denominado appspec.yaml com o seguinte conteúdo. 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

Enviar arquivos ao repositório CodeCommit

  1. Enviar ou carregar os arquivos ao repositório CodeCommit. Esses arquivos são o artefato de origem gerado peloCriar pipelinepara sua 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 de seu repositório local para seu repositório do CodeCommit:

        git push
    2. Para usar o console do CodeCommit para carregar seus arquivos:

      1. Abra o console do CodeCommit e escolha o repositório noRepositóriosLista.

      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.

Etapa 3: Crie o Application Load Balancer e os grupos de destino

Nesta seção, você criará um Amazon EC2 Application Load Balancer do. É possível utilizar os nomes de sub-redes e valores do grupo de destino gerados com seu load balancer posteriormente, ao criar o serviço do Amazon ECS. É possível utilizar um Application Load Balancer ou Network Load Balancer. O load balancer deve usar uma VPC com duas sub-redes públicas em diferentes zonas de disponibilidade. Nessas etapas, confirme sua VPC padrão, crie um load balancer e crie dois grupos de destino para seu load balancer. Para obter mais informações, consulte Grupos de destino para seus load balancers de rede.

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

  1. Faça login no AWS Management Console 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 Yes (Sim) na coluna de Default VPC (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 Amazon EC2 Application Load Balancer do

  1. Faça login no AWS Management Console 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 (Próximo): Configure Security Settings.

  11. Selecione Next (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 (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 Name (Nome), informe o nome do grupo de destino (por exemplo, target-group-1).

    2. Em Target type (Tipo de destino), selecione IP.

    3. Em Protocol (Protocolo): Selecione HTTP. Em Port (Porta), insira 80.

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

  15. Selecione Next (Próximo): Review (Revisar)e, depois, escolhaCriar.

Criar um grupo de destino para seu load balancer.

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

  2. Selecione Criar grupo de destino.

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

  4. Em Target type (Tipo de destino), selecione IP.

  5. Em Protocol (Protocolo): Selecione HTTP. Em Port (Porta), insira 8080.

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

  7. Escolha Create (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.

Etapa 4: Crie seu cluster e serviço do Amazon ECS

Nesta seção, você criará um cluster do Amazon ECS e serviço do em que o CodeDeploy roteia o tráfego durante a implantação (para um cluster do Amazon ECS em vez de instâncias do EC2). Para gerar o serviço do Amazon ECS, é necessário utilizar os nomes de sub-redes, grupo de segurança e o valor do grupo de destino gerados com seu load balancer para criar o serviço.

nota

Quando você usa essas etapas para criar o cluster do Amazon ECS, use oSomente redesmodelo de cluster, que provisionaAWSRecipientes Fargate.AWS Fargate é uma tecnologia que gerencia a infraestrutura de instâncias de contêiner para você. Você não precisa escolher nem criar manualmente instâncias do Amazon EC2 para seu cluster do Amazon ECS.

Para criar um cluster do Amazon ECS

  1. Abra o console do Amazon ECS emhttps://console.aws.amazon.com/ecs/.

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

  3. Selecione Create cluster (Criar cluster).

  4. Selecione oSomente redesmodelo de cluster que utilizaAWSFargate e, em seguida, escolhaPró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 Create (Criar).

Para criar um serviço do Amazon ECS

Usar aAWS CLIpara 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.

    Para otaskDefinition, ao registrar uma definição de tarefa no Amazon ECS, você atribui a ela uma família. 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: Crie 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, a partir do painel de navegação, emBALANCEAMENTO DE CARGA, escolhaGrupos 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

Etapa 5: Crie o aplicativo e o grupo de implantação do CodeDeploy (plataforma de computação do ECS)

Quando você cria um aplicativo do CodeDeploy e um grupo de implantação para a plataforma de computação do Amazon ECS, o aplicativo é usado durante uma implantação para referenciar o grupo de implantação correto, grupos de destino, ouvintes e comportamento de redirecionamento de tráfego.

Para criar um aplicativo CodeDeploy

  1. Abra o console do CodeDeploy e escolhaCriar aplicativo.

  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. Selecione Criar aplicativo.

Para criar um grupo de implantação 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 Deployment group name (Nome do grupo de implantação) digite um nome que descreva o grupo de implantação.

  3. DentroFunção de serviçoEscolha uma função de serviço que conceda ao CodeDeploy acesso ao Amazon ECS. Para criar uma nova função de serviço, siga estas etapas:

    1. Abra o console do IAM emhttps://console.aws.amazon.com/iam/).

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

    3. Selecione Create role.

    4. Em Select type of trusted entity (Selecionar tipo de entidade confiável), escolha 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. Selecione Next (Próximo): Permissions A política gerenciada AWSCodeDeployRoleForECS já está anexada à função.

    5. Selecione Next (Próximo): Tags, ePróximo: Análise.

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

  4. DentroConfiguração de ambientesEscolha o nome do cluster do Amazon ECS e o nome do serviço.

  5. NoLoad balancers, escolha o nome do load balancer que distribui o tráfego ao 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 Target group 1 nome (Nome do grupo de destino 1) e Target group 2 name (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. SelecioneRedirecione o tráfego imediatamentePara determinar por quanto tempo após uma implantação bem-sucedida será possível redirecionar o tráfego à sua tarefa atualizada do Amazon ECS.

  9. Selecione Create deployment group (Criar grupo de implantação).

Etapa 6: Crie o pipeline

Nesta seção, você criará um pipeline com as seguintes ações:

  • Uma ação CodeCommit do na qual os artefatos de origem são a definição de tarefa e o arquivo AppSpec.

  • Um estágio de origem com uma ação de origem do Amazon ECR no qual o artefato de origem é o arquivo de imagem.

  • Um estágio de implantação com uma ação de implantação do Amazon ECS em que a implantação é executada com um aplicativo CodeDeploy e um grupo de implantação do.

Criar um pipeline de dois estágios com o assistente

  1. Faça login noAWS Management Consolee abra o console do CodePipeline emhttp://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. DentroEtapa 1: Escolha as configurações do pipeline, emPipeline name (Nome do pipeline), insiraMyImagePipeline.

  4. DentroFunção de serviço, escolhaNova função de serviçoPara permitir que o CodePipeline crie uma função de serviço no IAM.

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

  6. DentroEtapa 2: Adicionar estágio de origem, emProvedor de origem, escolhaAWS CodeCommit. DentroNome do repositórioEscolha o nome do repositório CodeCommit criado emEtapa 1: Criar um repositório CodeCommit. Em Nome do ramo, selecione o nome do ramo que contém a última atualização do código.

    Escolha Next (Próximo).

  7. DentroEtapa 3: Adicionar estágio de compilação, escolhaIgnorar o estágioe aceite a mensagem de aviso ao clicar emSaltarnovamente. Escolha Next (Próximo).

  8. DentroEtapa 4: Adicionar estágio 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.

      
                                OEtapa 4: ImplantePágina de uma ação do Amazon ECS

      nota

      O nome “Deploy” é o nome padrão dado ao estágio criado noEtapa 4: Implante, assim como “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. EmAWSCodeDeploy pSpec, escolhaSourceArtifact. 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 Next (Próximo).

  9. DentroEtapa 5: Review (Revisar), revise as informações e escolhaCriar pipeline.

Para 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 seu 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 escolhendo+ Add actionao lado da ação fonte 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.

    
                        Adicionar uma ação de origem do Amazon ECR ao pipeline.
  6. DentroNome do repositórioEscolha 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 de 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. SelecioneEditeEm seu estágio de implantação e escolha o ícone para editar oAmazon ECS (Azul/Verde)Ação .

  2. Role até a parte inferior do painel. Em Input artifacts (Artefatos de entrada), selecione Add (Adicionar). Adicione o artefato de origem do seu 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. DentroAWSCodeDeploy pSpec, escolhaSourceArtifacte, em seguida, verifique seappspec.yamlé 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 Save (Salvar).

    
                        OEtapa 4: Implantepara um estágio editado do Amazon ECS
  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 Release change (Liberar alteração) e, depois, Release (Liberar).

    
                        Pipeline concluído com um estágio Azul/Verde do Amazon ECS
  8. Selecione a ação de implantação para visualizá-la no CodeDeploy e veja o progresso 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.

Etapa 7: Faça uma alteração no pipeline e verifique a implantação

Inclua uma alteração em sua imagem e envie-a ao repositório do Amazon ECR. Deste modo, a execução de seu pipeline é acionada. Verifique se a alteração da imagem de origem foi implantada.