Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Tutorial: distribuisci un servizio Amazon ECS con un test di convalida
In questo tutorial, imparerai come usare una funzione Lambda per convalidare parte della distribuzione di un'applicazione Amazon ECS aggiornata. Questo tutorial utilizza l' CodeDeploy applicazione, il gruppo di CodeDeploy distribuzione e l'applicazione Amazon ECS in [Tutorial: distribuire un'applicazione in Amazon ECS](tutorial-ecs-deployment.md) cui hai utilizzato. Completare il tutorial prima di iniziare questo.
Per aggiungere il test di convalida, devi prima implementare il test in una funzione Lambda. Successivamente, nel AppSpec file di distribuzione, specifichi la funzione Lambda per l'hook del ciclo di vita che desideri testare. Se un test di convalida ha esito negativo, la distribuzione viene interrotta, viene eseguito il rollback e contrassegnato come non riuscito. Se il test va a buon fine, la distribuzione continua con l'hook o l'evento del ciclo di vita della distribuzione successivo.
Durante una distribuzione Amazon ECS con test di convalida, CodeDeploy utilizza un sistema di bilanciamento del carico configurato con due gruppi target: un listener di traffico di produzione e un listener di traffico di test. Il diagramma seguente mostra come il load balancer, i listener di produzione e test, i gruppi target e l'applicazione Amazon ECS sono correlati prima dell'inizio della distribuzione. In questa esercitazione viene utilizzato un Application Load Balancer. Puoi anche usare un Network Load Balancer.
![\[Le connessioni tra Application Load Balancer o Network Load Balancer, listener, gruppi target, set di attività e servizio Amazon ECS.\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/images/codedeploy-ecs-deployment-step-1.png)
Durante una distribuzione di Amazon ECS, sono disponibili cinque hook del ciclo di vita per i test. Questo tutorial implementa un test durante il terzo hook di distribuzione del ciclo di vita, `AfterAllowTestTraffic`. Per ulteriori informazioni, consulta [Elenco di eventi del ciclo di vita per una distribuzione Amazon ECS](reference-appspec-file-structure-hooks.md#reference-appspec-file-structure-hooks-list-ecs). Una volta completata la distribuzione, il listener del traffico di produzione serve il traffico verso il nuovo set di attività di sostituzione e il set di attività originale viene terminato. Il seguente diagramma mostra il modo in cui le risorse sono correlate dopo una distribuzione riuscita. Per ulteriori informazioni, consulta [Cosa succede durante una distribuzione di Amazon ECS](deployment-steps-ecs.md#deployment-steps-what-happens).
![\[Le connessioni tra Application Load Balancer o Network Load Balancer, listener, gruppi target e attività sostitutive impostate dopo una distribuzione.\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/images/codedeploy-ecs-deployment-step-6.png)
**Nota**
Il completamento di questo tutorial potrebbe comportare addebiti sul tuo account. AWS Questi includono possibili addebiti per CodeDeploy AWS Lambda, e CloudWatch. Per ulteriori informazioni, consulta [AWS CodeDeploy prezzi](https://aws.amazon.com/codedeploy/pricing/), [AWS Lambda prezzi](https://aws.amazon.com/lambda/pricing/) e [ CloudWatch prezzi Amazon](https://aws.amazon.com/cloudwatch/pricing/).
**Topics**
+ [Prerequisiti](tutorial-ecs-with-hooks-prereqs.md)
+ [Fase 1: Creare un listener di test](tutorial-ecs-with-hooks-create-second-listener.md)
+ [Fase 2: aggiorna la tua applicazione Amazon ECS](tutorial-ecs-with-hooks-update-the-ecs-application.md)
+ [Fase 3: Creare una funzione Lambda dell'hook del ciclo di vita](tutorial-ecs-with-hooks-create-hooks.md)
+ [Passaggio 4: aggiorna il file AppSpec](tutorial-ecs-with-hooks-create-appspec-file.md)
+ [Fase 5: utilizza la CodeDeploy console per distribuire il servizio Amazon ECS](tutorial-ecs-with-hooks-deployment.md)
+ [Fase 6: Visualizza l'output della funzione Lambda hook in Logs CloudWatch](tutorial-ecs-with-hooks-view-cw-logs.md)
+ [Fase 7: pulire](tutoria-ecs-with-hooks-clean-up.md)
# Prerequisiti
Per completare questo tutorial, è necessario innanzitutto:
+ Completa i prerequisiti in [Prerequisiti](tutorial-ecs-prereqs.md) per [Tutorial: distribuire un'applicazione in Amazon ECS](tutorial-ecs-deployment.md).
+ Completa le fasi descritte in [Tutorial: distribuire un'applicazione in Amazon ECS](tutorial-ecs-deployment.md). Prendi nota di quanto segue:
+ Il nome del sistema di bilanciamento del carico.
+ I nomi dei gruppi target.
+ La porta utilizzata dal listener del sistema di bilanciamento del carico.
+ L'ARN del sistema di bilanciamento del carico. Per creare un nuovo listener si dovrà utilizzare questo.
+ L'ARN di uno dei gruppi target. Per creare un nuovo listener si dovrà utilizzare questo.
+ L' CodeDeploy applicazione e il gruppo di distribuzione che crei.
+ Il AppSpec file creato che viene utilizzato dalla CodeDeploy distribuzione. Questo file viene modificato in questo tutorial.
# Fase 1: Creare un listener di test
Una distribuzione Amazon ECS con test di convalida richiede un secondo listener. Questo listener viene utilizzato per fornire traffico di test all'applicazione Amazon ECS aggiornata in un set di attività sostitutivo. I test di convalida vengono eseguiti sul traffico di test.
Il listener per il traffico di test può utilizzare uno dei gruppi target. Usa il AWS CLI comando [create-listener](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-listener.html) per creare un secondo listener con una regola predefinita che inoltra il traffico di test alla porta 8080. Utilizzare l'ARN del sistema di bilanciamento del carico e l'ARN di uno dei gruppi target.
```
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
```
# Fase 2: aggiorna la tua applicazione Amazon ECS
In questa sezione, aggiorni la tua applicazione Amazon ECS per utilizzare una nuova revisione della definizione del task. È possibile creare la nuova revisione e aggiungervi un aggiornamento secondario aggiungendo un tag.
**Per aggiornare la definizione dell'attività**
1. Apri la console Amazon ECS classic all'indirizzo [https://console.aws.amazon.com/ecs/](https://console.aws.amazon.com/ecs/).
1. Nel riquadro di navigazione, scegli **Definizioni di attività**.
1. Seleziona la casella di controllo per la definizione dell'attività utilizzata dal tuo servizio Amazon ECS.
1. Scegliere **Create new revision (Crea nuova revisione)**.
1. Effettuare un piccolo aggiornamento alla definizione dell'attività aggiungendo un tag. Nella parte inferiore della pagina, in **Tags (Tag)**, creare un nuovo tag immettendo una nuova coppia chiave-valore.
1. Scegli **Create** (Crea). Il numero di revisione della definizione dell'attività è stato incrementato di uno.
1. Scegli la scheda **JSON**. Annotare il valore per `taskDefinitionArn`. Il formato è: `arn:aws:ecs:aws-region: account-id:task-definition/task-definition-family: task-definition-revision`. Questo è l'ARN della definizione di attività aggiornata.
# Fase 3: Creare una funzione Lambda dell'hook del ciclo di vita
In questa sezione, implementerai una funzione Lambda per l'hook della tua distribuzione Amazon ECS. `AfterAllowTestTraffic` La funzione Lambda esegue un test di convalida prima dell'installazione dell'applicazione Amazon ECS aggiornata. Per questo tutorial, viene restituita la funzione Lambda. `Succeeded` Durante una distribuzione reale, i test di convalida restituiscono `Succeeded` o `Failed`, a seconda del risultato del test di convalida. Inoltre, durante una distribuzione nel mondo reale, puoi implementare una funzione di test Lambda per uno o più degli altri eventi del ciclo di vita della distribuzione Amazon ECS (`BeforeInstall`,, e). `AfterInstall` `BeforeAllowTraffic` `AfterAllowTraffic` Per ulteriori informazioni, consulta [Elenco di eventi del ciclo di vita per una distribuzione Amazon ECS](reference-appspec-file-structure-hooks.md#reference-appspec-file-structure-hooks-list-ecs).
È necessario un ruolo IAM per creare la funzione Lambda. Il ruolo concede alla funzione Lambda il permesso di scrivere CloudWatch nei registri e impostare lo stato di un hook del ciclo di CodeDeploy vita.
**Per creare un ruolo IAM**
1. Aprire la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Nel riquadro di navigazione selezionare **Roles (Ruoli)**, quindi **Create role (Crea ruolo)**.
1. Creare un ruolo con le seguenti proprietà:
+ **Trusted entity (Entità attendibile)**: **AWS Lambda**.
+ **Autorizzazioni:. **AWSLambdaBasicExecutionRole**** Ciò concede alla funzione Lambda il permesso di scrivere CloudWatch nei registri.
+ **Nome ruolo**: **`lambda-cli-hook-role`**.
Per ulteriori informazioni, consulta [Creare un AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/with-userapp.html#with-userapp-walkthrough-custom-events-create-iam-role) ruolo di esecuzione.
1. Collega l'autorizzazione `codedeploy:PutLifecycleEventHookExecutionStatus` al ruolo creato. Ciò concede alle funzioni Lambda l'autorizzazione a impostare lo stato di CodeDeploy un hook del ciclo di vita durante una distribuzione. *Per ulteriori informazioni, consulta [Aggiungere i permessi di identità IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html#add-policies-console) nella *Guida per l'AWS Identity and Access Management utente* e [PutLifecycleEventHookExecutionStatus](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_PutLifecycleEventHookExecutionStatus.html)nel riferimento API. CodeDeploy *
**Per creare una funzione Lambda a forma di `AfterAllowTestTraffic` hook**
1. Crea un file denominato `AfterAllowTestTraffic.js` con i seguenti contenuti.
```
'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. Crea un pacchetto di distribuzione Lambda.
```
zip AfterAllowTestTraffic.zip AfterAllowTestTraffic.js
```
1. Usa il `create-function` comando per creare una funzione Lambda per il tuo `AfterAllowTestTraffic` hook.
```
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. Prendi nota dell'ARN della tua funzione Lambda nella risposta. `create-function` Questo ARN viene utilizzato quando si aggiorna il AppSpec file della CodeDeploy distribuzione nel passaggio successivo.
# Passaggio 4: aggiorna il file AppSpec
In questa sezione, aggiorni il AppSpec file con una `Hooks` sezione. Nella `Hooks` sezione, si specifica una funzione Lambda per il `AfterAllowTestTraffic` lifecycle hook.
**Per aggiornare il file AppSpec**
1. Apri il AppSpec file che hai creato in [Fase 2: Creare il file AppSpec](tutorial-ecs-create-appspec-file.md)[Tutorial: distribuire un'applicazione in Amazon ECS](tutorial-ecs-deployment.md).
1. Aggiornare la proprietà `TaskDefinition` con l'ARN della definizione dell'attività annotato in [Fase 2: aggiorna la tua applicazione Amazon ECS](tutorial-ecs-with-hooks-update-the-ecs-application.md).
1. Copia e incolla la `Hooks` sezione nel tuo AppSpec file di file. Aggiorna l'ARN dopo `AfterAllowTestTraffic` con l'ARN della funzione Lambda che hai annotato. [Fase 3: Creare una funzione Lambda dell'hook del ciclo di vita](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. Salva il AppSpec file e caricalo nel relativo bucket S3.
# Fase 5: utilizza la CodeDeploy console per distribuire il servizio Amazon ECS
In questa sezione, aggiornerai il gruppo di distribuzione specificando la porta per il listener di test. Questo è il listener creato in [Fase 1: Creare un listener di test](tutorial-ecs-with-hooks-create-second-listener.md). Nel corso della distribuzione, CodeDeploy esegue il test di convalida durante l'hook del ciclo di vita della distribuzione `AfterAllowTestTraffic` utilizzando il traffico di test servito al set di attività di sostituzione mediante il listener di test. Il test di convalida restituisce il risultato `Succeeded`, quindi la distribuzione procede con il successivo evento del ciclo di vita della distribuzione. In uno scenario reale, la funzione di test restituisce `Succeeded` o `Failed`.
**Per aggiungere un listener di test al gruppo di distribuzione**
1. Accedi Console di gestione AWS e apri la CodeDeploy console all'indirizzo. [https://console.aws.amazon.com/codedeploy/](https://console.aws.amazon.com/codedeploy/)
1. Nel riquadro di navigazione , scegliere **Applications (Applicazioni)**.
1. Scegliere l'applicazione creata in [Tutorial: distribuire un'applicazione in Amazon ECS](tutorial-ecs-deployment.md). Se hai utilizzato il nome suggerito, è **ecs-demo-codedeploy-app**.
1. In **Deployment group (Gruppo di distribuzione)**, scegliere il gruppo di distribuzione appena creato in [Tutorial: distribuire un'applicazione in Amazon ECS](tutorial-ecs-deployment.md). Se hai utilizzato il nome suggerito, è **ecs-demo-dg**.
1. Scegli **Modifica**.
1. Da **Test listener port (Porta listener di test)**, scegliere la porta e il protocollo per il listener di test creato in precedenza in questo tutorial. Deve essere **HTTP: 8080**.
1. Scegli **Save changes** (Salva modifiche).
**Per distribuire la tua applicazione Amazon ECS**
1. Nella pagina della console del gruppo di distribuzione, scegliere **Create deployment (Crea distribuzione)**.
1. Per il **gruppo Deployment**, scegli. **ecs-demo-dg**
1. Per **Revision type (Tipo di revisione)**, scegliere **My application is stored in Amazon S3 (La mia applicazione è archiviata in Amazon S3)**. In **Posizione di revisione**, inserisci il nome del bucket e del AppSpec file S3 (ad esempio,). **s3://my-s3-bucket/appspec.json**
1. Per **Revision file type (Tipo di file revisione)**, scegliere **.json** o **.yaml** a seconda dei casi.
1. (Facoltativo) In **Deployment description (Descrizione distribuzione)**, immetti una descrizione per questa distribuzione.
1. Scegli **Create deployment (Crea distribuzione)**.
Puoi monitorare la distribuzione in **Deployment status (Stato distribuzione)**. Dopo che il 100% del traffico di produzione è stato indirizzato al set di attività sostitutivo, puoi scegliere **Termina il set di attività originale per terminare immediatamente il set di attività originale**. Se non si sceglie **Terminate original task set (Termina set di attività originale)**, il set di attività originale termina dopo la durata specificata al momento della creazione del gruppo di distribuzione.
![\[La sezione sullo stato della distribuzione della console. CodeDeploy\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/images/ecs-tutorial-deployment-status-with-test-listener.png)
# Fase 6: Visualizza l'output della funzione Lambda hook in Logs CloudWatch
Se l' CodeDeploy implementazione ha esito positivo, anche i test di convalida delle funzioni hook Lambda hanno esito positivo. Puoi confermarlo esaminando il registro della funzione hook in Logs. CloudWatch
1. Apri la CloudWatch console all'indirizzo [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Nel riquadro di navigazione scegliere **Log**. Dovresti vedere un nuovo gruppo di log per la funzione hook Lambda che hai specificato nel tuo AppSpec file.
![\[Il nuovo gruppo di log nella CloudWatch console.\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/images/ecs-demo-cw-logs.png)
1. Scegliere il nuovo gruppo di log. Dovrebbe essere**/aws/lambda/AfterAllowTestTrafficHook**.
1. Scegli il flusso di log. Se si visualizza più di un flusso di log, scegliere quello con la data e l'ora più recenti in **Last Event Time (Ora ultimo evento)**.
1. Espandi gli eventi del flusso di registro per confermare che la funzione Lambda hook abbia scritto messaggi di successo nel registro. Quanto segue mostra che la funzione `AfterAllowTraffic` Lambda hook ha avuto successo.
![\[Gli eventi del flusso di registro che mostrano l'AfterAllowTraffichook.\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/images/ecs-demo-cw-log-events.png)
# Fase 7: pulire
Una volta terminato questo tutorial, rimuovi le risorse associate per evitare costi aggiuntivi per risorse che non utilizzi. I nomi delle risorse in questo passaggio sono i nomi suggeriti in questo tutorial (ad esempio, **ecs-demo-codedeploy-app** per il nome dell' CodeDeploy applicazione). Se sono stati utilizzati nomi diversi, utilizzarli nella pulizia.
**Per eliminare le risorse del tutorial**
1. Utilizzate il [delete-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/delete-deployment-group.html)comando per eliminare il gruppo CodeDeploy di distribuzione.
```
aws deploy delete-deployment-group --application-name ecs-demo-deployment-group --deployment-group-name ecs-demo-dg --region aws-region-id
```
1. Utilizzate il comando [delete-application](https://docs.aws.amazon.com/cli/latest/reference/deploy/delete-application.html) per eliminare l' CodeDeploy applicazione.
```
aws deploy delete-application --application-name ecs-demo-deployment-group --region aws-region-id
```
1. Usa il comando [delete-function](https://docs.aws.amazon.com/cli/latest/reference/lambda/delete-function.html) per eliminare la funzione hook Lambda.
```
aws lambda delete-function --function-name AfterAllowTestTraffic
```
1. Usa il [delete-log-group](https://docs.aws.amazon.com/cli/latest/reference/logs/delete-log-group.html)comando per eliminare il tuo CloudWatch gruppo di log.
```
aws logs delete-log-group --log-group-name /aws/lambda/AfterAllowTestTraffic
```