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: Implantar um serviço do Amazon ECS com um teste de validação
Neste tutorial, você aprenderá como usar uma função do Lambda para validar parte da implantação de um aplicativo do Amazon ECS atualizado. Este tutorial usa o CodeDeploy aplicativo, o grupo de CodeDeploy implantação e o aplicativo Amazon ECS em [Tutorial: Implantar um aplicativo no Amazon ECS](tutorial-ecs-deployment.md) que você usou. Conclua esse tutorial antes de iniciar o seguinte.
Para adicionar o teste de validação, primeiro implemente o teste em uma função do Lambda. Em seguida, em seu AppSpec arquivo de implantação, você especifica a função Lambda para o gancho de ciclo de vida que deseja testar. Se um teste de validação falhar, a implantação será interrompida, revertida e marcada como com falha. Se o teste for bem-sucedido, a implantação continuará para o próximo evento do ciclo de vida da implantação ou gancho.
Durante uma implantação do Amazon ECS com testes de validação, CodeDeploy usa um balanceador de carga configurado com dois grupos-alvo: um ouvinte de tráfego de produção e um ouvinte de tráfego de teste. O diagrama a seguir mostra como o balanceador de carga, os receptores de produção e de teste, os grupos de destino e o aplicativo do Amazon ECS são relacionados antes do início da implantação. Este tutorial usa um Application Load Balancer. Você também pode usar um Network Load Balancer.
![\[As conexões entre o Application Load Balancer ou o Network Load Balancer, os receptores, os grupos de destino, o conjunto de tarefas e o serviço Amazon ECS.\]](http://docs.aws.amazon.com/pt_br/codedeploy/latest/userguide/images/codedeploy-ecs-deployment-step-1.png)
Durante uma implantação do Amazon ECS, há cinco ganchos do ciclo de vida para testes. Este tutorial implementa um teste durante o terceiro gancho de implantação de ciclo de vida, `AfterAllowTestTraffic`. Para obter mais informações, consulte [Lista de hooks do evento do ciclo de vida para uma implantação Amazon ECS](reference-appspec-file-structure-hooks.md#reference-appspec-file-structure-hooks-list-ecs). Após uma implantação bem-sucedida, o listener do tráfego de produção atende ao tráfego do novo conjunto de tarefas de substituição e o conjunto de tarefas original é encerrado. O diagrama a seguir mostra como seus recursos estão relacionados após uma implantação bem-sucedida. Para obter mais informações, consulte [O que acontece durante uma implantação do](deployment-steps-ecs.md#deployment-steps-what-happens).
![\[As conexões entre o Application Load Balancer ou o Network Load Balancer, os receptores, os grupos de destino e o conjunto de tarefas de substituição após uma implantação.\]](http://docs.aws.amazon.com/pt_br/codedeploy/latest/userguide/images/codedeploy-ecs-deployment-step-6.png)
**nota**
A conclusão deste tutorial pode resultar em cobranças em sua AWS conta. Isso inclui possíveis cobranças de CodeDeploy AWS Lambda, CloudWatch e. Para obter mais informações, consulte [AWS CodeDeploy preços](https://aws.amazon.com/codedeploy/pricing/), [AWS Lambda preços](https://aws.amazon.com/lambda/pricing/) e [ CloudWatch preços da Amazon](https://aws.amazon.com/cloudwatch/pricing/).
**Topics**
+ [Pré-requisitos](tutorial-ecs-with-hooks-prereqs.md)
+ [Etapa 1: Criar um receptor de teste](tutorial-ecs-with-hooks-create-second-listener.md)
+ [Etapa 2: Atualizar o código do aplicativo do Amazon ECS](tutorial-ecs-with-hooks-update-the-ecs-application.md)
+ [Etapa 3: Criar uma função do Lambda de gancho do ciclo de vida](tutorial-ecs-with-hooks-create-hooks.md)
+ [Etapa 4: atualize seu AppSpec arquivo](tutorial-ecs-with-hooks-create-appspec-file.md)
+ [Etapa 5: Use o CodeDeploy console para implantar seu serviço Amazon ECS](tutorial-ecs-with-hooks-deployment.md)
+ [Etapa 6: Visualize a saída da função Lambda hook em Logs CloudWatch](tutorial-ecs-with-hooks-view-cw-logs.md)
+ [Etapa 7: limpar](tutoria-ecs-with-hooks-clean-up.md)
# Pré-requisitos
Para concluir este tutorial com êxito, você deve primeiro:
+ Atenda os pré-requisitos em [Pré-requisitos](tutorial-ecs-prereqs.md) para [Tutorial: Implantar um aplicativo no Amazon ECS](tutorial-ecs-deployment.md).
+ Siga as etapas em [Tutorial: Implantar um aplicativo no Amazon ECS](tutorial-ecs-deployment.md). Anote o seguinte:
+ O nome do seu load balancer.
+ Os nomes dos seus grupos de destino.
+ A porta usada pelo listener do load balancer.
+ O ARN do load balancer. Você o usará para criar um novo listener.
+ O ARN de um de seus grupos de destino. Você o usará para criar um novo listener.
+ O CodeDeploy aplicativo e o grupo de implantação que você cria.
+ O AppSpec arquivo que você cria e que é usado pela sua CodeDeploy implantação. Edite esse arquivo neste tutorial.
# Etapa 1: Criar um receptor de teste
Uma implantação do Amazon ECS com testes de validação requer um segundo receptor. Esse receptor é usado para atender ao tráfego de teste para seu aplicativo do Amazon ECS atualizado em um conjunto de tarefas de substituição. Os testes de validação são executados no tráfego de teste.
O listener do tráfego de teste pode usar qualquer um de seus grupos de destino. Use o AWS CLI comando [create-listener](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-listener.html) para criar um segundo ouvinte com uma regra padrão que encaminha o tráfego de teste para a porta 8080. Use o ARN do load balancer e o ARN de um de seus grupos de destino.
```
aws elbv2 create-listener --load-balancer-arn your-load-balancer-arn \
--protocol HTTP --port 8080 \
--default-actions Type=forward,TargetGroupArn=your-target-group-arn --region your-aws-region
```
# Etapa 2: Atualizar o código do aplicativo do Amazon ECS
Nesta seção, você atualiza o aplicativo do Amazon ECS para usar uma nova revisão de sua definição de tarefa. Você cria a nova revisão e adiciona uma atualização secundária a ela adicionando uma tag.
**Para atualizar a definição da tarefa**
1. Abra o console clássico do Amazon ECS em [https://console.aws.amazon.com/ecs/](https://console.aws.amazon.com/ecs/).
1. No painel de navegação, selecione **Definições de tarefas**.
1. Marque a caixa de seleção da definição da tarefa usada pelo serviço do Amazon ECS.
1. Escolha **Create new revisional (Criar nova revisão)**.
1. Faça uma pequena atualização na definição da tarefa adicionando uma tag. Na parte inferior da página, em **Tags**, crie uma nova tag inserindo um novo par de chave e valor.
1. Escolha **Criar**. Você deve ver que o número de revisão da definição da tarefa foi incrementado em um.
1. Selecione a guia **JSON**. Anote o valor de `taskDefinitionArn`. O formato é `arn:aws:ecs:aws-region: account-id:task-definition/task-definition-family: task-definition-revision`. Esse é o ARN da sua definição de tarefa atualizada.
# Etapa 3: Criar uma função do Lambda de gancho do ciclo de vida
Nesta seção, você implementa uma função do Lambda para o hook do `AfterAllowTestTraffic` da implantação do Amazon ECS. A função do Lambda executa um teste de validação antes do aplicativo do Amazon ECS atualizado ser instalado. Para este tutorial, a função do Lambda retorna `Succeeded`. Durante uma implantação do mundo real, os testes de validação retornam `Succeeded` ou `Failed`, dependendo do resultado do teste de validação. Além disso, durante uma implantação do mundo real, você pode implementar uma função de teste do Lambda para um ou mais dos outros hooks de evento do ciclo de vida da implantação do Amazon ECS (`BeforeInstall`, `AfterInstall`, `BeforeAllowTraffic` e `AfterAllowTraffic`). Para obter mais informações, consulte [Lista de hooks do evento do ciclo de vida para uma implantação Amazon ECS](reference-appspec-file-structure-hooks.md#reference-appspec-file-structure-hooks-list-ecs).
Um perfil do IAM é necessário para criar a função do Lambda. A função concede à função Lambda permissão para gravar em CloudWatch registros e definir o status de um gancho do ciclo de CodeDeploy vida.
**Para criar um perfil do IAM**
1. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. No painel de navegação, escolha **Roles (Funções)** e **Create role (Criar função)**.
1. Crie uma função com as seguintes propriedades:
+ **Trusted entity (Entidade confiável)**: **AWS Lambda**.
+ **Permissões**: **AWSLambdaBasicExecutionRole**. Isso concede à sua função Lambda permissão para CloudWatch gravar em registros.
+ **Nome da função**: **`lambda-cli-hook-role`**.
Para obter mais informações, consulte [Criar uma função AWS Lambda de execução](https://docs.aws.amazon.com/lambda/latest/dg/with-userapp.html#with-userapp-walkthrough-custom-events-create-iam-role).
1. Anexe a permissão `codedeploy:PutLifecycleEventHookExecutionStatus` à função que você criou. Isso concede às suas funções do Lambda permissão para definir o status de um gancho do CodeDeploy ciclo de vida durante uma implantação. Para obter mais informações, consulte [Adicionar permissões de identidade do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html#add-policies-console) no *Guia AWS Identity and Access Management do usuário* e [PutLifecycleEventHookExecutionStatus](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_PutLifecycleEventHookExecutionStatus.html)na *Referência da CodeDeploy API*.
**Como criar uma função do Lambda de hook do `AfterAllowTestTraffic`**
1. Crie um arquivo denominado `AfterAllowTestTraffic.js` com os conteúdos a seguir.
```
'use strict';
const AWS = require('aws-sdk');
const codedeploy = new AWS.CodeDeploy({apiVersion: '2014-10-06'});
exports.handler = (event, context, callback) => {
console.log("Entering AfterAllowTestTraffic hook.");
// Read the DeploymentId and LifecycleEventHookExecutionId from the event payload
var deploymentId = event.DeploymentId;
var lifecycleEventHookExecutionId = event.LifecycleEventHookExecutionId;
var validationTestResult = "Failed";
// Perform AfterAllowTestTraffic validation tests here. Set the test result
// to "Succeeded" for this tutorial.
console.log("This is where AfterAllowTestTraffic validation tests happen.")
validationTestResult = "Succeeded";
// Complete the AfterAllowTestTraffic hook by sending CodeDeploy the validation status
var params = {
deploymentId: deploymentId,
lifecycleEventHookExecutionId: lifecycleEventHookExecutionId,
status: validationTestResult // status can be 'Succeeded' or 'Failed'
};
// Pass CodeDeploy the prepared validation test results.
codedeploy.putLifecycleEventHookExecutionStatus(params, function(err, data) {
if (err) {
// Validation failed.
console.log('AfterAllowTestTraffic validation tests failed');
console.log(err, err.stack);
callback("CodeDeploy Status update failed");
} else {
// Validation succeeded.
console.log("AfterAllowTestTraffic validation tests succeeded");
callback(null, "AfterAllowTestTraffic validation tests succeeded");
}
});
}
```
1. Crie um pacote de implantação do Lambda.
```
zip AfterAllowTestTraffic.zip AfterAllowTestTraffic.js
```
1. Use o comando `create-function` para criar uma função do Lambda para o hook do `AfterAllowTestTraffic`.
```
aws lambda create-function --function-name AfterAllowTestTraffic \
--zip-file fileb://AfterAllowTestTraffic.zip \
--handler AfterAllowTestTraffic.handler \
--runtime nodejs10.x \
--role arn:aws:iam::aws-account-id:role/lambda-cli-hook-role
```
1. Anote o ARN da função do Lambda na resposta do `create-function`. Você usa esse ARN ao atualizar o AppSpec arquivo de CodeDeploy implantação na próxima etapa.
# Etapa 4: atualize seu AppSpec arquivo
Nesta seção, você atualiza seu AppSpec arquivo com uma `Hooks` seção. Na seção de `Hooks`, você especifica uma função do Lambda para o gancho do ciclo de vida do `AfterAllowTestTraffic`.
**Para atualizar seu AppSpec arquivo**
1. Abra o AppSpec arquivo que você criou no [Etapa 2: criar o AppSpec arquivo](tutorial-ecs-create-appspec-file.md)[Tutorial: Implantar um aplicativo no Amazon ECS](tutorial-ecs-deployment.md).
1. Atualize a propriedade `TaskDefinition` com o ARN da definição de tarefa anotado em [Etapa 2: Atualizar o código do aplicativo do Amazon ECS](tutorial-ecs-with-hooks-update-the-ecs-application.md).
1. Copie e cole a `Hooks` seção em seu AppSpec arquivo. Atualize o ARN depois do `AfterAllowTestTraffic` com o ARN da função do Lambda que você anotou no [Etapa 3: Criar uma função do Lambda de gancho do ciclo de vida](tutorial-ecs-with-hooks-create-hooks.md).
------
#### [ JSON AppSpec ]
```
{
"version": 0.0,
"Resources": [
{
"TargetService": {
"Type": "AWS::ECS::Service",
"Properties": {
"TaskDefinition": "arn:aws:ecs:aws-region-id:aws-account-id::task-definition/ecs-demo-task-definition:revision-number",
"LoadBalancerInfo": {
"ContainerName": "sample-website",
"ContainerPort": 80
}
}
}
}
],
"Hooks": [
{
"AfterAllowTestTraffic": "arn:aws:lambda:aws-region-id:aws-account-id:function:AfterAllowTestTraffic"
}
]
}
```
------
#### [ YAML AppSpec ]
```
version: 0.0
Resources:
- TargetService:
Type: AWS::ECS::Service
Properties:
TaskDefinition: "arn:aws:ecs:aws-region-id:aws-account-id::task-definition/ecs-demo-task-definition:revision-number"
LoadBalancerInfo:
ContainerName: "sample-website"
ContainerPort: 80
Hooks:
- AfterAllowTestTraffic: "arn:aws:lambda:aws-region-id:aws-account-id:function:AfterAllowTestTraffic"
```
------
1. Salve seu AppSpec arquivo e faça o upload para o bucket do S3.
# Etapa 5: Use o CodeDeploy console para implantar seu serviço Amazon ECS
Nesta seção, você atualiza o grupo de implantação especificando a porta do listener de teste. Esse é o listener que você criou em [Etapa 1: Criar um receptor de teste](tutorial-ecs-with-hooks-create-second-listener.md). Durante a implantação, o CodeDeploy executa o teste de validação durante o gancho de ciclo de vida da implantação `AfterAllowTestTraffic` usando o tráfego de teste fornecido a seu conjunto de tarefas de substituição usando o listener de teste. O teste de validação retorna o resultado `Succeeded`, portanto, a implantação prossegue com o próximo evento de ciclo de vida da implantação. Em um cenário do mundo real, sua função de teste retorna `Succeeded` ou `Failed`.
**Para adicionar um listener de teste ao grupo de implantação**
1. Faça login no Console de gerenciamento da AWS e abra o CodeDeploy console em [https://console.aws.amazon.com/codedeploy/](https://console.aws.amazon.com/codedeploy/).
1. No painel de navegação, selecione **Applications (Aplicativos)**.
1. Escolha o aplicativo que você criou em [Tutorial: Implantar um aplicativo no Amazon ECS](tutorial-ecs-deployment.md). Se você usou o nome sugerido, ele será **ecs-demo-codedeploy-app**.
1. Em **Deployment groups (Grupos de implantação)**, selecione o grupo de implantação que você criou em [Tutorial: Implantar um aplicativo no Amazon ECS](tutorial-ecs-deployment.md), Se você usou o nome sugerido, ele será **ecs-demo-dg**.
1. Escolha **Editar**.
1. Em **Test listener port (Porta do listener de teste)**, escolha a porta e o protocolo para o listener de teste que você criou anteriormente neste tutorial. Ela deve ser **HTTP: 8080**.
1. Escolha **Salvar alterações**.
**Para implantar o aplicativo do Amazon ECS**
1. Na página do console do grupo de implantação, escolha **Criar implantação**.
1. Em **Grupo de implantação**, escolha **ecs-demo-dg**.
1. Em **Tipo de revisão**, escolha **Meu aplicativo está armazenado no Amazon S3**. Em **Local da revisão**, insira o nome do bucket e do AppSpec arquivo do S3 (por exemplo,**s3://my-s3-bucket/appspec.json**).
1. Em **Tipo de arquivo de revisão**, escolha **.json** ou **.yaml** conforme apropriado.
1. (Opcional) Em **Descrição da implantação**, digite uma descrição para a implantação.
1. Escolha **Criar implantação**.
Você pode monitorar a implantação em **Deployment status (Status da implantação)**. Depois que 100% do tráfego de produção for roteado para o conjunto de tarefas de substituição, você poderá escolher **Encerrar conjunto de tarefas original** para encerrar imediatamente o conjunto de tarefas original. Se você não escolher **Terminate original task set (Encerrar conjunto de tarefas original)**, o conjunto de tarefas original será encerrado após o período especificado quando você criou o grupo de implantação.
![\[A seção de status de implantação do CodeDeploy console.\]](http://docs.aws.amazon.com/pt_br/codedeploy/latest/userguide/images/ecs-tutorial-deployment-status-with-test-listener.png)
# Etapa 6: Visualize a saída da função Lambda hook em Logs CloudWatch
Se sua CodeDeploy implantação for bem-sucedida, os testes de validação em suas funções de gancho do Lambda também serão bem-sucedidos. Você pode confirmar isso examinando o registro da função de gancho em CloudWatch Logs.
1. Abra o CloudWatch console em [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Na página de navegação, escolha **Logs**. Você deve ver um novo grupo de registros para a função de gancho do Lambda especificada em seu AppSpec arquivo.
![\[O novo grupo de registros no CloudWatch console.\]](http://docs.aws.amazon.com/pt_br/codedeploy/latest/userguide/images/ecs-demo-cw-logs.png)
1. Escolha o novo grupo de logs. Isso deve ser**/aws/lambda/AfterAllowTestTrafficHook**.
1. Escolha o fluxo de logs. Se você vir mais de um fluxo de logs, escolha aquele com a data e hora mais recentes em **Last Event Time (Hora do último evento)**.
1. Expanda os eventos do fluxo de logs para confirmar se a função de hook do Lambda gravou mensagens de êxito no log. A tabela a seguir mostra que a função de hook do Lambda do `AfterAllowTraffic` foi bem-sucedida.
![\[Os eventos do fluxo de logs mostrando o hook AfterAllowTraffic.\]](http://docs.aws.amazon.com/pt_br/codedeploy/latest/userguide/images/ecs-demo-cw-log-events.png)
# Etapa 7: limpar
Ao concluir este tutorial, limpe os recursos associados a ele para evitar cobranças por recursos que você não está usando. Os nomes dos recursos nesta etapa são os nomes sugeridos neste tutorial (por exemplo, **ecs-demo-codedeploy-app** para o nome do seu CodeDeploy aplicativo). Se você tiver usado nomes diferentes, certifique-se de usá-los em sua limpeza.
**Para limpar os recursos do tutorial**
1. Use o [delete-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/delete-deployment-group.html)comando para excluir o grupo CodeDeploy de implantação.
```
aws deploy delete-deployment-group --application-name ecs-demo-deployment-group --deployment-group-name ecs-demo-dg --region aws-region-id
```
1. Use o comando [delete-application](https://docs.aws.amazon.com/cli/latest/reference/deploy/delete-application.html) para excluir o aplicativo. CodeDeploy
```
aws deploy delete-application --application-name ecs-demo-deployment-group --region aws-region-id
```
1. Use o comando [delete-function](https://docs.aws.amazon.com/cli/latest/reference/lambda/delete-function.html) para excluir a função de hook do Lambda.
```
aws lambda delete-function --function-name AfterAllowTestTraffic
```
1. Use o [delete-log-group](https://docs.aws.amazon.com/cli/latest/reference/logs/delete-log-group.html)comando para excluir seu grupo de CloudWatch registros.
```
aws logs delete-log-group --log-group-name /aws/lambda/AfterAllowTestTraffic
```