Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Tutorial: Implementación de un servicio de Amazon ECS con una prueba de validación
En este tutorial, aprenderá a utilizar una función de Lambda para validar parte de la implementación de una aplicación de Amazon ECS actualizada. En este tutorial se utilizan la CodeDeploy aplicación, el grupo de CodeDeploy implementación y la aplicación Amazon ECS en la que utilizó[Tutorial: Implementación de una aplicación en Amazon ECS](tutorial-ecs-deployment.md). Complete ese tutorial antes de comenzar este.
Para añadir una prueba de validación, primero debe implementar la prueba en una función de Lambda. A continuación, en el AppSpec archivo de despliegue, especifique la función Lambda para el enlace del ciclo de vida que desee probar. Si se produce un error en una prueba de validación, la implementación se detiene, se revisa y se marca como errónea. Si la prueba se realiza correctamente, la implementación continúa con el siguiente evento o enlace del ciclo de vida de la implementación.
Durante una implementación de Amazon ECS con pruebas de validación, CodeDeploy utiliza un balanceador de carga que está configurado con dos grupos objetivo: un detector de tráfico de producción y un detector de tráfico de prueba. En el siguiente diagrama se muestra cómo están relacionados el equilibrador de carga, los oyentes de producción y prueba, los grupos de destino y la aplicación de Amazon ECS antes de que comience la implementación. En este tutorial, se utiliza un equilibrador de carga de aplicación. También puede usar un equilibrador de carga de red.
![\[Las conexiones entre el Equilibrador de carga de aplicación o el Equilibrador de carga de red, los oyentes, los grupos de destino, el conjunto de tareas y el servicio de Amazon ECS.\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/images/codedeploy-ecs-deployment-step-1.png)
Durante una implementación de Amazon ECS, existen cinco enlaces de ciclo de vida para pruebas. En este tutorial se implementa una prueba durante el tercer enlace de implementación de ciclo de vida, `AfterAllowTestTraffic`. Para obtener más información, consulte [Lista de enlaces de eventos de ciclo de vida para una implementación de Amazon ECS](reference-appspec-file-structure-hooks.md#reference-appspec-file-structure-hooks-list-ecs). Después de una implementación correcta, el agente de escucha de tráfico de producción ofrece el tráfico al nuevo conjunto de tareas de sustitución y se termina el conjunto de tareas original. En el siguiente diagrama se muestra cómo están relacionados los recursos después de una implementación correcta. Para obtener más información, consulte [¿Qué sucede durante una implementación de Amazon ECS?](deployment-steps-ecs.md#deployment-steps-what-happens).
![\[Las conexiones entre el Equilibrador de carga de aplicación o el Equilibrador de carga de red, los oyentes, los grupos de destino y la tarea de sustitución establecida después de una implementación.\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/images/codedeploy-ecs-deployment-step-6.png)
**nota**
Si completa este tutorial, es posible que se le cobren cargos a su cuenta. AWS Estos incluyen posibles cargos por CodeDeploy, AWS Lambda, y CloudWatch. Para obtener más información, consulta [AWS CodeDeploy precios](https://aws.amazon.com/codedeploy/pricing/), [AWS Lambda precios](https://aws.amazon.com/lambda/pricing/) y [ CloudWatch precios de Amazon](https://aws.amazon.com/cloudwatch/pricing/).
**Topics**
+ [Requisitos previos](tutorial-ecs-with-hooks-prereqs.md)
+ [Paso 1: Creación de un oyente de prueba](tutorial-ecs-with-hooks-create-second-listener.md)
+ [Paso 2: Actualizar la aplicación de Amazon ECS](tutorial-ecs-with-hooks-update-the-ecs-application.md)
+ [Paso 3: Creación de una función de Lambda de enlace de ciclo de vida](tutorial-ecs-with-hooks-create-hooks.md)
+ [Paso 4: actualice AppSpec el archivo](tutorial-ecs-with-hooks-create-appspec-file.md)
+ [Paso 5: Utilice la CodeDeploy consola para implementar el servicio Amazon ECS](tutorial-ecs-with-hooks-deployment.md)
+ [Paso 6: Ver el resultado de la función de enlace Lambda en los registros CloudWatch](tutorial-ecs-with-hooks-view-cw-logs.md)
+ [Paso 7: limpiar](tutoria-ecs-with-hooks-clean-up.md)
# Requisitos previos
Para completar correctamente este tutorial, primero debe realizar el siguiente procedimiento:
+ Cumpla los requisitos previos de [Requisitos previos](tutorial-ecs-prereqs.md) para [Tutorial: Implementación de una aplicación en Amazon ECS](tutorial-ecs-deployment.md).
+ Realice los pasos que se indican en [Tutorial: Implementación de una aplicación en Amazon ECS](tutorial-ecs-deployment.md). Anote lo siguiente:
+ Nombre del balanceador de carga.
+ Los nombres de los grupos de destino.
+ El puerto utilizado por el agente de escucha del balanceador de carga.
+ El ARN del balanceador de carga. Puede utilizarlo para crear un nuevo agente de escucha.
+ El ARN de uno de los grupos de destino. Puede utilizarlo para crear un nuevo agente de escucha.
+ El grupo de CodeDeploy aplicaciones e implementaciones que cree.
+ El AppSpec archivo que crea y que utiliza la CodeDeploy implementación. Puede editar este archivo en este tutorial.
# Paso 1: Creación de un oyente de prueba
Una implementación de Amazon ECS con pruebas de validación requiere un segundo oyente. Este oyente se utiliza para ofrecer tráfico de prueba a la aplicación de Amazon ECS actualizada en un conjunto de tareas de sustitución. Las pruebas de validación se ejecutan en el tráfico de prueba.
El agente de escucha del tráfico de prueba puede utilizar cualquiera de los grupos de destino. Utilice el AWS CLI comando [create-listener](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-listener.html) para crear un segundo detector con una regla predeterminada que reenvíe el tráfico de prueba al puerto 8080. Utilice el ARN del balanceador de carga y el ARN de uno de los 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
```
# Paso 2: Actualizar la aplicación de Amazon ECS
En esta sección, actualizará la aplicación de Amazon ECS para que utilice una nueva revisión de su definición de tarea. Puede crear la nueva revisión y añadirle una actualización secundaria añadiendo una etiqueta.
**Para actualizar la definición de tarea, realice el siguiente procedimiento:**
1. Abra la consola clásica de Amazon ECS en [https://console.aws.amazon.com/ecs/](https://console.aws.amazon.com/ecs/).
1. En el panel de navegación, elija **Task Definitions**.
1. Seleccione la casilla de verificación de la definición de tarea utilizada por el servicio de Amazon ECS.
1. Elija **Create new revision** (Crear nueva revisión).
1. Realice una pequeña actualización de la definición de la tarea añadiendo una etiqueta. En la parte inferior de la página, en **Tags** (Etiquetas), cree una nueva etiqueta escribiendo un nuevo par de clave y valor.
1. Seleccione **Crear**. Debería ver que el número de revisión de la definición de la tarea se ha incrementado en uno.
1. Seleccione la pestaña **JSON**. Anote el valor de `taskDefinitionArn`. Su formato es el siguiente: `arn:aws:ecs:aws-region: account-id:task-definition/task-definition-family: task-definition-revision`. Este es el ARN de la definición de tarea actualizada.
# Paso 3: Creación de una función de Lambda de enlace de ciclo de vida
En esta sección, implementará una función de Lambda para el enlace de `AfterAllowTestTraffic` de la implementación de Amazon ECS. La función de Lambda ejecuta una prueba de validación antes de instalar la aplicación de Amazon ECS actualizada. En este tutorial, la función de Lambda devuelve `Succeeded`. Durante una implementación real, las pruebas de validación devuelven `Succeeded` o `Failed`, en función del resultado de la prueba de validación. También durante una implementación real, puede implementar una función de Lambda de prueba para uno o varios de los demás enlaces de eventos del ciclo de vida de la implementación de Amazon ECS (`BeforeInstall`, `AfterInstall`, `BeforeAllowTraffic`, y `AfterAllowTraffic`). Para obtener más información, consulte [Lista de enlaces de eventos de ciclo de vida para una implementación de Amazon ECS](reference-appspec-file-structure-hooks.md#reference-appspec-file-structure-hooks-list-ecs).
Se requiere un rol de IAM para crear la función de Lambda. El rol otorga a la función Lambda permiso para escribir en los CloudWatch registros y establecer el estado de un enlace de CodeDeploy ciclo de vida.
**Cómo crear un rol de IAM**
1. Abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. En el panel de navegación, seleccione **Roles (Roles)** y, a continuación, seleccione **Create role (Crear rol)**.
1. Cree un rol con las propiedades siguientes:
+ **Trusted entity** (Entidad de confianza): **AWS Lambda**.
+ **Permisos**: **AWSLambdaBasicExecutionRole**. Esto le otorga a la función Lambda permiso para escribir en los registros. CloudWatch
+ **Role name** (Nombre de rol): **`lambda-cli-hook-role`**.
Para obtener más información, consulte [Crear un rol AWS Lambda de ejecución](https://docs.aws.amazon.com/lambda/latest/dg/with-userapp.html#with-userapp-walkthrough-custom-events-create-iam-role).
1. Asocie el permiso `codedeploy:PutLifecycleEventHookExecutionStatus` al rol que ha creado. Esto otorga a sus funciones de Lambda permiso para establecer el estado de un enlace de CodeDeploy ciclo de vida durante una implementación. Para obtener más información, consulte [Añadir permisos de identidad de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html#add-policies-console) en la *Guía del AWS Identity and Access Management usuario* y [PutLifecycleEventHookExecutionStatus](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_PutLifecycleEventHookExecutionStatus.html)en la Referencia de la *CodeDeploy API*.
**Para crear una función de Lambda del enlace de `AfterAllowTestTraffic`**
1. Cree un archivo denominado `AfterAllowTestTraffic.js` con el siguiente contenido.
```
'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. Cree un paquete de implementación de Lambda.
```
zip AfterAllowTestTraffic.zip AfterAllowTestTraffic.js
```
1. Utilice el comando `create-function` para crear una función de Lambda para el enlace de `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 el ARN de la función de Lambda en la respuesta de `create-function`. Este ARN se utiliza cuando se actualiza el AppSpec archivo de la CodeDeploy implementación en el siguiente paso.
# Paso 4: actualice AppSpec el archivo
En esta sección, actualizas tu AppSpec archivo con una `Hooks` sección. En la sección `Hooks`, debe especificar una función de Lambda para el enlace de ciclo de vida `AfterAllowTestTraffic`.
**Para actualizar el AppSpec archivo**
1. Abra el AppSpec archivo [Paso 2: Crea el AppSpec archivo](tutorial-ecs-create-appspec-file.md) de archivo que creó en[Tutorial: Implementación de una aplicación en Amazon ECS](tutorial-ecs-deployment.md).
1. Actualice la propiedad `TaskDefinition` con el ARN de definición de tarea que anotó en [Paso 2: Actualizar la aplicación de Amazon ECS](tutorial-ecs-with-hooks-update-the-ecs-application.md).
1. Copia y pega la `Hooks` sección en tu AppSpec archivo de archivo. Actualice el ARN después de `AfterAllowTestTraffic` con el ARN de la función de Lambda que anotó en [Paso 3: Creación de una función de Lambda de enlace de 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. Guarde el AppSpec archivo y cárguelo en su bucket de S3.
# Paso 5: Utilice la CodeDeploy consola para implementar el servicio Amazon ECS
En esta sección, debe actualizar el grupo de implementaciones especificando el puerto para el agente de escucha de prueba. Este es el agente de escucha que creó en [Paso 1: Creación de un oyente de prueba](tutorial-ecs-with-hooks-create-second-listener.md). Durante la implementación, CodeDeploy ejecuta la prueba de validación durante el enlace de ciclo de vida de la implementación de `AfterAllowTestTraffic` utilizando el tráfico de prueba servido al conjunto de tareas de sustitución mediante el agente de escucha de prueba. La prueba de validación devuelve el resultado `Succeeded`, por lo que la implementación avanza con el siguiente evento del ciclo de vida de la implementación. En un escenario real, la función de prueba devuelve `Succeeded` o `Failed`.
**Para añadir un agente de escucha de prueba a su grupo de implementaciones, realice el siguiente procedimiento:**
1. Inicie sesión en Consola de administración de AWS y abra la CodeDeploy consola en [https://console.aws.amazon.com/codedeploy/](https://console.aws.amazon.com/codedeploy/).
1. En el panel de navegación, elija **Applications** (Aplicaciones).
1. Elija la aplicación que ha creado en [Tutorial: Implementación de una aplicación en Amazon ECS](tutorial-ecs-deployment.md). Si utilizó el nombre recomendado, es **ecs-demo-codedeploy-app**.
1. En **Deployment groups** (Grupos de implementaciones), elija el grupo de implementaciones que creó en [Tutorial: Implementación de una aplicación en Amazon ECS](tutorial-ecs-deployment.md). Si utilizó el nombre recomendado, es **ecs-demo-dg**.
1. Elija **Edit (Edición de)**.
1. En **Test listener port** (Puerto de agente de escucha de prueba), elija el puerto y el protocolo del agente de escucha de prueba que creó anteriormente en este tutorial. Debe ser **HTTP: 8080**.
1. Seleccione **Save changes (Guardar cambios)**.
**Para implementar la aplicación de Amazon ECS**
1. En la página de la consola del grupo de implementaciones, elija **Create deployment** (Crear implementación).
1. En **Grupo de implementación**, elija **ecs-demo-dg**.
1. En **Tipo de revisión**, elija **Mi aplicación está almacenada en Amazon S3**. En la **ubicación de la revisión**, introduzca el nombre del depósito y el AppSpec archivo de S3 (por ejemplo,**s3://my-s3-bucket/appspec.json**).
1. En **Revision file type** (Tipo de archivo de revisión), elija **.json** o **.yaml**, según corresponda.
1. En el cuadro **Deployment description** (Descripción de la implementación), especifique una descripción para la implementación (opcional).
1. Elija **Crear implementación**.
Puede monitorizar la implementación en **Deployment status** (Estado de implementación). Después de que el 100 % del tráfico de producción se dirija al conjunto de tareas de sustitución, puede elegir **Terminar conjunto de tareas original** para terminar inmediatamente el conjunto de tareas original. Si no elige **Terminate original task set** (Terminar conjunto de tareas original), el conjunto de tareas original termina después de la duración especificada al crear el grupo de implementaciones.
![\[La sección de estado de despliegue de la CodeDeploy consola.\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/images/ecs-tutorial-deployment-status-with-test-listener.png)
# Paso 6: Ver el resultado de la función de enlace Lambda en los registros CloudWatch
Si la CodeDeploy implementación se realiza correctamente, las pruebas de validación de las funciones de enlace de Lambda también lo son. Puede confirmarlo consultando el registro para ver la función de enlace en CloudWatch los registros.
1. Abre la CloudWatch consola en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. En el panel de navegación, elija **Logs (Registros)**. Debería ver un grupo de registros nuevo para la función de enlace de Lambda que especificó en el archivo AppSpec .
![\[El nuevo grupo de registros de la CloudWatch consola.\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/images/ecs-demo-cw-logs.png)
1. Elija el nuevo grupo de registros. Debería ser**/aws/lambda/AfterAllowTestTrafficHook**.
1. Elija el flujo de registros. Si ve más de un flujo de registros, elija el que tenga la fecha y la hora más recientes en **Last Event Time** (Hora del último evento).
1. Expanda los eventos del flujo de registro para confirmar que la función de enlace de Lambda escribió mensajes de éxito en el registro. A continuación se muestra cómo la función de enlace de Lambda se ha realizado correctamente.
![\[Los eventos del flujo de registros que muestra el enlace AfterAllowTraffic.\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/images/ecs-demo-cw-log-events.png)
# Paso 7: limpiar
Cuando termine este tutorial, debe limpiar los recursos asociados para evitar incurrir en cargos por recursos que no está utilizando. Los nombres de los recursos de este paso son los nombres sugeridos en este tutorial (por ejemplo, **ecs-demo-codedeploy-app** para el nombre de la CodeDeploy aplicación). Si utilizó nombres diferentes, asegúrese de usarlos en el borrado.
**Para borrar los recursos del tutorial, realice el siguiente procedimiento:**
1. Use el [delete-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/delete-deployment-group.html)comando para eliminar el grupo CodeDeploy de implementación.
```
aws deploy delete-deployment-group --application-name ecs-demo-deployment-group --deployment-group-name ecs-demo-dg --region aws-region-id
```
1. Utilice el comando [delete-application](https://docs.aws.amazon.com/cli/latest/reference/deploy/delete-application.html) para eliminar la CodeDeploy aplicación.
```
aws deploy delete-application --application-name ecs-demo-deployment-group --region aws-region-id
```
1. Utilice el comando [delete-function](https://docs.aws.amazon.com/cli/latest/reference/lambda/delete-function.html) para eliminar la función de enlace de Lambda.
```
aws lambda delete-function --function-name AfterAllowTestTraffic
```
1. Utilice el [delete-log-group](https://docs.aws.amazon.com/cli/latest/reference/logs/delete-log-group.html)comando para eliminar el grupo de CloudWatch registros.
```
aws logs delete-log-group --log-group-name /aws/lambda/AfterAllowTestTraffic
```