A continuación, añada un archivo de especificaciones de la aplicación (AppSpec archivo), un archivo con formato [YAML](http://www.yaml.org) que se utiliza para: CodeDeploy
+ Asignar los archivos de origen de la revisión de la aplicación a sus destinos en la instancia de Amazon EC2 de destino.
+ Especificar permisos personalizados para los archivos implementados.
+ Especificar los scripts que se van a ejecutar en la instancia de Amazon EC2 de destino durante la implementación.
El AppSpec archivo debe tener un nombre. `appspec.yml` Debe colocarse en el directorio raíz del código fuente de la aplicación. En este tutorial, el directorio raíz es `/tmp/WordPress`.
Mediante su editor de texto, cree un archivo denominado `appspec.yml`. Añada las líneas siguientes al archivo:
```
version: 0.0
os: linux
files:
- source: /
destination: /var/www/html/WordPress
hooks:
BeforeInstall:
- location: scripts/install_dependencies.sh
timeout: 300
runas: root
AfterInstall:
- location: scripts/change_permissions.sh
timeout: 300
runas: root
ApplicationStart:
- location: scripts/start_server.sh
- location: scripts/create_test_db.sh
timeout: 300
runas: root
ApplicationStop:
- location: scripts/stop_server.sh
timeout: 300
runas: root
```
CodeDeploy utiliza este AppSpec archivo para copiar todos los archivos de la `/tmp/WordPress` carpeta de la máquina de desarrollo a la `/var/www/html/WordPress` carpeta de la instancia Amazon EC2 de destino. Durante la implementación, CodeDeploy ejecuta los scripts especificados como `root` en la `/var/www/html/WordPress/scripts` carpeta de la instancia Amazon EC2 de destino en eventos específicos durante el ciclo de vida de la implementación, como **BeforeInstall** y. **AfterInstall** Si alguno de estos scripts tarda más de 300 segundos (5 minutos) en ejecutarse, CodeDeploy detiene la implementación y marca la implementación como fallida.
Para obtener más información sobre la configuración, consulte [CodeDeploy AppSpec referencia de archivo](reference-appspec-file.md).
**importante**
Las ubicaciones y el número de espacios entre cada uno de los elementos de este archivo son importantes. Si el espaciado es incorrecto, se produce CodeDeploy un error que puede ser difícil de depurar. Para obtener más información, consulte [AppSpec Espaciado de archivos](reference-appspec-file.md#reference-appspec-file-spacing).
# Paso 3: Cargue WordPress la aplicación en Amazon S3
Ahora preparará y cargará el contenido de origen en una ubicación desde la que CodeDeploy pueda desplegarlo. Las siguientes instrucciones explican cómo aprovisionar un bucket de Amazon S3, preparar los archivos de la revisión de la aplicación para el bucket, agrupar los archivos de la revisión y, a continuación, enviar la revisión al bucket.
**nota**
Aunque no se trata en este tutorial, puede utilizarla CodeDeploy para implementar aplicaciones desde GitHub los repositorios hasta las instancias. Para obtener más información, consulte [Integración CodeDeploy con GitHub](integrations-partners-github.md).
**Topics**
+ [Aprovisionar un bucket de Amazon S3](#tutorials-wordpress-upload-application-create-s3-bucket)
+ [Preparación de los archivos de la aplicación para el bucket](#tutorials-wordpress-upload-application-prepare-application-files)
+ [Agrupación de los archivos de la aplicación en un único archivo de almacenamiento y envío del archivo de almacenamiento](#tutorials-wordpress-upload-application-bundle-and-push-archive)
## Aprovisionar un bucket de Amazon S3
Cree un contenedor de almacenamiento o *bucket* en Amazon S3 o utilice un bucket existente. Asegúrese de que puede cargar la revisión en el bucket y que las instancias Amazon EC2 utilizadas en las implementaciones pueden descargar la revisión del bucket.
Puede usar la AWS CLI consola Amazon S3 o Amazon S3 APIs para crear un bucket de Amazon S3. Después de crear el bucket, asegúrese de que concede permisos de acceso al bucket y a su cuenta de AWS .
**nota**
Los nombres de los buckets deben ser únicos en Amazon S3 para todas AWS las cuentas. Si no puede utilizar **amzn-s3-demo-bucket**, pruebe otro nombre de bucket, por ejemplo, **amzn-s3-demo-bucket** seguido de un guion y sus iniciales o algún otro identificador único. A continuación, cuando aparezca **amzn-s3-demo-bucket** en este tutorial, asegúrese de sustituirlo por el nombre de su bucket.
El bucket de Amazon S3 debe crearse en la misma AWS región en la que se lanzan las instancias de Amazon EC2 de destino. Por ejemplo, si crea el bucket en la región Este de EE. UU. (Norte de Virginia), sus instancias de Amazon EC2 de destino deben lanzarse en la región Este de EE. UU. (Norte de Virginia).
**Topics**
+ [Para crear un bucket de Amazon S3 (CLI)](#tutorials-wordpress-upload-application-create-s3-bucket-cli)
+ [Para crear un bucket de Amazon S3 (consola)](#tutorials-wordpress-upload-application-create-s3-bucket-console)
+ [Otorgue permisos al bucket y a la AWS cuenta de Amazon S3](#tutorials-wordpress-upload-application-create-s3-bucket-grant-permissions)
### Para crear un bucket de Amazon S3 (CLI)
Llame al comando **mb** para crear un bucket de Amazon S3 denominado **amzn-s3-demo-bucket**:
```
aws s3 mb s3://amzn-s3-demo-bucket --region region
```
### Para crear un bucket de Amazon S3 (consola)
1. Abra la consola de Amazon S3 en [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. En la consola de Amazon S3, elija **Crear bucket**.
1. En el cuadro **Bucket name (Nombre del bucket)**, escriba un nombre para el bucket.
1. En la lista **Region (Región)**, elija la región de destino y, a continuación, seleccione **Create (Crear)**.
### Otorgue permisos al bucket y a la AWS cuenta de Amazon S3
Debe tener permisos para cargar en el bucket de Amazon S3. Puede especificar estos permisos mediante una política de bucket de Amazon S3. Por ejemplo, en la siguiente política de bucket de Amazon S3, el uso del carácter comodín (\$1) permite `111122223333` a la AWS cuenta cargar archivos en cualquier directorio del bucket de Amazon S3 denominado`amzn-s3-demo-bucket`:
```
{
"Statement": [
{
"Action": [
"s3:PutObject"
],
"Effect": "Allow",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*",
"Principal": {
"AWS": [
"111122223333"
]
}
}
]
}
```
Para ver el ID de su AWS cuenta, consulte [Cómo encontrar el ID de su AWS cuenta](https://docs.aws.amazon.com/IAM/latest/UserGuide/console_account-alias.html#FindingYourAWSId).
Ahora es un buen momento para comprobar que el bucket de Amazon S3 permite las solicitudes de descarga de cada instancia de Amazon EC2 participante. Puede especificarlos mediante una política de bucket de Amazon S3. Por ejemplo, en la siguiente política de bucket de Amazon S3, el carácter comodín (\$1) permite a cualquier instancia de Amazon EC2 asociada a un perfil de instancia de IAM que contenga el ARN `arn:aws:iam::444455556666:role/CodeDeployDemo` descargar desde cualquier directorio al bucket de Amazon S3 llamado `amzn-s3-demo-bucket`:
```
{
"Statement": [
{
"Action": [
"s3:Get*",
"s3:List*"
],
"Effect": "Allow",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*",
"Principal": {
"AWS": [
"arn:aws:iam::444455556666:role/CodeDeployDemo"
]
}
}
]
}
```
Para obtener información acerca de cómo generar y adjuntar una política de bucket de Amazon S3, consulte [Ejemplos de política de bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-bucket-policies.html).
Para obtener información acerca de cómo crear y adjuntar una política de IAM, consulte [Trabajo con políticas](https://docs.aws.amazon.com/IAM/latest/UserGuide/ManagingPolicies.html#AddingPermissions_Console).
## Preparación de los archivos de la aplicación para el bucket
Asegúrese de que los archivos de la WordPress aplicación, el AppSpec archivo y los scripts estén organizados en su máquina de desarrollo de forma similar a la siguiente:
```
/tmp/
|--WordPress/
|-- appspec.yml
|-- scripts/
| |-- change_permissions.sh
| |-- create_test_db.sh
| |-- install_dependencies.sh
| |-- start_server.sh
| |-- stop_server.sh
|-- wp-admin/
| |-- (various files...)
|-- wp-content/
| |-- (various files...)
|-- wp-includes/
| |-- (various files...)
|-- index.php
|-- license.txt
|-- readme.html
|-- (various files ending with .php...)
```
## Agrupación de los archivos de la aplicación en un único archivo de almacenamiento y envío del archivo de almacenamiento
Agrupe los archivos de la WordPress aplicación y el AppSpec archivo en un archivo de almacenamiento (conocido como *revisión* de la aplicación).
**nota**
Es posible que se cobre por almacenar objetos en un bucket y por transferir revisiones de la aplicación dentro y fuera de un bucket. Para obtener más información, consulte [Precios de Amazon S3](https://aws.amazon.com/s3/pricing/).
1. En el equipo de desarrollo, cambie a la carpeta en la que se almacenan los archivos:
```
cd /tmp/WordPress
```
**nota**
Si no cambia a esta carpeta, la agrupación del archivo comenzará en su carpeta actual. Por ejemplo, si la carpeta actual es `/tmp` en lugar de `/tmp/WordPress`, la agrupación comenzará con los archivos y subcarpetas de la carpeta `tmp`, lo que puede incluir algo más que la subcarpeta `WordPress`.
1. Llame al comando **create-application** para registrar una aplicación nueva denominada **WordPress\$1App**.
```
aws deploy create-application --application-name WordPress_App
```
1. Ejecute el comando CodeDeploy [push](https://docs.aws.amazon.com/cli/latest/reference/deploy/push.html) para agrupar los archivos, cargar las revisiones en Amazon S3 y registrar la información CodeDeploy sobre la revisión cargada, todo en una sola acción.
```
aws deploy push \
--application-name WordPress_App \
--s3-location s3://amzn-s3-demo-bucket/WordPressApp.zip \
--ignore-hidden-files
```
Este comando agrupa los archivos del directorio actual (excluyendo los archivos ocultos) en un único archivo denominado**WordPressApp.zip**, carga la revisión en el **amzn-s3-demo-bucket** depósito y registra la información CodeDeploy sobre la revisión cargada.
# Paso 4: Implemente su WordPress aplicación
Ahora implementa la revisión de la WordPress aplicación de muestra que cargó en Amazon S3. Puede utilizar la consola AWS CLI o la CodeDeploy consola para implementar la revisión y supervisar el progreso de la implementación. Una vez implementada correctamente la revisión de la aplicación, comprobará los resultados.
**Topics**
+ [Implemente la revisión de su aplicación con CodeDeploy](#tutorials-wordpress-deploy-application-create-deployment)
+ [Monitorización y solución de problemas de la implementación](#tutorials-wordpress-deploy-application-monitor)
+ [Comprobación de la implementación](#tutorials-wordpress-deploy-application-verify-deployment)
## Implemente la revisión de su aplicación con CodeDeploy
Utilice la consola AWS CLI o la consola para implementar la revisión de la aplicación.
**Topics**
+ [Para implementar la revisión de la aplicación (CLI)](#tutorials-wordpress-deploy-application-create-deployment-cli)
+ [Para implementar la revisión de la aplicación (consola)](#tutorials-wordpress-deploy-application-create-deployment-console)
### Para implementar la revisión de la aplicación (CLI)
1. La implementación necesita un grupo de implementaciones. Sin embargo, para crear el grupo de implementaciones, primero necesita un ARN de rol de servicio. Un rol de servicio es un rol de IAM que concede a un servicio permiso para actuar en su nombre. En este caso, el rol de servicio otorga CodeDeploy permiso para acceder a sus instancias de Amazon EC2 para expandir (leer) sus etiquetas de instancia de Amazon EC2.
Ya debe haber seguido las instrucciones de [Creación de un rol de servicio (CLI)](getting-started-create-service-role.md#getting-started-create-service-role-cli) para crear un rol de servicio. Para obtener el ARN del rol de servicio, consulte [Obtención del ARN del rol de servicio (CLI)](getting-started-create-service-role.md#getting-started-get-service-role-cli).
1. Ahora que tiene el ARN del rol de servicio, llame al comando **create-deployment-group** para crear un grupo de implementación denominado **WordPress\$1DepGroup** asociado a la aplicación **WordPress\$1App**, utilizando la etiqueta de Amazon EC2 denominada **CodeDeployDemo** y la configuración de implementación **CodeDeployDefault.OneAtATime**:
```
aws deploy create-deployment-group \
--application-name WordPress_App \
--deployment-group-name WordPress_DepGroup \
--deployment-config-name CodeDeployDefault.OneAtATime \
--ec2-tag-filters Key=Name,Value=CodeDeployDemo,Type=KEY_AND_VALUE \
--service-role-arn serviceRoleARN
```
**nota**
El [create-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment-group.html)comando permite crear activadores que provoquen el envío de notificaciones de Amazon SNS a los suscriptores del tema sobre eventos específicos en implementaciones e instancias. El comando también admite opciones para revertir automáticamente las implementaciones y configurar alarmas para detener las implementaciones cuando se cumplen los umbrales de monitoreo de CloudWatch las alarmas de Amazon. Los comandos para estas acciones no se incluyen en este tutorial.
1. Antes de crear una implementación, las instancias de su grupo de implementación deben tener el CodeDeploy agente instalado. Puede instalar el agente desde la línea de comandos con AWS Systems Manager mediante el comando siguiente:
```
aws ssm create-association \
--name AWS-ConfigureAWSPackage \
--targets Key=tag:Name,Values=CodeDeployDemo \
--parameters action=Install,name=AWSCodeDeployAgent \
--schedule-expression "cron(0 2 ? * SUN *)"
```
Este comando crea una asociación en Systems Manager State Manager que instalará el CodeDeploy agente e intentará actualizarlo todos los domingos a las 2:00 de la mañana. Para obtener más información sobre el CodeDeploy agente, consulte [Trabajar con el CodeDeploy agente](https://docs.aws.amazon.com/codedeploy/latest/userguide/codedeploy-agent.html). Para obtener más información acerca de Systems Manager, consulte [¿Qué es AWS Systems Manager?](https://docs.aws.amazon.com/systems-manager/latest/userguide/what-is-systems-manager.html).
1. Ejecute ahora el comando **create-deployment** para crear una implementación asociada a la aplicación **WordPress\$1App**, la configuración de implementación **CodeDeployDefault.OneAtATime** y el grupo de implementaciones **WordPress\$1DepGroup** utilizando la revisión de la aplicación **WordPressApp.zip** del bucket **amzn-s3-demo-bucket**:
```
aws deploy create-deployment \
--application-name WordPress_App \
--deployment-config-name CodeDeployDefault.OneAtATime \
--deployment-group-name WordPress_DepGroup \
--s3-location bucket=amzn-s3-demo-bucket,bundleType=zip,key=WordPressApp.zip
```
### Para implementar la revisión de la aplicación (consola)
1. Antes de usar la CodeDeploy consola para implementar la revisión de la aplicación, necesita un ARN de rol de servicio. Un rol de servicio es un rol de IAM que concede a un servicio permiso para actuar en su nombre. En este caso, el rol de servicio otorga CodeDeploy permiso para acceder a sus instancias de Amazon EC2 para expandir (leer) sus etiquetas de instancia de Amazon EC2.
Ya debe haber seguido las instrucciones de [Creación de un rol de servicio (consola)](getting-started-create-service-role.md#getting-started-create-service-role-console) para crear un rol de servicio. Para obtener el ARN del rol de servicio, consulte [Obtención del ARN del rol de servicio (consola)](getting-started-create-service-role.md#getting-started-get-service-role-console).
1. Ahora que tiene el ARN, utilice la CodeDeploy consola para implementar la revisión de la aplicación:
Inicie sesión Consola de administración de AWS y abra la CodeDeploy consola en [https://console.aws.amazon.com/codedeploy.](https://console.aws.amazon.com/codedeploy)
**nota**
Inicie sesión con el mismo usuario que configuró en [Empezar con CodeDeploy](getting-started-codedeploy.md).
1. En el panel de navegación, expanda **Implementar** y, después, elija **Aplicaciones**.
1. **En la lista de aplicaciones, selecciona WordPress \$1App.**
1. En la pestaña **Deployment groups (Grupos de implementaciones)**, elija **Create deployment group (Crear grupo de implementaciones)**.
1. En **Nombre de grupo de implementación**, escriba **WordPress\$1DepGroup**.
1. En **Tipo de implementación**, elija **Implementación local**.
1. En **Configuración de entorno**, elija la pestaña **Instancias de Amazon EC2**.
1. En **Configuración del agente con AWS Systems Manager**, mantenga los valores predeterminados.
1. En **Clave**, introduzca **Name**.
1. En **Valor**, escriba **CodeDeployDemo**.
**nota**
Después de escribir**CodeDeployDemo**, aparecerá un **1** en **Instancias coincidentes** para confirmar que CodeDeploy se ha encontrado una instancia de Amazon EC2 coincidente.
1. **En **Configuración de implementación**, elijaCodeDeployDefault. OneAtATime**.
1. En **ARN de rol de servicio**, elija el ARN del rol de servicio y seleccione **Crear grupo de implementación**.
1. Elija **Crear implementación**.
1. En **Grupo de implementación**, elija **WordPress\$1DepGroup**.
1. Junto a **Tipo de repositorio**, elija **Mi aplicación está almacenada en Amazon S3**. En **Ubicación de revisión**, introduzca la ubicación de la revisión de la WordPress aplicación de muestra que cargó anteriormente en Amazon S3. Para obtener la ubicación:
1. Abra la consola de Amazon S3 en [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. En la lista de buckets, elija **amzn-s3-demo-bucket** (o el nombre del bucket en el que cargó la revisión de la aplicación).
1. En la lista de objetos, elija **WordPressApp.zip.**
1. En la pestaña **Overview** (Información general), copie el valor del campo **Link** (Enlace) en el portapapeles.
Debe ser similar al siguiente:
**https://s3.amazonaws.com/amzn-s3-demo-bucket/WordPressApp.zip**
1. Vuelva a la CodeDeploy consola y, en la **ubicación de revisión**, pegue el valor del campo **Enlace**.
1. Si en la lista **File type** (Tipo de archivo) aparece un mensaje en el que se indica que no se ha podido detectar el tipo de archivo, seleccione **.zip**.
1. (Opcional) Escriba un comentario en el cuadro **Deployment description**.
1. **Expanda **Anulaciones de grupos de despliegues** y, en **Configuración de despliegue**, seleccioneCodeDeployDefault. OneAtATime**.
1. Elija **Iniciar la implementación**. En la página **Deployments** se mostrará información sobre la implementación que acaba de crear.
## Monitorización y solución de problemas de la implementación
Utilice la consola AWS CLI o la consola para supervisar y solucionar los problemas de la implementación.
**Topics**
+ [Para monitorizar y solucionar problemas en la implementación (CLI)](#tutorials-wordpress-deploy-application-monitor-cli)
+ [Para monitorizar y resolver problemas de la implementación (consola)](#tutorials-wordpress-deploy-application-monitor-console)
### Para monitorizar y solucionar problemas en la implementación (CLI)
1. Obtenga el ID de la implementación; para ello, ejecute el comando **list-deployments** para la aplicación **WordPress\$1App** y el grupo de implementaciones **WordPress\$1DepGroup**:
```
aws deploy list-deployments --application-name WordPress_App --deployment-group-name WordPress_DepGroup --query 'deployments' --output text
```
1. Llame al comando **get-deployment** con el ID de la implementación:
```
aws deploy get-deployment --deployment-id deploymentID --query 'deploymentInfo.status' --output text
```
1. El comando devuelve el estado general de la implementación. Si todo sale bien, el valor es `Succeeded`.
Si el estado general es `Failed`, puede ejecutar comandos como [list-deployment-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployment-instances.html) y [get-deployment-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/get-deployment-instance.html) para solucionar los problemas. Si desea conocer más opciones de solución de problemas, consulte [Análisis de archivos de registro para investigar los errores de implementación en instancias](troubleshooting-ec2-instances.md#troubleshooting-deploy-failures).
### Para monitorizar y resolver problemas de la implementación (consola)
En la página **Implementaciones** de la CodeDeploy consola, puede supervisar el estado de la implementación en la columna **Estado**.
Para obtener más información acerca de la implementación, sobre todo si el valor de la columna **Status** tiene un valor distinto de **Succeeded**:
1. En la tabla **Deployments (Implementaciones)**, elija el nombre de la implementación. Cuando se produce un error en una implementación, aparece un mensaje que describe el motivo del error.
1. En **Actividad de instancia**, aparece más información sobre la implementación. Cuando se una implementación falla, es posible que pueda determinar las instancias de Amazon EC2 afectadas y el paso del proceso en el que se ha producido el error.
1. Si desea continuar con la solución de problemas, puede aplicar una técnica como la descrita en [Visualización de los detalles de la instancia con CodeDeploy](instances-view-details.md). También puede analizar los archivos de registro de la implementación en una instancia de Amazon EC2. Para obtener más información, consulte [Análisis de archivos de registro para investigar los errores de implementación en instancias](troubleshooting-ec2-instances.md#troubleshooting-deploy-failures).
## Comprobación de la implementación
Una vez que la implementación se haya realizado correctamente, compruebe que WordPress la instalación funciona. Utilice la dirección DNS pública de la instancia de Amazon EC2 seguida de `/WordPress`, para ver el sitio en un navegador web. (Para obtener el valor de DNS público, en la consola de Amazon EC2, seleccione la instancia de Amazon EC2 y, en la pestaña **Descripción**, busque el valor **Public DNS**).
Por ejemplo, si la dirección DNS pública de la instancia de Amazon EC2 es **ec2-01-234-567-890.compute-1.amazonaws.com**, se usará la siguiente dirección URL:
```
http://ec2-01-234-567-890.compute-1.amazonaws.com/WordPress
```
Al ver el sitio en el navegador, debería ver una página de WordPress bienvenida similar a la siguiente:
![\[WordPress página de bienvenida\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/images/WordPress-Welcome-Page-013118.png)
Si su instancia de Amazon EC2 no tiene una regla de entrada HTTP agregada a su grupo de seguridad, la página de WordPress bienvenida no aparecerá. Si aparece un mensaje que indica que el servidor remoto no responde, asegúrese de que el grupo de seguridad de la instancia de Amazon EC2 tiene la regla de entrada. Para obtener más información, consulte [Adición de una regla de entrada que permite el tráfico HTTP hacia la instancia de Amazon EC2 de Amazon Linux o RHELAdición de una regla de entrada que permite el tráfico HTTP a la instancia de Amazon EC2 de Windows Server](tutorials-wordpress-launch-instance.md#tutorials-wordpress-launch-instance-add-inbound-rule).
# Paso 5: Actualizar y volver a implementar la aplicación WordPress
Ahora que has implementado correctamente la revisión de la aplicación, actualiza el WordPress código en la máquina de desarrollo y úsalo CodeDeploy para volver a implementar el sitio. Posteriormente, debería poder ver los cambios en el código en la instancia de Amazon EC2.
**Topics**
+ [Configura el sitio WordPress](#tutorials-wordpress-update-and-redeploy-application-configure-and-install)
+ [Modificación del sitio](#tutorials-wordpress-update-and-redeploy-application-modify-code)
+ [Nueva implementación del sitio](#tutorials-wordpress-update-and-redeploy-application-deploy-updates)
## Configura el sitio WordPress
Para ver los efectos del cambio de código, termine de configurar el WordPress sitio para que tenga una instalación completamente funcional.
1. Escriba la URL del sitio web en el navegador web. La URL es la dirección DNS pública de la instancia de Amazon EC2 con una extensión `/WordPress`. Para este WordPress sitio de ejemplo (y ejemplo de la dirección DNS pública de la instancia Amazon EC2), la URL es. **http://ec2-01-234-567-890.compute-1.amazonaws.com/WordPress**
1. Si aún no ha configurado el sitio, aparecerá la página de bienvenida WordPress predeterminada. Elija **¡Vamos\$1**.
1. En la página de configuración de la base de datos, escriba los siguientes valores para utilizar la base de datos MySQL predeterminada:
+ **Database Name (Nombre de la base de datos)**: **test**
+ **User Name (Nombre del usuario)**: **root**
+ **Contraseña**: déjela en blanco.
+ **Database Host (Host de base de datos)**: **localhost**
+ **Table Prefix (Prefijo de tabla)**: **wp\$1**
Elija **Submit** para configurar la base de datos.
1. Continúe con la configuración del sitio. En la página de **bienvenida**, rellena los valores que desees y selecciona **Instalar WordPress**. Cuando se haya completado la instalación, puede iniciar sesión en el panel.
**importante**
Durante el despliegue de la WordPress aplicación, el **change\$1permissions.sh** script actualizó los permisos de la `/tmp/WordPress` carpeta para que cualquiera pudiera escribir en ella. Este es un buen momento para ejecutar el siguiente comando para restringir los permisos, de forma que solo usted, el propietario, pueda escribir en ella:
```
chmod -R 755 /var/www/html/WordPress
```
## Modificación del sitio
Para modificar el WordPress sitio, vaya a la carpeta de la aplicación en su máquina de desarrollo:
```
cd /tmp/WordPress
```
Para modificar algunos colores del sitio, en el archivo `wp-content/themes/twentyfifteen/style.css`, utilice un editor de texto o **sed** para cambiar `#fff` a `#768331`.
En Linux u otros sistemas con **sed** GNU, utilice:
```
sed -i 's/#fff/#768331/g' wp-content/themes/twentyfifteen/style.css
```
En macOS, Unix u otros sistemas con **sed** BSD, utilice:
```
sed -i '' 's/#fff/#768331/g' wp-content/themes/twentyfifteen/style.css
```
## Nueva implementación del sitio
Ahora que ha modificado el código del sitio, utilice Amazon S3 CodeDeploy para volver a implementar el sitio.
Agrupe y cargue los cambios en Amazon S3, como se describe en [Agrupación de los archivos de la aplicación en un único archivo de almacenamiento y envío del archivo de almacenamiento](tutorials-wordpress-upload-application.md#tutorials-wordpress-upload-application-bundle-and-push-archive). (Cuando siga esas instrucciones, recuerde que no tiene que crear una aplicación). Asigne a la nueva revisión la misma clave que antes (**WordPressApp.zip**). Cárguela en el mismo bucket de Amazon S3 que creó anteriormente (por ejemplo, **amzn-s3-demo-bucket**).
Utilice la AWS CLI CodeDeploy consola o la CodeDeploy APIs para volver a implementar el sitio.
**Topics**
+ [Para volver implementar el sitio (CLI)](#tutorials-wordpress-update-and-redeploy-application-deploy-updates-cli)
+ [Para volver a implementar el sitio (consola)](#tutorials-wordpress-update-and-redeploy-application-deploy-updates-console)
### Para volver implementar el sitio (CLI)
Llame al comando **create-deployment** para crear una implementación basada en la revisión recién cargada. Utilice la aplicación **WordPress\$1App**, la configuración de implementación **CodeDeployDefault.OneAtATime**, el grupo de implementaciones **WordPress\$1DepGroup** y la revisión **WordPressApp.zip** del bucket **amzn-s3-demo-bucket**:
```
aws deploy create-deployment \
--application-name WordPress_App \
--deployment-config-name CodeDeployDefault.OneAtATime \
--deployment-group-name WordPress_DepGroup \
--s3-location bucket=amzn-s3-demo-bucket,bundleType=zip,key=WordPressApp.zip
```
Puede comprobar el estado de la implementación como se describe en [Monitorización y solución de problemas de la implementación](tutorials-wordpress-deploy-application.md#tutorials-wordpress-deploy-application-monitor).
Una vez CodeDeploy que haya redistribuido el sitio, vuelva a visitarlo en su navegador web para comprobar que se han cambiado los colores. (Puede que tenga que actualizar el navegador). Si los colores han cambiado, ¡enhorabuena\$1 Ha modificado y vuelto a implementar correctamente su sitio.
### Para volver a implementar el sitio (consola)
1. [Inicie sesión en /codedeploy Consola de administración de AWS y abra la CodeDeploy consola. https://console.aws.amazon.com](https://console.aws.amazon.com/codedeploy)
**nota**
Inicie sesión con el mismo usuario que configuró en [Empezar con CodeDeploy](getting-started-codedeploy.md).
1. En el panel de navegación, expanda **Implementar** y, después, elija **Aplicaciones**.
1. **En la lista de aplicaciones, selecciona WordPress \$1App.**
1. En la pestaña **Deployment groups (Grupos de implementaciones)**, elija **WordPress\$1DepGroup**.
1. Elija **Crear implementación**.
1. En la página **Create deployment**:
1. En **Deployment group (Grupo de implementación)**, elija **WordPress\$1DepGroup**.
1. En el área **Tipo de repositorio**, seleccione **Mi aplicación está almacenada en Amazon S3** y luego copie el enlace de Amazon S3 de la revisión en el cuadro **Ubicación de la revisión**. Para encontrar el valor del enlace:
1. En una pestaña diferente del navegador:
Inicie sesión en la consola de Amazon S3 Consola de administración de AWS y ábrala en [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
Vaya al archivo **amzn-s3-demo-bucket**, ábralo y elija la re visión **WordPressApp.zip**.
1. Si el panel **Propiedades** no se muestra en la consola de Amazon S3, elija el botón **Propiedades**.
1. En el panel de **propiedades**, copie el valor del campo **Enlace** en el cuadro **Ubicación de la revisión** de la CodeDeploy consola.
1. Si aparece un mensaje que indica que el tipo de archivo no se pudo detectar, elija **.zip**.
1. Deje el cuadro **Deployment description** en blanco.
1. **Expanda **Anulaciones de grupos** de despliegues y, en **Configuración de despliegue**, seleccioneCodeDeployDefault. OneAtATime**.
1. Elija **Iniciar la implementación**. En la página **Deployments** se mostrará información sobre la implementación que acaba de crear.
1. Puede comprobar el estado de la implementación como se describe en [Monitorización y solución de problemas de la implementación](tutorials-wordpress-deploy-application.md#tutorials-wordpress-deploy-application-monitor).
Una vez CodeDeploy que haya redistribuido el sitio, vuelva a visitarlo en su navegador web para comprobar que se han cambiado los colores. (Puede que tenga que actualizar el navegador). Si los colores han cambiado, ¡enhorabuena\$1 Ha modificado y vuelto a implementar correctamente su sitio.
# Paso 6: Limpiar WordPress la aplicación y los recursos relacionados
Ahora has realizado correctamente una actualización del WordPress código y has vuelto a implementar el sitio. Para evitar cargos recurrentes por los recursos que ha creado para este tutorial, debe eliminar:
+ Cualquier CloudFormation pila (o cierre cualquier instancia de Amazon EC2, si la creó fuera CloudFormation de ella).
+ Todos los buckets de Amazon S3.
+ La aplicación `WordPress_App` en CodeDeploy.
+ La asociación de administradores AWS Systems Manager estatales del CodeDeploy agente.
Puede utilizar Amazon S3 CloudFormation, Amazon EC2 y CodeDeploy las consolas, o AWS APIs para realizar la limpieza. AWS CLI
**Topics**
+ [Para limpiar los recursos (CLI)](#tutorials-wordpress-clean-up-cli)
+ [Para limpiar los recursos (consola)](#tutorials-wordpress-clean-up-console)
+ [Siguientes pasos](#tutorials-wordpress-clean-up-whats-next)
## Para limpiar los recursos (CLI)
1. Si usó nuestra CloudFormation plantilla para este tutorial, **delete-stack** ejecute el comando contra la pila nombrada. **CodeDeployDemoStack** Así terminará todas las instancias Amazon EC2 asociadas y eliminará todos los roles de IAM que haya creado la pila:
```
aws cloudformation delete-stack --stack-name CodeDeployDemoStack
```
1. Para eliminar el bucket de Amazon S3, llame al comando **rm** con el modificador **--recursive** para el bucket denominado **amzn-s3-demo-bucket**. Así eliminará el bucket y todos los objetos que contiene:
```
aws s3 rm s3://amzn-s3-demo-bucket --recursive --region region
```
1. Para eliminar la aplicación `WordPress_App`, realice una llamada al comando **delete-application**. Esto eliminará también todos los registros de grupo de implementaciones asociados y los registros de implementación de la aplicación:
```
aws deploy delete-application --application-name WordPress_App
```
1. Para eliminar la asociación de Systems Manager State Manager, llame al comando **delete-association**.
```
aws ssm delete-association --assocation-id association-id
```
Puedes obtenerla *association-id* llamando al **describe-association** comando.
```
aws ssm describe-association --name AWS-ConfigureAWSPackage --targets Key=tag:Name,Values=CodeDeployDemo
```
Si no usó la CloudFormation pila para este tutorial, **terminate-instances** ejecute el comando para terminar cualquier instancia de Amazon EC2 que haya creado manualmente. Indique el ID de la instancia de Amazon EC2 que desea terminar:
```
aws ec2 terminate-instances --instance-ids instanceId
```
## Para limpiar los recursos (consola)
Si utilizó nuestra CloudFormation plantilla para este tutorial, elimine la CloudFormation pila asociada.
1. Inicia sesión Consola de administración de AWS y abre la CloudFormation consola en [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. En el cuadro **Filtro**, escribe el nombre de la CloudFormation pila que creaste anteriormente (por ejemplo,**CodeDeployDemoStack**).
1. Seleccione la casilla junto al nombre de la pila. En el menú **Actions (Acciones)**, elija **Delete Stack (Eliminar pila)**.
CloudFormation elimina la pila, cierra todas las instancias de Amazon EC2 adjuntas y elimina todas las funciones de IAM correspondientes.
Para finalizar las instancias de Amazon EC2 que creó fuera de una CloudFormation pila:
1. Inicie sesión en la consola Amazon EC2 Consola de administración de AWS y ábrala en. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. En la lista **INSTANCES**, elija **Instances**.
1. En el campo de búsqueda, escriba el nombre de la instancia de Amazon EC2 que desee finalizar (por ejemplo, **CodeDeployDemo**) y, a continuación, pulse Intro.
1. Seleccione el nombre de la instancia de Amazon EC2.
1. En el menú **Actions**, seleccione **Instance State** y elija **Terminate**. Cuando se le pregunte, elija **Yes, Terminate**.
Repita estos pasos para cada instancia.
Para eliminar el bucket de Amazon S3:
1. Inicie sesión en la consola de Amazon S3 Consola de administración de AWS y ábrala en [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. En la lista de buckets, busque y seleccione el nombre del bucket de Amazon S3 que creó anteriormente (por ejemplo, **amzn-s3-demo-bucket**).
1. Para eliminar un bucket, primero debe eliminar su contenido. Seleccione todos los archivos del bucket, como **WordPressApp.zip**. En el menú **Actions**, elija **Delete**. Cuando se le pida confirmar la eliminación, elija **OK**.
1. Una vez vacío, puede eliminar el bucket. En la lista de buckets, elija la línea del bucket (pero no su nombre). Elija **Delete bucket** y cuando se le pida que confirme, seleccione **OK**.
Para eliminar la `WordPress_App` aplicación de CodeDeploy:
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).
**nota**
Inicie sesión con el mismo usuario que configuró en [Empezar con CodeDeploy](getting-started-codedeploy.md).
1. En el panel de navegación, expanda **Implementar** y, después, elija **Aplicaciones**.
1. **En la lista de aplicaciones, selecciona WordPress \$1App.**
1. En la página **Application details (Detalles de la aplicación)**, elija **Delete application (Eliminar aplicación)**.
1. Cuando se le solicite, introduzca el nombre de la aplicación para confirmar que desea eliminarla y seleccione **Delete (Eliminar)**.
Para eliminar la asociación de Systems Manager State Manager:
1. Abra la AWS Systems Manager consola en /systems-manager. https://console.aws.amazon.com
1. En el panel de navegación, elija **Administrador de estados**.
1. Elija la asociación que ha creado y, después, elija **Eliminar**.
## Siguientes pasos
Si ha llegado hasta aquí, ¡enhorabuena\$1 Ha completado correctamente una implementación de CodeDeploy, ha actualizado el código del sitio y lo ha vuelto a implementar.
# Tutorial: Implementación de una aplicación "Hello, World\$1" aplicación con CodeDeploy (Windows Server)
En este tutorial, implementa una única página web en una sola instancia Amazon EC2 de Windows Server que ejecuta Internet Information Services (IIS) como servidor web. Esta página web muestra un mensaje "Hello, World\$1".
¿No es lo que está buscando?
+ Para practicar la implementación en una instancia de Amazon EC2 de Amazon Linux o Red Hat Enterprise Linux (RHEL) en su lugar, consulte [Tutorial: Implementación WordPress en una instancia de Amazon EC2 (Amazon Linux o Red Hat Enterprise Linux y Linux, macOS o Unix)](tutorials-wordpress.md).
+ Para practicar la implementación en una instancia on-premises, consulte [Tutorial: Implemente una aplicación en una instancia local con CodeDeploy (Windows Server, Ubuntu Server o Red Hat Enterprise Linux)](tutorials-on-premises-instance.md).
Los pasos de este tutorial se presentan desde una perspectiva de Windows. Aunque puede completar la mayoría de estos pasos en un equipo local que ejecuta Linux, macOS o Unix, debe adaptar los pasos en los que se usan rutas de directorio basadas en Windows, como `c:\temp`. Además, si desea conectarse a la instancia de Amazon EC2, necesita una aplicación cliente que pueda conectarse mediante el Protocolo de escritorio remoto (RDP) a la instancia de Amazon EC2 que ejecuta Windows Server. (Windows incluye una aplicación cliente de conexión RDP de forma predeterminada).
Antes de empezar este tutorial, debe cumplir los requisitos previos, como configurar el usuario[Empezar con CodeDeploy](getting-started-codedeploy.md), instalar o actualizar el perfil de instancia de IAM y crear un perfil de instancia de IAM y un rol de servicio. AWS CLI
**Topics**
+ [Paso 1: Lanzar una instancia de Amazon EC2 de Windows Server](tutorials-windows-launch-instance.md)
+ [Paso 2: Configurar el contenido de origen para implementarlo en la instancia de Amazon EC2 de Windows Server](tutorials-windows-configure-content.md)
+ [Paso 3: Cargar la aplicación "Hello, World\$1" en Amazon S3](tutorials-windows-upload-application.md)
+ [Paso 4: Implementar la aplicación Hello World.](tutorials-windows-deploy-application.md)
+ [Paso 5: Actualizar y volver a implementar su aplicación "Hello, World\$1"](tutorials-windows-update-and-redeploy-application.md)
+ [Paso 6: Limpiar la aplicación de "Hello, World\$1" y sus recursos relacionados](tutorials-windows-clean-up.md)
# Paso 1: Lanzar una instancia de Amazon EC2 de Windows Server
Para implementar la aplicación Hello World CodeDeploy, necesita una instancia de Amazon EC2 que ejecute Windows Server.
Siga las instrucciones en [Cree una instancia de Amazon EC2 para CodeDeploy](instances-ec2-create.md). Cuando esté listo para asignar una etiqueta de instancia de Amazon EC2 a la instancia, asegúrese de especificar la clave de etiqueta **Name** y el valor de etiqueta **CodeDeployDemo**. (Si especifica otra clave u otro valor de etiqueta, las instrucciones de [Paso 4: Implementar la aplicación Hello World.](tutorials-windows-deploy-application.md) pueden producir resultados inesperados).
Una vez que haya lanzado la instancia de Amazon EC2, vuelva a esta página y continúe con la sección siguiente. No continúe en [Cree una aplicación con CodeDeploy](applications-create.md) como paso siguiente.
## Conexión con la instancia de Amazon EC2
Una vez lanzada la instancia de Amazon EC2, siga estas instrucciones para practicar la conexión a la instancia.
**nota**
En estas instrucciones se supone que está trabajando con Windows y con la aplicación cliente de conexión a escritorio de Windows. Para obtener más información, consulte [Conexión con la instancia de Windows mediante RDP](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/connecting_to_windows_instance.html). Es posible que necesite adaptar estas instrucciones para otros sistemas operativos u otras aplicaciones cliente de conexión RDP.
1. Inicie sesión en la consola Amazon EC2 Consola de administración de AWS y ábrala en. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. En el panel de navegación, bajo **Instances**, elija **Instances**.
1. Busque su instancia de Windows Server en la lista y selecciónela.
1. Elija **Conectar**.
1. Elija **Obtener contraseña** y, a continuación, elija **Seleccionar archivo**.
1. Busque y seleccione el archivo de par de claves de la instancia de Amazon EC2 asociado a la instancia Amazon EC2 de Windows Server y, a continuación, elija **Abrir**.
1. Elija **Descifrar contraseña**. Apunte la contraseña que se muestra. La necesitará en el paso 10.
1. Elija **Download Remote Desktop File (Descargar archivo de escritorio remoto)** y abra el archivo.
1. Si se le pide conectarse a pesar de que el editor de la conexión remota no pueda identificarse, hágalo.
1. Escriba la contraseña que ha anotado en el paso 7 y continúe. (Si la aplicación cliente de conexión RDP solicita un nombre de usuario, escriba **Administrator**).
1. Si se le pide que se conecte a pesar de que la identidad del equipo remoto no pueda verificarse, hágalo.
1. Después de haberse conectado, se muestra el escritorio de la instancia de Amazon EC2 que ejecuta Windows Server.
1. Ahora puede desconectar de la instancia de Amazon EC2.
**aviso**
No interrumpa ni termine la instancia. De lo contrario, no CodeDeploy podrá realizar la implementación en ella.
## Adición de una regla de entrada que permite el tráfico HTTP a la instancia de Amazon EC2 de Windows Server
El siguiente paso confirma que la instancia de Amazon EC2 tiene un puerto HTTP abierto para que se pueda ver la página web implementada en la instancia de Amazon EC2 de Windows Server en un navegador.
1. Inicie sesión en la consola Amazon EC2 Consola de administración de AWS y ábrala en. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. Elija **Instancias** y, luego, elija su instancia.
1. En la pestaña **Descripción**, en **Grupos de seguridad**, elija **ver reglas de entrada**.
Debe aparecer una lista de reglas en el grupo de seguridad con un aspecto similar al siguiente:
```
Security Groups associated with i-1234567890abcdef0
Ports Protocol Source launch-wizard-N
22 tcp 0.0.0.0/0 ✔
```
1. En **Grupos de seguridad**, elija el grupo de seguridad de la instancia de Amazon EC2. Podría llamarse **launch-wizard-*N***. La ***N*** del nombre es un número asignado al grupo de seguridad cuando se creó la instancia.
Elija la pestaña **Inbound** (Reglas entrantes). El grupo de seguridad de la instancia está configurado correctamente si se ve una regla con los siguientes valores:
+ **Tipo**: HTTP
+ **Protocolo**: TCP
+ **Rango de puertos**: 80
+ **Fuente**: 0.0.0.0/0
1. Si no ve ninguna regla con estos valores, utilice los procedimientos de [Agregar reglas a un grupo de seguridad](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html#adding-security-group-rule) para agregarlas a una nueva regla de seguridad.
# Paso 2: Configurar el contenido de origen para implementarlo en la instancia de Amazon EC2 de Windows Server
Ha llegado el momento de configurar el contenido de origen de la aplicación para tener algo que implementar en la instancia de Amazon EC2. En este tutorial, implementará una única página web en la instancia de Amazon EC2 que ejecuta Windows Server, que a su vez ejecutará Internet Information Services (IIS) como su servidor web. Esta página web mostrará un mensaje "Hello, World\$1" simple.
**Topics**
+ [Crear la página web](#tutorials-windows-configure-content-download-code)
+ [Crear un script para ejecutar la aplicación](#tutorials-windows-configure-content-create-scripts)
+ [Añadir un archivo de especificación de la aplicación](#tutorials-windows-configure-content-add-appspec-file)
## Crear la página web
1. Cree un subdirectorio (subcarpeta) denominado `HelloWorldApp` en su carpeta `c:\temp` y, a continuación, pase a esa carpeta.
```
mkdir c:\temp\HelloWorldApp
cd c:\temp\HelloWorldApp
```
**nota**
La ubicación de la carpeta no tiene por qué ser `c:\temp` ni el nombre de la subcarpeta, `HelloWorldApp`. Si utiliza otra ubicación u otro nombre de subcarpeta, asegúrese de utilizarlos en este tutorial.
1. Utilice un editor de texto para crear un archivo dentro de la carpeta. Nombre el archivo `index.html`.
```
notepad index.html
```
1. Añada el siguiente código HTML al archivo y guárdelo.
```
Hello, World!
Hello, World!
You have successfully deployed an application using CodeDeploy
```
## Crear un script para ejecutar la aplicación
A continuación, creará un script que CodeDeploy se utilizará para configurar el servidor web en la instancia Amazon EC2 de destino.
1. En la misma subcarpeta donde se guarda el archivo `index.html`, utilice un editor de texto para crear otro archivo. Nombre el archivo `before-install.bat`.
```
notepad before-install.bat
```
1. Añada el siguiente código de script de procesamiento por lotes al archivo y, a continuación, guárdelo.
```
REM Install Internet Information Server (IIS).
c:\Windows\Sysnative\WindowsPowerShell\v1.0\powershell.exe -Command Import-Module -Name ServerManager
c:\Windows\Sysnative\WindowsPowerShell\v1.0\powershell.exe -Command Install-WindowsFeature Web-Server
```
## Añadir un archivo de especificación de la aplicación
A continuación, añadirá un archivo de especificaciones de la aplicación (AppSpec archivo) además de la página web y el archivo de script por lotes. El AppSpec archivo es un archivo con formato [YAML](http://www.yaml.org) que se utiliza para: CodeDeploy
+ Asignar los archivos de origen de la revisión de la aplicación a sus destinos en la instancia.
+ Especificar los scripts que deben ejecutarse en la instancia durante la implementación.
El AppSpec archivo debe tener un nombre. `appspec.yml` Debe ir en la carpeta raíz de código fuente de la aplicación.
1. Utilice un editor de texto para crear otro archivo en la misma carpeta en la que se encuentran `index.html` y `before-install.bat`. Nombre el archivo `appspec.yml`.
```
notepad appspec.yml
```
1. Añada el siguiente código YAML al archivo y guárdelo.
```
version: 0.0
os: windows
files:
- source: \index.html
destination: c:\inetpub\wwwroot
hooks:
BeforeInstall:
- location: \before-install.bat
timeout: 900
```
CodeDeploy utilizará este AppSpec archivo para copiar el `index.html` archivo de la carpeta raíz del código fuente de la aplicación a la `c:\inetpub\wwwroot` carpeta de la instancia Amazon EC2 de destino. Durante la implementación, CodeDeploy ejecutará el script `before-install.bat` por lotes en la instancia Amazon EC2 de destino durante el evento del ciclo de vida de la **BeforeInstall** implementación. Si este script tarda más de 900 segundos (15 minutos) en ejecutarse, CodeDeploy detendrá la implementación y marcará la implementación en la instancia de Amazon EC2 como fallida.
Para obtener más información sobre la configuración, consulte [CodeDeploy AppSpec referencia de archivo](reference-appspec-file.md).
**importante**
Las ubicaciones y el número de espacios entre cada uno de los elementos de este archivo son importantes. Si el espaciado es incorrecto, se CodeDeploy generará un error que puede ser difícil de depurar. Para obtener más información, consulte [AppSpec Espaciado de archivos](reference-appspec-file.md#reference-appspec-file-spacing).
# Paso 3: Cargar la aplicación "Hello, World\$1" en Amazon S3
Ahora preparará y cargará su contenido fuente en una ubicación desde la que CodeDeploy pueda desplegarlo. Las siguientes instrucciones explican cómo aprovisionar un bucket de Amazon S3, preparar los archivos de la revisión de la aplicación para el bucket, agrupar los archivos de la revisión y, a continuación, enviar la revisión al bucket.
**nota**
Aunque no se trata en este tutorial, puede utilizarla CodeDeploy para implementar aplicaciones desde GitHub los repositorios hasta las instancias. Para obtener más información, consulte [Integración CodeDeploy con GitHub](integrations-partners-github.md).
**Topics**
+ [Aprovisionar un bucket de Amazon S3](#tutorials-windows-upload-application-create-s3-bucket)
+ [Preparación de los archivos de la aplicación para el bucket](#tutorials-windows-upload-application-prepare-application-files)
+ [Agrupación de los archivos de la aplicación en un único archivo de almacenamiento y envío del archivo de almacenamiento](#tutorials-windows-upload-application-bundle-and-push-archive)
## Aprovisionar un bucket de Amazon S3
Cree un contenedor de almacenamiento o *bucket* en Amazon S3 o utilice un bucket existente. Asegúrese de que puede cargar la revisión en el bucket y que las instancias Amazon EC2 utilizadas en las implementaciones pueden descargar la revisión del bucket.
Puede usar la AWS CLI consola Amazon S3 o Amazon S3 APIs para crear un bucket de Amazon S3. Después de crear el bucket, asegúrese de que concede permisos de acceso al bucket y a su usuario de CodeDeploy.
**nota**
Los nombres de los buckets deben ser únicos en Amazon S3 para todas AWS las cuentas. Si no puede utilizar **amzn-s3-demo-bucket**, pruebe otro nombre de bucket, por ejemplo, **amzn-s3-demo-bucket** seguido de un guion y sus iniciales o algún otro identificador único. A continuación, cuando aparezca **amzn-s3-demo-bucket** en este tutorial, asegúrese de sustituirlo por el nombre de su bucket.
El bucket de Amazon S3 debe crearse en la misma AWS región en la que se lanzaron las instancias de Amazon EC2 de destino. Por ejemplo, si crea el bucket en la región Este de EE. UU. (Norte de Virginia), sus instancias de Amazon EC2 de destino deben lanzarse en la región Este de EE. UU. (Norte de Virginia).
**Topics**
+ [Para crear un bucket de Amazon S3 (CLI)](#tutorials-windows-upload-application-create-s3-bucket-cli)
+ [Para crear un bucket de Amazon S3 (consola)](#tutorials-windows-upload-application-create-s3-bucket-console)
+ [Conceda permisos al bucket de Amazon S3 y a su AWS cuenta](#tutorials-windows-upload-application-create-s3-bucket-grant-permission)
### Para crear un bucket de Amazon S3 (CLI)
Llame al comando **mb** para crear un bucket de Amazon S3 denominado **amzn-s3-demo-bucket**:
```
aws s3 mb s3://amzn-s3-demo-bucket --region region
```
### Para crear un bucket de Amazon S3 (consola)
1. Abra la consola de Amazon S3 en [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. En la consola de Amazon S3, elija **Crear bucket**.
1. En el cuadro **Bucket name (Nombre del bucket)**, escriba un nombre para el bucket.
1. En la lista **Region (Región)**, elija la región de destino y, a continuación, seleccione **Create (Crear)**.
### Conceda permisos al bucket de Amazon S3 y a su AWS cuenta
Debe tener permisos para cargar en el bucket de Amazon S3. Puede especificar estos permisos mediante una política de bucket de Amazon S3. Por ejemplo, en la siguiente política de bucket de Amazon S3, el uso del carácter comodín (\$1) permite `111122223333` a la AWS cuenta cargar archivos en cualquier directorio del bucket de Amazon S3 denominado`amzn-s3-demo-bucket`:
```
{
"Statement": [
{
"Action": [
"s3:PutObject"
],
"Effect": "Allow",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*",
"Principal": {
"AWS": [
"111122223333"
]
}
}
]
}
```
Para ver el ID de su AWS cuenta, consulte [Cómo encontrar el ID de su AWS cuenta](https://docs.aws.amazon.com/IAM/latest/UserGuide/console_account-alias.html#FindingYourAWSId).
Ahora es un buen momento para comprobar que el bucket de Amazon S3 permite las solicitudes de descarga de cada instancia de Amazon EC2 participante. Puede especificarlos mediante una política de bucket de Amazon S3. Por ejemplo, en la siguiente política de bucket de Amazon S3, el carácter comodín (\$1) permite a cualquier instancia de Amazon EC2 asociada a un perfil de instancia de IAM que contenga el ARN `arn:aws:iam::444455556666:role/CodeDeployDemo` descargar desde cualquier directorio al bucket de Amazon S3 llamado `amzn-s3-demo-bucket`:
```
{
"Statement": [
{
"Action": [
"s3:Get*",
"s3:List*"
],
"Effect": "Allow",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*",
"Principal": {
"AWS": [
"arn:aws:iam::444455556666:role/CodeDeployDemo"
]
}
}
]
}
```
Para obtener información acerca de cómo generar y adjuntar una política de bucket de Amazon S3, consulte [Ejemplos de política de bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-bucket-policies.html).
El usuario CodeDeploy administrativo en el que creó también [Paso 1: Configurar](getting-started-setting-up.md) debe tener permiso para cargar la revisión en el bucket de Amazon S3. Una forma de especificarlo es mediante una política de IAM, que se añade al conjunto de permisos del usuario o a un rol de IAM (que se deja que el usuario asuma). La siguiente política de IAM permite que el usuario cargue revisiones en cualquier lugar del bucket de Amazon S3 denominado `amzn-s3-demo-bucket`:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":["s3:PutObject"],
"Resource":"arn:aws:s3:::amzn-s3-demo-bucket/*"
}
]
}
```
------
Para obtener información sobre cómo crear una política de IAM, consulte [Creación de políticas de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) en la *Guía del usuario de IAM*. Para obtener información sobre cómo añadir una política a un conjunto de permisos, consulte [Crear un conjunto de permisos](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtocreatepermissionset.html) en la *Guía del usuario de AWS IAM Identity Center *.
## Preparación de los archivos de la aplicación para el bucket
Asegúrese de que la página web, el AppSpec archivo y el script estén organizados en su máquina de desarrollo de la siguiente manera:
```
c:\
|-- temp\
|--HelloWorldApp\
|-- appspec.yml
|-- before-install.bat
|-- index.html
```
## Agrupación de los archivos de la aplicación en un único archivo de almacenamiento y envío del archivo de almacenamiento
Agrupe los archivos en un archivo de almacenamiento (se denomina una *revisión* de la aplicación).
**nota**
Es posible que se cobre por almacenar objetos en un bucket y por transferir revisiones de la aplicación dentro y fuera de un bucket. Para obtener más información, consulte [Precios de Amazon S3](https://aws.amazon.com/s3/pricing/).
1. En el equipo de desarrollo, cambie a la carpeta en la que se almacenan los archivos:
```
cd c:\temp\HelloWorldApp
```
**nota**
Si no cambia a esta carpeta, la agrupación del archivo comenzará en su carpeta actual. Por ejemplo, si la carpeta actual es `c:\temp` en lugar de `c:\temp\HelloWorldApp`, la agrupación comenzará con los archivos y subcarpetas de la carpeta `c:\temp`, lo que puede incluir algo más que la subcarpeta `HelloWorldApp`.
1. Ejecute el **create-application** comando para registrar una nueva aplicación cuyo nombre **HelloWorld\$1App** sea CodeDeploy:
```
aws deploy create-application --application-name HelloWorld_App
```
1. Ejecute el comando CodeDeploy [push](https://docs.aws.amazon.com/cli/latest/reference/deploy/push.html) para agrupar los archivos, cargar las revisiones en Amazon S3 y registrar la información CodeDeploy sobre la revisión cargada, todo en una sola acción.
```
aws deploy push --application-name HelloWorld_App --s3-location s3://amzn-s3-demo-bucket/HelloWorld_App.zip --ignore-hidden-files
```
Este comando agrupa los archivos del directorio actual (excluyendo los archivos ocultos) en un único archivo denominado`HelloWorld_App.zip`, carga la revisión en el **amzn-s3-demo-bucket** depósito y registra la información CodeDeploy sobre la revisión cargada.
# Paso 4: Implementar la aplicación Hello World.
Ahora implementa la revisión de la aplicación Hello, World\$1 de ejemplo que ha cargado en Amazon S3. Utilice la consola AWS CLI o la CodeDeploy consola para implementar la revisión y supervisar el progreso de la implementación. Una vez implementada correctamente la revisión de la aplicación, comprobará los resultados.
**Topics**
+ [Implemente la revisión de su aplicación con CodeDeploy](#tutorials-windows-deploy-application-create-deployment)
+ [Monitorización y solución de problemas de la implementación](#tutorials-windows-deploy-application-monitor)
+ [Comprobación de la implementación](#tutorials-windows-deploy-application-verify)
## Implemente la revisión de su aplicación con CodeDeploy
Puede implementar su aplicación con la CLI o la consola.
**Topics**
+ [Para implementar la revisión de la aplicación (CLI)](#tutorials-windows-deploy-application-create-deployment-cli)
+ [Para implementar la revisión de la aplicación (consola)](#tutorials-windows-deploy-application-create-deployment-console)
### Para implementar la revisión de la aplicación (CLI)
1. En primer lugar, la implementación necesita un grupo de implementaciones. Sin embargo, para crear el grupo de implementaciones, primero necesita un ARN de rol de servicio. Un rol de servicio es un rol de IAM que concede a un servicio permiso para actuar en su nombre. En este caso, el rol de servicio otorga CodeDeploy permiso para acceder a sus instancias de Amazon EC2 para expandir (leer) sus etiquetas de instancia de Amazon EC2.
Ya debe haber seguido las instrucciones de [Creación de un rol de servicio (CLI)](getting-started-create-service-role.md#getting-started-create-service-role-cli) para crear un rol de servicio. Para obtener el ARN del rol de servicio, consulte [Obtención del ARN del rol de servicio (CLI)](getting-started-create-service-role.md#getting-started-get-service-role-cli).
1. Ahora que tiene el ARN, llame al comando **create-deployment-group** para crear un grupo de implementación denominado **HelloWorld\$1DepGroup** asociado a la aplicación **HelloWorld\$1App**, utilizando la etiqueta de instancia de Amazon EC2 denominada **CodeDeployDemo** y la configuración de implementación denominada **CodeDeployDefault.OneAtATime** con el ARN del rol de servicio:
```
aws deploy create-deployment-group --application-name HelloWorld_App --deployment-group-name HelloWorld_DepGroup --deployment-config-name CodeDeployDefault.OneAtATime --ec2-tag-filters Key=Name,Value=CodeDeployDemo,Type=KEY_AND_VALUE --service-role-arn serviceRoleARN
```
**nota**
El [create-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment-group.html)comando permite crear activadores que provoquen el envío de notificaciones de Amazon SNS a los suscriptores del tema sobre eventos específicos en implementaciones e instancias. El comando también admite opciones para revertir automáticamente las implementaciones y configurar alarmas para detener las implementaciones cuando se cumplen los umbrales de monitoreo de CloudWatch las alarmas de Amazon. Los comandos para estas acciones no se incluyen en este tutorial.
1. Antes de crear una implementación, las instancias de su grupo de implementación deben tener el CodeDeploy agente instalado. Puede instalar el agente desde la línea de comandos con AWS Systems Manager mediante el comando siguiente:
```
aws ssm create-association --name AWS-ConfigureAWSPackage --targets Key=tag:Name,Values=CodeDeployDemo --parameters action=Install,name=AWSCodeDeployAgent --schedule-expression "cron(0 2 ? * SUN *)"
```
Este comando crea una asociación en Systems Manager State Manager que instalará el CodeDeploy agente e intentará actualizarlo todos los domingos a las 2:00 de la mañana. Para obtener más información sobre el CodeDeploy agente, consulte [Trabajar con el CodeDeploy agente](https://docs.aws.amazon.com/codedeploy/latest/userguide/codedeploy-agent.html). Para obtener más información acerca de Systems Manager, consulte [¿Qué es AWS Systems Manager?](https://docs.aws.amazon.com/systems-manager/latest/userguide/what-is-systems-manager.html).
1. Ejecute ahora el comando **create-deployment** para crear una implementación asociada a la aplicación **HelloWorld\$1App**, la configuración de implementación **CodeDeployDefault.OneAtATime** y el grupo de implementaciones **HelloWorld\$1DepGroup** utilizando la revisión de la aplicación **HelloWorld\$1App.zip** del bucket **amzn-s3-demo-bucket**:
```
aws deploy create-deployment --application-name HelloWorld_App --deployment-config-name CodeDeployDefault.OneAtATime --deployment-group-name HelloWorld_DepGroup --s3-location bucket=amzn-s3-demo-bucket,bundleType=zip,key=HelloWorld_App.zip
```
### Para implementar la revisión de la aplicación (consola)
1. Antes de usar la CodeDeploy consola para implementar la revisión de la aplicación, necesita un ARN de rol de servicio. Un rol de servicio es un rol de IAM que concede a un servicio permiso para actuar en su nombre. En este caso, el rol de servicio otorga CodeDeploy permiso para acceder a sus instancias de Amazon EC2 para expandir (leer) sus etiquetas de instancia de Amazon EC2.
Ya debe haber seguido las instrucciones de [Creación de un rol de servicio (consola)](getting-started-create-service-role.md#getting-started-create-service-role-console) para crear un rol de servicio. Para obtener el ARN del rol de servicio, consulte [Obtención del ARN del rol de servicio (consola)](getting-started-create-service-role.md#getting-started-get-service-role-console).
1. Ahora que tiene el ARN, puede usar la CodeDeploy consola para implementar la revisión de la aplicación.
Inicie sesión en la CodeDeploy consola Consola de administración de AWS y ábrala en [https://console.aws.amazon.com/codedeploy](https://console.aws.amazon.com/codedeploy).
**nota**
Inicie sesión con el mismo usuario que configuró en [Empezar con CodeDeploy](getting-started-codedeploy.md).
1. En el panel de navegación, expanda **Implementar** y, después, elija **Aplicaciones**.
1. **Elige \$1AppHelloWorld.**
1. En la pestaña **Deployment groups (Grupos de implementaciones)**, elija **Create deployment group (Crear grupo de implementaciones)**.
1. En **Nombre de grupo de implementación**, escriba **HelloWorld\$1DepGroup**.
1. En **Service Role (Rol de servicio)**, elija el nombre del rol de servicio.
1. En **Tipo de implementación**, elija **Local**.
1. En **Configuración de entorno**, elija la pestaña **Instancias de Amazon EC2**.
1. En la **configuración del agente con AWS Systems Manager**, mantenga los valores predeterminados.
1. En **Clave**, introduzca **Name**.
1. En **Valor**, escriba **CodeDeployDemo**.
1. **En **Configuración de despliegue**, elijaCodeDeployDefault. OneAtATime**.
1. En **Equilibrador de carga**, anule la selección de **Habilitar equilibración de carga**.
1. Elija **Crear grupo de implementación**.
1. Elija **Crear implementación**.
1. En el **grupo de implementación**, elija **HelloWorld\$1 DepGroup**
1. En **Tipo de revisión**, elija **Mi aplicación está almacenada en Amazon S3** y, a continuación, en **Ubicación de la revisión**, escriba la ubicación de la revisión de la aplicación de ejemplo Hello, World\$1 que cargó previamente en Amazon S3. Para obtener la ubicación:
1. Abra la consola de Amazon S3 en [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. En la lista de buckets, elija **amzn-s3-demo-bucket** (o el nombre del bucket en el que cargó la revisión de la aplicación).
1. En la lista de objetos, elija **HelloWorld\$1App.zip**.
1. En la pestaña **Overview (Información general)**, elija **Copy path (Ruta de copia)**.
1. Vuelva a la CodeDeploy consola y, en **Ubicación de revisión**, pegue el valor del campo **Enlace**.
1. En **Revision file type (Tipo de archivo de revisión)**, elija **.zip**.
1. (Opcional) Escriba un comentario en **Deployment description (Descripción de implementación)**.
1. Elija **Crear implementación**. En la página **Deployments** se mostrará información sobre la implementación que acaba de crear.
## Monitorización y solución de problemas de la implementación
Utilice la consola AWS CLI o la consola para supervisar y solucionar los problemas de la implementación.
**Topics**
+ [Para monitorizar y solucionar problemas en la implementación (CLI)](#tutorials-windows-deploy-application-monitor-cli)
+ [Para monitorizar y resolver problemas de la implementación (consola)](#tutorials-windows-deploy-application-monitor-console)
### Para monitorizar y solucionar problemas en la implementación (CLI)
1. Obtenga el ID de la implementación; para ello, ejecute el comando **list-deployments** para la aplicación **HelloWorld\$1App** y el grupo de implementaciones **HelloWorld\$1DepGroup**:
```
aws deploy list-deployments --application-name HelloWorld_App --deployment-group-name HelloWorld_DepGroup --query "deployments" --output text
```
1. Llame al comando **get-deployment** con el ID de la implementación:
```
aws deploy get-deployment --deployment-id deploymentID --query "deploymentInfo.status" --output text
```
1. El comando devuelve el estado general de la implementación. Si todo sale bien, el valor es `Succeeded`.
Si el estado general es `Failed`, puede ejecutar comandos como [list-deployment-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployment-instances.html) y [get-deployment-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/get-deployment-instance.html) para solucionar los problemas. Si desea conocer más opciones de solución de problemas, consulte [Análisis de archivos de registro para investigar los errores de implementación en instancias](troubleshooting-ec2-instances.md#troubleshooting-deploy-failures).
### Para monitorizar y resolver problemas de la implementación (consola)
En la página **Implementaciones** de la CodeDeploy consola, puede supervisar el estado de la implementación en la columna **Estado**.
Para obtener más información acerca de la implementación, sobre todo si el valor de la columna **Status** tiene un valor distinto de **Succeeded**:
1. En la tabla **Deployments (Implementaciones)**, elija el ID de implementación. Cuando se produce un error en una implementación, aparece un mensaje que describe el motivo del error en la página de detalles de la implementación.
1. Aparece más información sobre las instancias de la implementación. Cuando se una implementación falla, es posible que pueda determinar las instancias de Amazon EC2 afectadas y el paso del proceso en el que se ha producido el error.
1. Si desea realizar más resolución de problemas, puede utilizar una técnica como [Visualización de los detalles de la instancia con CodeDeploy](instances-view-details.md). También puede analizar los archivos de registro de la implementación en una instancia de Amazon EC2. Para obtener más información, consulte [Análisis de archivos de registro para investigar los errores de implementación en instancias](troubleshooting-ec2-instances.md#troubleshooting-deploy-failures).
## Comprobación de la implementación
Después que la implementación se realiza correctamente, verifique que funciona la instalación. Utilice la dirección de DNS público de la instancia de Amazon EC2 para ver la página web en un navegador web. (Para obtener el valor de DNS público, en la consola de Amazon EC2, seleccione la instancia de Amazon EC2 y, en la pestaña **Descripción**, busque el valor **Public DNS**).
Por ejemplo, si la dirección DNS pública de la instancia de Amazon EC2 es **ec2-01-234-567-890.compute-1.amazonaws.com**, se usará la siguiente dirección URL:
```
http://ec2-01-234-567-890.compute-1.amazonaws.com
```
Si la operación se realiza correctamente, debería ver una página web Hello, World\$1.
# Paso 5: Actualizar y volver a implementar su aplicación "Hello, World\$1"
Una vez que hayas implementado correctamente la revisión de la aplicación, actualiza el código de la página web en la máquina de desarrollo y úsala CodeDeploy para volver a implementar el sitio. Una vez implementada nuevamente la revisión, debe poder ver los cambios en el código en la instancia de Amazon EC2.
**Topics**
+ [Modificar la página web](#tutorials-windows-update-and-redeploy-application-modify-code)
+ [Nueva implementación del sitio](#tutorials-windows-update-and-redeploy-application-deploy-updates)
## Modificar la página web
1. Vaya a la subcarpeta `c:\temp\HelloWorldApp` y use un editor de texto para modificar el archivo `index.html`:
```
cd c:\temp\HelloWorldApp
notepad index.html
```
1. Revise el contenido del archivo `index.html` para cambiar el color de fondo y parte del texto de la página web y, a continuación, guarde el archivo:
```
Hello Again, World!
Hello Again, World!
You have successfully deployed a revision of an application using CodeDeploy
```
## Nueva implementación del sitio
Ahora que ha modificado el código, utilice Amazon S3 CodeDeploy para volver a implementar la página web.
Agrupe y cargue los cambios en Amazon S3, como se describe en [Agrupación de los archivos de la aplicación en un único archivo de almacenamiento y envío del archivo de almacenamiento](tutorials-windows-upload-application.md#tutorials-windows-upload-application-bundle-and-push-archive). (Cuando siga esas instrucciones, recuerde que no tiene que crear una nueva aplicación). Asigne a la nueva revisión la misma clave que antes (**HelloWorld\$1App.zip**). Cárguela en el mismo bucket de Amazon S3 que creó anteriormente (por ejemplo, **amzn-s3-demo-bucket**).
Utilice la consola AWS CLI o la CodeDeploy consola para volver a implementar el sitio.
**Topics**
+ [Para volver implementar el sitio (CLI)](#tutorials-windows-update-and-redeploy-application-deploy-updates-cli)
+ [Para volver a implementar el sitio (consola)](#tutorials-windows-update-and-redeploy-application-deploy-updates-console)
### Para volver implementar el sitio (CLI)
Ejecute el comando **create-deployment** para crear una implementación basada en la revisión que ha cargado, utilizando también la aplicación **HelloWorld\$1App**, la configuración de implementación **CodeDeployDefault.OneAtATime**, el grupo de implementaciones **HelloWorld\$1DepGroup** y la revisión de la aplicación **HelloWorld\$1App.zip** del bucket **amzn-s3-demo-bucket**:
```
aws deploy create-deployment --application-name HelloWorld_App --deployment-config-name CodeDeployDefault.OneAtATime --deployment-group-name HelloWorld_DepGroup --s3-location bucket=amzn-s3-demo-bucket,bundleType=zip,key=HelloWorld_App.zip
```
Puede comprobar el estado de la nueva implementación como se describe en [Monitorización y solución de problemas de la implementación](tutorials-windows-deploy-application.md#tutorials-windows-deploy-application-monitor).
Cuando CodeDeploy haya redistribuido el sitio, vuelva a visitarlo en su navegador web para comprobar que se han cambiado el color de fondo y el texto de la página web. (Puede que tenga que actualizar el navegador). Si el color de fondo y el texto se han modificado, ¡enhorabuena\$1 Ha modificado y ha vuelto a implementar su sitio.
### Para volver a implementar el sitio (consola)
1. [Inicie sesión en Consola de administración de AWS y abra la CodeDeploy consola en /codedeploy. https://console.aws.amazon.com](https://console.aws.amazon.com/codedeploy)
**nota**
Inicie sesión con el mismo usuario que configuró en [Empezar con CodeDeploy](getting-started-codedeploy.md).
1. En el panel de navegación, elija **Applications (Aplicaciones)**.
1. **En la lista de **aplicaciones**, elija HelloWorld \$1App.**
1. En la pestaña **Deployments (Implementaciones)**, elija **Create deployment (Crear implementación)**.
1. En la lista **de grupos de despliegues**, elija **HelloWorld\$1 DepGroup**.
1. En **Ubicación de la revisión**, introduzca el enlace de Amazon S3 de la revisión.
Para encontrar el valor del enlace:
1. Inicie sesión en la consola de Amazon S3 Consola de administración de AWS y ábrala en [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
Vaya al archivo **amzn-s3-demo-bucket**, ábralo y elija la revisión, **HelloWorld\$1App.zip**, en la consola de Amazon S3.
1. Si el panel **Propiedades** no se muestra en la consola de Amazon S3, elija el botón **Propiedades**.
1. En el panel **Properties (Propiedades)**, copie el valor del campo **Link (Enlace)**.
1. Regrese a la CodeDeploy consola y, a continuación, pegue el enlace en la **ubicación de revisión**.
1. En **Revision file type (Tipo de archivo de revisión)**, si aparece un mensaje en el que se indica que no se ha podido detectar el tipo de archivo, elija **.zip**.
1. Deje **Deployment description (Descripción de implementación)** en blanco.
1. **Expanda las **anulaciones de grupos de despliegues** En la lista **de configuraciones de despliegue**, seleccioneCodeDeployDefault. OneAtATime**y, a continuación, elija **Crear despliegue**.
Puede comprobar el estado de la implementación como se describe en [Monitorización y solución de problemas de la implementación](tutorials-windows-deploy-application.md#tutorials-windows-deploy-application-monitor).
Cuando CodeDeploy haya vuelto a implementar el sitio, vuelva a visitarlo en su navegador web para comprobar que el color de fondo y el texto de la página web han cambiado. (Puede que tenga que actualizar el navegador). Si el color de fondo y el texto se han modificado, ¡enhorabuena\$1 Ha modificado y ha vuelto a implementar su sitio.
# Paso 6: Limpiar la aplicación de "Hello, World\$1" y sus recursos relacionados
Ha actualizado el código de "Hello, World\$1" correctamente e implementado de nuevo el sitio. Para evitar cargos recurrentes por los recursos que ha creado para completar este tutorial, debe eliminar:
+ Cualquier CloudFormation pila (o cierre cualquier instancia de Amazon EC2, si la creó fuera CloudFormation de ella).
+ Todos los buckets de Amazon S3.
+ La aplicación `HelloWorld_App` en CodeDeploy.
+ La asociación de administradores AWS Systems Manager estatales del CodeDeploy agente.
Puede utilizar Amazon S3 CloudFormation, Amazon EC2 y CodeDeploy las consolas, o AWS APIs para realizar la limpieza. AWS CLI
**Topics**
+ [Para limpiar los recursos (CLI)](#tutorials-windows-clean-up-cli)
+ [Para limpiar los recursos (consola)](#tutorials-windows-clean-up-console)
+ [Siguientes pasos](#tutorials-windows-clean-up-whats-next)
## Para limpiar los recursos (CLI)
1. Si usó la CloudFormation pila para este tutorial, elimine la pila ejecutando el **delete-stack** comando correspondiente a la pila nombrada. **CodeDeployDemoStack** Esto termina todas las instancias de Amazon EC2 vinculadas y elimina todos los roles de IAM asociados creados originalmente por la pila.
```
aws cloudformation delete-stack --stack-name CodeDeployDemoStack
```
1. Para eliminar el bucket de Amazon S3, llame al comando **rm** con el modificador **--recursive** para el bucket denominado **amzn-s3-demo-bucket**. Así elimina el bucket y todos los objetos que contiene.
```
aws s3 rm s3://amzn-s3-demo-bucket --recursive --region region
```
1. Para eliminar la `HelloWorld_App` aplicación CodeDeploy, ejecuta el **delete-application** comando. Esto elimina todos los registros de grupo de implementaciones asociados y los registros de implementación de la aplicación.
```
aws deploy delete-application --application-name HelloWorld_App
```
1. Para eliminar la asociación de Systems Manager State Manager, llame al comando **delete-association**.
```
aws ssm delete-association --assocation-id association-id
```
Puede obtenerlo *association-id* llamando al **describe-association** comando.
```
aws ssm describe-association --name AWS-ConfigureAWSPackage --targets Key=tag:Name,Values=CodeDeployDemo
```
1. Si no usó la CloudFormation pila para este tutorial, **terminate-instances** ejecute el comando para terminar las instancias de Amazon EC2 que creó manualmente. Indique el ID de la instancia de Amazon EC2 que desea terminar.
```
aws ec2 terminate-instances --instance-ids instanceId
```
## Para limpiar los recursos (consola)
Si utilizó nuestra CloudFormation plantilla para este tutorial, elimine la CloudFormation pila asociada.
1. Inicia sesión Consola de administración de AWS y abre la CloudFormation consola en [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. En el cuadro de búsqueda, escribe el nombre de la CloudFormation pila (por ejemplo,**CodeDeployDemoStack**).
1. Seleccione la casilla junto al nombre de la pila.
1. En el menú **Actions (Acciones)**, elija **Delete Stack (Eliminar pila)**. Esto elimina la pila, termina todas las instancias de Amazon EC2 asociadas y elimina todos los roles de IAM asociados.
Para finalizar las instancias de Amazon EC2 que creó fuera de una CloudFormation pila:
1. Inicie sesión en la consola Amazon EC2 Consola de administración de AWS y ábrala en. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. En el área **Instances**, elija **Instances**.
1. En el campo de búsqueda, escriba el nombre de la instancia de Amazon EC2 que desee eliminar y, a continuación, pulse **Intro**.
1. Seleccione la instancia de Amazon EC2.
1. Elija **Acciones**, seleccione **Estado de la instancia** y elija **Terminar**. Cuando se le pregunte, elija **Yes, Terminate**. Repita estos pasos para todas las instancias de Amazon EC2.
Para eliminar el bucket de Amazon S3:
1. Inicie sesión en la consola de Amazon S3 Consola de administración de AWS y ábrala en [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. En la lista de buckets, busque y seleccione el nombre del bucket de Amazon S3 (por ejemplo, **amzn-s3-demo-bucket**).
1. Para eliminar un bucket, primero debe eliminar su contenido. Seleccione todos los archivos del bucket, como **HelloWorld\$1App.zip**. En el menú **Actions**, elija **Delete**. Cuando se le pida confirmar la eliminación, elija **OK**.
1. Una vez vacío, puede eliminar el bucket. En la lista de buckets, elija la línea del bucket (pero no su nombre). Elija **Delete bucket** y cuando se le pida que confirme, seleccione **OK**.
Para eliminar la `HelloWorld_App` aplicación de CodeDeploy:
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)
**nota**
Inicie sesión con el mismo usuario que configuró en [Empezar con CodeDeploy](getting-started-codedeploy.md).
1. En el panel de navegación, expanda **Implementar** y, después, elija **Aplicaciones**.
1. Elija **`HelloWorld_App`**.
1. Elija **Eliminar aplicación**.
1. Cuando se le pregunte, escriba **Delete** y, a continuación, elija **Delete (Eliminar)**.
Para eliminar la asociación de Systems Manager State Manager:
1. Abra la AWS Systems Manager consola en /systems-manager. https://console.aws.amazon.com
1. En el panel de navegación, elija **Administrador de estados**.
1. Elija la asociación que ha creado y, después, elija **Eliminar**.
## Siguientes pasos
Si ha llegado aquí, significa que ha completado correctamente una implementación con. CodeDeploy ¡Enhorabuena\$1
# Tutorial: Implemente una aplicación en una instancia local con CodeDeploy (Windows Server, Ubuntu Server o Red Hat Enterprise Linux)
Este tutorial lo ayuda a adquirir experiencia CodeDeploy al guiarlo a través de la implementación de una revisión de aplicación de muestra en una única instancia local (es decir, un dispositivo físico que no es una instancia de Amazon EC2) que ejecute Windows Server, Ubuntu Server o Red Hat Enterprise Linux (RHEL). Para obtener información sobre las instancias locales y cómo funcionan con ellas, consulte. CodeDeploy [Trabajar con instancias locales para CodeDeploy](instances-on-premises.md)
¿No es lo que está buscando?
+ Para practicar la implementación en una instancia de Amazon EC2 con Amazon Linux o RHEL, consulte [Tutorial: Implementación WordPress en una instancia de Amazon EC2 (Amazon Linux o Red Hat Enterprise Linux y Linux, macOS o Unix)](tutorials-wordpress.md).
+ Para practicar la implementación en una instancia de Amazon EC2 con Windows Server, consulte [Tutorial: Implementación de una aplicación "Hello, World\$1" aplicación con CodeDeploy (Windows Server)](tutorials-windows.md).
**Topics**
+ [Requisitos previos](tutorials-on-premises-instance-prerequisites.md)
+ [Paso 1: Configurar la instancia en las instalaciones](tutorials-on-premises-instance-1-configure-instance.md)
+ [Paso 2: Crear una revisión de aplicación de ejemplo](tutorials-on-premises-instance-2-create-sample-revision.md)
+ [Paso 3: Empaquetado y carga de la revisión de aplicación en Amazon S3](tutorials-on-premises-instance-3-bundle-sample-revision.md)
+ [Paso 4: Implementar la revisión de la aplicación](tutorials-on-premises-instance-4-deploy-sample-revision.md)
+ [Paso 5: Comprobar la implementación](tutorials-on-premises-instance-5-verify-deployment.md)
+ [Paso 6: Limpiar los recursos](tutorials-on-premises-instance-6-clean-up-resources.md)
# Requisitos previos
Antes de comenzar este tutorial, debe cumplir los requisitos previos[Empezar con CodeDeploy](getting-started-codedeploy.md), que incluyen configurar un usuario, instalar o actualizar el AWS CLI rol de servicio y crear un rol de servicio. No es necesario crear un perfil de instancia de IAM como se describe en los requisitos previos. Las instancias en las instalaciones no utilizan perfiles de instancia de IAM.
El dispositivo físico que configurará como instancia on-premises debe emplear uno de los sistemas operativos indicados en [Sistemas operativos compatibles con el agente CodeDeploy](codedeploy-agent.md#codedeploy-agent-supported-operating-systems).
# Paso 1: Configurar la instancia en las instalaciones
Antes de implementar en la instancia en las instalaciones, debe configurarla. Siga las instrucciones de [Trabajar con instancias locales para CodeDeploy](instances-on-premises.md) y, a continuación, vuelva a esta página.
## Instale el agente CodeDeploy
Tras configurar la instancia local, siga los pasos para las instancias locales que se indican en [Instalar el CodeDeploy agente](https://docs.aws.amazon.com/codedeploy/latest/userguide/codedeploy-agent-operations-install.html) y vuelva a esta página.
# Paso 2: Crear una revisión de aplicación de ejemplo
En este paso, creará una revisión de aplicación de ejemplo para implementarla en la instancia en las instalaciones.
Dado que es difícil conocer el software y las características que ya están instalados -o que las políticas de su organización permiten instalar- en la instancia en las instalaciones, la revisión de aplicación de ejemplo que incluimos aquí usa simplemente scripts por lotes (en Windows Server) o scripts de intérpretes de comandos (en Ubuntu Server y RHEL) para escribir archivos de texto en una ubicación de la instancia en las instalaciones. Se escribe un archivo para cada uno de los diversos eventos del ciclo de vida de la CodeDeploy implementación, incluidos los eventos de **instalación**, **AfterInstall**ApplicationStart****, y. **ValidateService** Durante el evento del ciclo de vida de la **BeforeInstall**implementación, se ejecutará un script para eliminar los archivos antiguos escritos durante las implementaciones anteriores de este ejemplo y crear una ubicación en la instancia local en la que escribir los nuevos archivos.
**nota**
La implementación de la revisión de aplicación de ejemplo puede fallar si se da cualquiera de las siguientes circunstancias:
El usuario que inicia el CodeDeploy agente en la instancia local no tiene permiso para ejecutar scripts.
El usuario no tiene permiso para crear o eliminar carpetas en las ubicaciones indicadas en los scripts.
El usuario no tiene permiso para crear archivos de texto en las ubicaciones indicadas en los scripts.
**nota**
Si ha configurado una instancia de Windows Server y desea implementar un ejemplo diferente, puede ser conveniente usar el indicado en [Paso 2: Configurar el contenido de origen para implementarlo en la instancia de Amazon EC2 de Windows Server](tutorials-windows-configure-content.md) en el tutorial [Tutorial: Implementación de una aplicación "Hello, World\$1" aplicación con CodeDeploy (Windows Server)](tutorials-windows.md).
Si ha configurado una instancia de RHEL y desea implementar un ejemplo diferente, puede ser conveniente usar el indicado en [Paso 2: Configurar el contenido fuente para implementarlo en la instancia de Amazon EC2 de Amazon Linux o Red Hat Enterprise Linux](tutorials-wordpress-configure-content.md) en el tutorial [Tutorial: Implementación WordPress en una instancia de Amazon EC2 (Amazon Linux o Red Hat Enterprise Linux y Linux, macOS o Unix)](tutorials-wordpress.md).
En la actualidad, no hay ningún ejemplo alternativo para Ubuntu Server.
1. En el equipo de desarrollo, cree un subdirectorio (subcarpeta) con el nombre `CodeDeployDemo-OnPrem` para almacenar los archivos de la revisión de aplicación de ejemplo y, a continuación, sitúese en esa subcarpeta. En este ejemplo, supondremos que va a utilizar la carpeta `c:\temp` como la carpeta raíz para Windows Server o la carpeta `/tmp` como la carpeta raíz para Ubuntu Server y RHEL. Si utiliza una carpeta diferente, asegúrese de indicarla en lugar de la anterior en todo el tutorial:
Para Windows:
```
mkdir c:\temp\CodeDeployDemo-OnPrem
cd c:\temp\CodeDeployDemo-OnPrem
```
Para Linux, macOS o Unix:
```
mkdir /tmp/CodeDeployDemo-OnPrem
cd /tmp/CodeDeployDemo-OnPrem
```
1. En la raíz de la subcarpeta `CodeDeployDemo-OnPrem`, utilice en editor de texto para crear dos archivos con los nombres `appspec.yml` e `install.txt`:
`appspec.yml` para Windows Server:
```
version: 0.0
os: windows
files:
- source: .\install.txt
destination: c:\temp\CodeDeployExample
hooks:
BeforeInstall:
- location: .\scripts\before-install.bat
timeout: 900
AfterInstall:
- location: .\scripts\after-install.bat
timeout: 900
ApplicationStart:
- location: .\scripts\application-start.bat
timeout: 900
ValidateService:
- location: .\scripts\validate-service.bat
timeout: 900
```
`appspec.yml` para Ubuntu Server y RHEL:
```
version: 0.0
os: linux
files:
- source: ./install.txt
destination: /tmp/CodeDeployExample
hooks:
BeforeInstall:
- location: ./scripts/before-install.sh
timeout: 900
AfterInstall:
- location: ./scripts/after-install.sh
timeout: 900
ApplicationStart:
- location: ./scripts/application-start.sh
timeout: 900
ValidateService:
- location: ./scripts/validate-service.sh
timeout: 900
```
Para obtener más información sobre AppSpec los archivos, consulte [Añadir un archivo de especificaciones de la aplicación a una revisión de CodeDeploy](application-revisions-appspec-file.md) y[CodeDeploy AppSpec referencia de archivo](reference-appspec-file.md).
`install.txt`:
```
The Install deployment lifecycle event successfully completed.
```
1. En la raíz de la subcarpeta `CodeDeployDemo-OnPrem`, cree una subcarpeta `scripts` y sitúese en ella:
Para Windows:
```
mkdir c:\temp\CodeDeployDemo-OnPrem\scripts
cd c:\temp\CodeDeployDemo-OnPrem\scripts
```
Para Linux, macOS o Unix:
```
mkdir -p /tmp/CodeDeployDemo-OnPrem/scripts
cd /tmp/CodeDeployDemo-OnPrem/scripts
```
1. En la raíz de la subcarpeta `scripts`, utilice un editor de texto para crear cuatro archivos con los nombres `before-install.bat`, `after-install.bat`, `application-start.bat` y `validate-service.bat` para Windows Server, o `before-install.sh`, `after-install.sh`, `application-start.sh` y `validate-service.sh` para Ubuntu Server y RHEL:
Para Windows Server:
`before-install.bat`:
```
set FOLDER=%HOMEDRIVE%\temp\CodeDeployExample
if exist %FOLDER% (
rd /s /q "%FOLDER%"
)
mkdir %FOLDER%
```
`after-install.bat`:
```
cd %HOMEDRIVE%\temp\CodeDeployExample
echo The AfterInstall deployment lifecycle event successfully completed. > after-install.txt
```
`application-start.bat`:
```
cd %HOMEDRIVE%\temp\CodeDeployExample
echo The ApplicationStart deployment lifecycle event successfully completed. > application-start.txt
```
`validate-service.bat`:
```
cd %HOMEDRIVE%\temp\CodeDeployExample
echo The ValidateService deployment lifecycle event successfully completed. > validate-service.txt
```
Para Ubuntu Server y RHEL:
`before-install.sh`:
```
#!/bin/bash
export FOLDER=/tmp/CodeDeployExample
if [ -d $FOLDER ]
then
rm -rf $FOLDER
fi
mkdir -p $FOLDER
```
`after-install.sh`:
```
#!/bin/bash
cd /tmp/CodeDeployExample
echo "The AfterInstall deployment lifecycle event successfully completed." > after-install.txt
```
`application-start.sh`:
```
#!/bin/bash
cd /tmp/CodeDeployExample
echo "The ApplicationStart deployment lifecycle event successfully completed." > application-start.txt
```
`validate-service.sh`:
```
#!/bin/bash
cd /tmp/CodeDeployExample
echo "The ValidateService deployment lifecycle event successfully completed." > validate-service.txt
unset FOLDER
```
1. Solo para Ubuntu Server y RHEL, asegúrese de que los cuatro scripts de intérpretes de comandos tengan permisos de ejecución:
```
chmod +x ./scripts/*
```
# Paso 3: Empaquetado y carga de la revisión de aplicación en Amazon S3
Para poder implementar la revisión de la aplicación, antes tiene que agrupar sus archivos y cargar el paquete en un bucket de Amazon S3. Siga las instrucciones en [Cree una aplicación con CodeDeploy](applications-create.md) y [Enviar una revisión CodeDeploy a Amazon S3 (solo para implementaciones de EC2/on-premise)](application-revisions-push.md). (Aunque puede dar cualquier nombre a la aplicación y al grupo de implementaciones, le recomendamos especificar `CodeDeploy-OnPrem-App` como nombre para la aplicación y `CodeDeploy-OnPrem-DG` como nombre del grupo de implementaciones). Una vez que haya completado las instrucciones, vuelve a esta página.
**nota**
Como alternativa, puede cargar el paquete de archivos en un GitHub repositorio e implementarlo desde allí. Para obtener más información, consulte [Integración CodeDeploy con GitHub](integrations-partners-github.md).
# Paso 4: Implementar la revisión de la aplicación
Una vez cargada la revisión de la aplicación en un bucket de Amazon S3, intente implementarla en la instancia en las instalaciones. Siga las instrucciones de [Cree una implementación con CodeDeploy](deployments-create.md) y, a continuación, vuelva a esta página.
# Paso 5: Comprobar la implementación
Para comprobar si la implementación se ha realizado correctamente, siga las instrucciones de [Ver detalles CodeDeploy de la implementación](deployments-view-details.md) y, a continuación, vuelva a esta página.
Si la implementación se ha realizado correctamente, verá cuatro archivos de texto en la carpeta `c:\temp\CodeDeployExample` (para Windows Server) o `/tmp/CodeDeployExample` (para Ubuntu Server y RHEL).
Si la implementación ha fallado, siga los pasos de resolución de problemas de [Visualización de los detalles de la instancia con CodeDeploy](instances-view-details.md) y [Solución de problemas de instancias](troubleshooting-ec2-instances.md). Haga las correcciones necesarias, vuelva a empaquetar y cargar la revisión de la aplicación e intente implementarla de nuevo.
# Paso 6: Limpiar los recursos
Para evitar cargos recurrentes por los recursos que ha creado para este tutorial, elimine el bucket de Amazon S3 si no va a utilizarlo. También puede limpiar los recursos asociados, como los registros del grupo de aplicaciones y despliegues CodeDeploy y la instancia local.
Puede utilizar las consolas Amazon S3 AWS CLI o una combinación de ellas AWS CLI para limpiar los recursos. CodeDeploy
## Limpieza de los recursos (CLI)
**Para eliminar el bucket de Amazon S3**
+ Ejecute el comando [rm](https://docs.aws.amazon.com/cli/latest/reference/s3/rm.html) con el modificador `--recursive` para el bucket (por ejemplo, `amzn-s3-demo-bucket`). El bucket y todos los objetos que contiene se eliminarán.
```
aws s3 rm s3://your-bucket-name --recursive --region region
```
**Para eliminar los registros del grupo de aplicaciones y despliegues en CodeDeploy**
+ Llame al comando [delete-application](https://docs.aws.amazon.com/cli/latest/reference/deploy/delete-application.html) para la aplicación (por ejemplo, `CodeDeploy-OnPrem-App`). Los registros de la implementación y del grupo de implementaciones se eliminarán.
```
aws deploy delete-application --application-name your-application-name
```
**Para cancelar el registro de la instancia on-premises y eliminar el usuario de IAM**
+ Ejecute el comando [deregister](https://docs.aws.amazon.com/cli/latest/reference/deploy/deregister.html) para la instancia en las instalaciones y la región:
```
aws deploy deregister --instance-name your-instance-name --delete-iam-user --region your-region
```
**nota**
Si no desea eliminar el usuario de IAM asociado a esta instancia en las instalaciones, especifique la opción `--no-delete-iam-user`.
**Para desinstalar el CodeDeploy agente y eliminar el archivo de configuración de la instancia local**
+ Desde la instancia en las instalaciones, llame al comando [uninstall](https://docs.aws.amazon.com/cli/latest/reference/deploy/uninstall.html):
```
aws deploy uninstall
```
Ha completado todos los pasos para limpiar los recursos utilizados en este tutorial.
## Limpieza de los recursos (consola)
**Para eliminar el bucket de Amazon S3**
1. Inicie sesión en la consola de Amazon S3 Consola de administración de AWS y ábrala en [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. Elija el icono junto al bucket que desea eliminar (por ejemplo, `amzn-s3-demo-bucket`), pero no elija el bucket en sí.
1. Elija **Acciones** y, a continuación, elija **Eliminar**.
1. Cuando se le pida confirmación de que desea eliminar el bucket, elija **OK**.
**Para eliminar los registros del grupo de aplicaciones y despliegues en CodeDeploy**
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)
**nota**
Inicie sesión con el mismo usuario que configuró en [Empezar con CodeDeploy](getting-started-codedeploy.md).
1. En el panel de navegación, elija **Applications (Aplicaciones)**.
1. Elija el nombre de la aplicación que desea eliminar (por ejemplo, `CodeDeploy-OnPrem-App`) y, a continuación, elija **Delete application (Eliminar aplicación)**.
1. Cuando se le solicite, introduzca el nombre de la aplicación para confirmar que desea eliminarla y seleccione **Delete (Eliminar)**.
No puede usar la AWS CodeDeploy consola para anular el registro de la instancia local o desinstalar el agente. CodeDeploy Siga las instrucciones en [Para cancelar el registro de la instancia on-premises y eliminar el usuario de IAM](#tutorials-on-premises-instance-6-clean-up-resources-deregister-cli).
# Tutorial: Se usa CodeDeploy para implementar una aplicación en un grupo de Auto Scaling
En este tutorial, se utilizará CodeDeploy para implementar una revisión de la aplicación en un grupo de Auto Scaling. Amazon EC2 Auto Scaling lanza las instancias de Amazon EC2 con condiciones predefinidas y, a continuación, las termina cuando ya no se necesitan. Amazon EC2 Auto Scaling puede CodeDeploy ayudar a escalar al garantizar que siempre tenga el número correcto de instancias de Amazon EC2 disponibles para gestionar la carga de las implementaciones. Para obtener información sobre la integración de Amazon EC2 Auto Scaling CodeDeploy con, [Integración CodeDeploy con Amazon EC2 Auto Scaling](integrations-aws-auto-scaling.md) consulte.
**Topics**
+ [Requisitos previos](tutorials-auto-scaling-group-prerequisites.md)
+ [Paso 1: Crear y configurar el grupo de escalado automático](tutorials-auto-scaling-group-create-auto-scaling-group.md)
+ [Paso 2: Implementar la aplicación en el grupo de escalado automático](tutorials-auto-scaling-group-create-deployment.md)
+ [Paso 3: Comprobar los resultados](tutorials-auto-scaling-group-verify.md)
+ [Paso 4: Aumentar el número de instancias de Amazon EC2 en el grupo de escalado automático](tutorials-auto-scaling-group-scale-up.md)
+ [Paso 5: Comprobar los resultados de nuevo](tutorials-auto-scaling-group-reverify.md)
+ [Paso 6: limpiar](tutorials-auto-scaling-group-clean-up.md)
# Requisitos previos
Para seguir en este tutorial:
+ Complete todos los pasos[Empezar con CodeDeploy](getting-started-codedeploy.md), incluida la configuración AWS CLI y creación de un perfil de instancia de IAM (**CodeDeployDemo-EC2-Instance-Profile**) y un rol de servicio (**CodeDeployDemo**). Un *rol de servicio* es un tipo especial de rol de IAM que da a un servicio permiso para actuar en nombre de un usuario.
+ Si crea un grupo de escalado automático con una plantilla de inicio, debe añadir los siguientes permisos:
+ `ec2:RunInstances`
+ `ec2:CreateTags`
+ `iam:PassRole`
Para obtener más información, consulte [Paso 2: Crear un rol de servicio](getting-started-create-service-role.md), [Creación de una plantilla de lanzamiento para un grupo de escalado automático](https://docs.aws.amazon.com/autoscaling/ec2/userguide/create-launch-template.html) y [Compatibilidad con las plantillas de lanzamiento](https://docs.aws.amazon.com/autoscaling/ec2/userguide/ec2-auto-scaling-launch-template-permissions.html) en la *Guía del usuario de Amazon EC2 Auto Scaling*.
+ Cree y utilice una revisión que sea compatible con una instancia de Ubuntu Server y CodeDeploy. Para su revisión, puede realizar una de las siguientes acciones:
+ Cree y utilice la revisión de ejemplo en [Paso 2: Crear una revisión de aplicación de ejemplo](tutorials-on-premises-instance-2-create-sample-revision.md) en el tutorial [Tutorial: Implemente una aplicación en una instancia local con CodeDeploy (Windows Server, Ubuntu Server o Red Hat Enterprise Linux)](tutorials-on-premises-instance.md).
+ Para crear su propia revisión, consulte [Trabajar con revisiones de aplicaciones para CodeDeploy](application-revisions.md).
+ Cree un grupo de seguridad denominado **CodeDeployDemo-AS-SG** con la siguiente **regla de entrada**:
+ Tipo: HTTP
+ Origen: Cualquiera
Esto es necesario para ver la aplicación y comprobar que la implementación se ha realizado correctamente. Para obtener información sobre cómo crear un grupo de seguridad, consulte [Creación de un grupo de seguridad](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/working-with-security-groups.html#creating-security-group) en la *Guía del usuario de Amazon EC2*.
# Paso 1: Crear y configurar el grupo de escalado automático
En este paso, creará un grupo de escalado automático que contenga una única instancia de Amazon EC2 de Amazon Linux, RHEL o Windows Server. En un paso posterior, indicará a Amazon EC2 Auto Scaling que añada una instancia más de Amazon EC2 e implementará su revisión CodeDeploy en ella.
**Topics**
+ [Para crear y configurar el grupo de escalado automático (CLI)](#tutorials-auto-scaling-group-create-auto-scaling-group-cli)
+ [Para crear y configurar el grupo de escalado automático (consola)](#tutorials-auto-scaling-group-create-auto-scaling-group-console)
## Para crear y configurar el grupo de escalado automático (CLI)
1. Llame al comando **create-launch-template** para crear una plantilla de lanzamiento de Amazon EC2.
Antes de llamar a este comando, necesitará el ID de una AMI que funcione para este tutorial, representado por el marcador *image-id* de posición. También necesita el nombre de un par de claves de instancia de Amazon EC2 para permitir el acceso a la instancia de Amazon EC2, representada por el marcador de posición. *key-name*
Para obtener el ID de una AMI adecuada para este tutorial:
1. Abra la consola de Amazon EC2 en [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. En el panel de navegación, en **Instances**, elija **Instances** y seleccione **Launch Instance**.
1. En la pestaña **Inicio rápido** de la página **Elija una imagen de máquina de Amazon**, anote el ID de la AMI junto a **AMI de Amazon Linux 2**, **Red Hat Enterprise Linux 7.1**, **Ubuntu Server 14.04 LTS** o **Microsoft Windows Server 2012 R2**.
**nota**
Si dispone de una versión personalizada de una AMI que sea compatible con CodeDeploy, elíjala aquí en lugar de buscarla en la pestaña **Quick Start (Inicio rápido)**. Para obtener información sobre el uso de una AMI personalizada con CodeDeploy Amazon EC2 Auto Scaling, [Uso de una AMI personalizada con CodeDeploy Amazon EC2 Auto Scaling](integrations-aws-auto-scaling.md#integrations-aws-auto-scaling-custom-ami) consulte.
Como par de claves de la instancia de Amazon EC2, indique el nombre del par de claves de su instancia de Amazon EC2.
Llame al comando **create-launch-template**.
En máquinas Linux, macOS o Unix locales:
```
aws ec2 create-launch-template \
--launch-template-name CodeDeployDemo-AS-Launch-Template \
--launch-template-data file://config.json
```
El contenido del archivo `config.json`:
```
{
"InstanceType":"t1.micro",
"ImageId":"image-id",
"IamInstanceProfile":{
"Name":"CodeDeployDemo-EC2-Instance-Profile"
},
"KeyName":"key-name"
}
```
En los equipos locales con Windows:
```
aws ec2 create-launch-template --launch-template-name CodeDeployDemo-AS-Launch-Template --launch-template-data file://config.json
```
El contenido del archivo `config.json`:
```
{
"InstanceType":"t1.micro",
"ImageId":"image-id",
"IamInstanceProfile":{
"Name":"CodeDeployDemo-EC2-Instance-Profile"
},
"KeyName":"key-name"
}
```
Estos comandos, junto con el `config.json` archivo, crean una plantilla de lanzamiento de Amazon EC2 con el nombre CodeDeployDemo-AS-Launch-Template de su grupo de Auto Scaling que se creará en un paso siguiente en función del tipo de instancia t1.micro de Amazon EC2. En función de los datos introducidos para `ImageId`, `IamInstanceProfile` y `KeyName`, la plantilla de lanzamiento también especifica el ID de la AMI, el nombre del perfil de instancia asociado al rol de IAM que se va a transferir a las instancias en el momento del lanzamiento y el par de claves de Amazon EC2 que se debe utilizar al conectarse a las instancias.
1. Llame al comando **create-auto-scaling-group** para crear un grupo de escalado automático. Necesitará el nombre de una de las zonas de disponibilidad de una de las regiones que figuran en [Región y puntos de enlace en ella *Referencia general de AWS*](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region), representada por el marcador de posición. *availability-zone*
**nota**
Para ver una lista de las zonas de disponibilidad de una región, ejecute este comando:
```
aws ec2 describe-availability-zones --region region-name
```
Por ejemplo, para ver una lista con las zonas de disponibilidad de la región Oeste de EE. UU. (Oregón), llame al comando siguiente:
```
aws ec2 describe-availability-zones --region us-west-2
```
Para obtener una lista de los identificadores de nombres de región, consulte [Nombres de bucket del kit de recursos por región](resource-kit.md#resource-kit-bucket-names).
En máquinas Linux, macOS o Unix locales:
```
aws autoscaling create-auto-scaling-group \
--auto-scaling-group-name CodeDeployDemo-AS-Group \
--launch-template CodeDeployDemo-AS-Launch-Template,Version='$Latest' \
--min-size 1 \
--max-size 1 \
--desired-capacity 1 \
--availability-zones availability-zone \
--tags Key=Name,Value=CodeDeployDemo,PropagateAtLaunch=true
```
En los equipos locales con Windows:
```
aws autoscaling create-auto-scaling-group --auto-scaling-group-name CodeDeployDemo-AS-Group --launch-template LaunchTemplateName=CodeDeployDemo-AS-Launch-Template,Version="$Latest" --min-size 1 --max-size 1 --desired-capacity 1 --availability-zones availability-zone --tags Key=Name,Value=CodeDeployDemo,PropagateAtLaunch=true
```
Estos comandos crean un grupo de escalado automático denominado **CodeDeployDemo-AS-Group** en función del nombre de la plantilla de lanzamiento de Amazon EC2 **CodeDeployDemo-AS-Launch-Template**. Este grupo de escalado automático tiene una única instancia de Amazon EC2 y se crea en la zona de disponibilidad especificada. Cada instancia de este grupo de escalado automático tendrá la etiqueta `Name=CodeDeployDemo`. La etiqueta se utilizará al instalar el CodeDeploy agente más adelante.
1. Llame al comando **describe-auto-scaling-groups** con **CodeDeployDemo-AS-Group**:
```
aws autoscaling describe-auto-scaling-groups --auto-scaling-group-names CodeDeployDemo-AS-Group --query "AutoScalingGroups[0].Instances[*].[HealthStatus, LifecycleState]" --output text
```
No continúe hasta que los valores devueltos indiquen `Healthy` y `InService`.
1. Las instancias de su grupo de Auto Scaling deben tener el CodeDeploy agente instalado para poder usarse en CodeDeploy las implementaciones. Instale el CodeDeploy agente llamando al **create-association** comando desde AWS Systems Manager con las etiquetas que se agregaron cuando se creó el grupo Auto Scaling.
```
aws ssm create-association \
--name AWS-ConfigureAWSPackage \
--targets Key=tag:Name,Values=CodeDeployDemo \
--parameters action=Install, name=AWSCodeDeployAgent \
--schedule-expression "cron(0 2 ? * SUN *)"
```
Este comando crea una asociación en Systems Manager State Manager que instalará el CodeDeploy agente en todas las instancias del grupo Auto Scaling y, a continuación, intentará actualizarlo a las 2:00 todos los domingos por la mañana. Para obtener más información sobre el CodeDeploy agente, consulte [Trabajar con el CodeDeploy agente](https://docs.aws.amazon.com/codedeploy/latest/userguide/codedeploy-agent.html). Para obtener más información acerca de Systems Manager, consulte [¿Qué es AWS Systems Manager?](https://docs.aws.amazon.com/systems-manager/latest/userguide/what-is-systems-manager.html).
## Para crear y configurar el grupo de escalado automático (consola)
1. Abra la consola de Amazon EC2 en [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. En la barra de navegación global, asegúrese de que esté seleccionada una de las regiones enumeradas en [Región y puntos de conexión](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) en *Referencia general de AWS*. Los recursos de Amazon EC2 Auto Scaling están vinculados a la región que especifique CodeDeploy y solo se admiten en determinadas regiones.
1. En el panel de navegación, en **Instancias**, seleccione **Plantillas de lanzamiento**.
1. Elija **Crear plantilla de lanzamiento**.
1. En **Nombre y descripción de la plantilla de lanzamiento**, para **Nombre de plantilla de lanzamiento**, introduzca **CodeDeployDemo-AS-Launch-Template**. Deje los valores predeterminados para el resto de los campos.
1. En el cuadro de diálogo **Imagen de máquina de Amazon (AMI)**, haga clic en el menú desplegable situado debajo de **AMI** y elija una AMI que funcione con este tutorial:
1. En la pestaña **Inicio rápido** del menú desplegable **AMI**, elija uno de los siguientes: **AMI de Amazon Linux 2**, **Red Hat Enterprise Linux 7.1**, **Ubuntu Server 14.04 LTS** o **Microsoft Windows Server 2012 R2**.
**nota**
Si dispone de una versión personalizada de una AMI que sea compatible con CodeDeploy, elíjala aquí en lugar de buscarla en la pestaña **Quick Start (Inicio rápido)**. Para obtener información sobre el uso de una AMI personalizada con CodeDeploy Amazon EC2 Auto Scaling, [Uso de una AMI personalizada con CodeDeploy Amazon EC2 Auto Scaling](integrations-aws-auto-scaling.md#integrations-aws-auto-scaling-custom-ami) consulte.
1. En **Tipo de instancia**, seleccione el menú desplegable y elija **t1.micro.** Puede utilizar la barra de búsqueda para encontrarla más rápidamente.
1. En el cuadro de diálogo **Par de claves (inicio de sesión)**, seleccione **Elegir un par de claves existente**. En la lista desplegable **Seleccionar un par de claves**, elija el par de claves de la instancia de Amazon EC2 que ha creado o utilizado en los pasos anteriores.
1. En el cuadro de diálogo **Configuración de red**, elija **Nube pública virtual (VPC)**.
En el menú desplegable **Grupos de seguridad**, elija el grupo de seguridad que creó en la [sección de requisitos previos del tutorial](https://docs.aws.amazon.com/codedeploy/latest/userguide/tutorials-auto-scaling-group-prerequisites.html) (**CodeDeployDemo-AS-SG**).
1. Amplíe el cuadro de diálogo de **Detalles avanzados**. En el menú desplegable de **Perfil de instancia de IAM**, seleccione el rol de IAM que creó anteriormente (**CodeDeployDemo-EC2-Instance-Profile**) en **Perfil de instancia de IAM**.
Deje el resto de las opciones predeterminadas.
1. Elija **Crear plantilla de inicialización**.
1. En el cuadro de diálogo **Próximos pasos**, elija **Crear grupo de escalado automático**.
1. En la página **Elegir una plantilla de lanzamiento o configuración**, para **Nombre de grupo de escalado automático**, ingrese **CodeDeployDemo-AS-Group**.
1. En el cuadro de diálogo **Plantilla de lanzamiento**, debe ingresar su plantilla de lanzamiento (**CodeDeployDemo-AS-Launch-Template**); de lo contrario, selecciónela en el menú desplegable. Deje los valores predeterminados y elija **Siguiente**.
1. En la página **Elegir opciones de lanzamiento de las instancias**, en **Red**, en la opción **VPC**, elija la VPC predeterminada. A continuación, en **Zonas de disponibilidad y subredes**, elija una subred predeterminada. Debe crear una VPC si no puede elegir la predeterminada. Para obtener más información, consulte [Introducción a Amazon VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-getting-started.html).
1. En la sección **Instance type requirements** (Requisitos del tipo de instancia), utilice la configuración predeterminada para simplificar este paso. (No anule la plantilla de lanzamiento). En este tutorial, solo lanzará instancias bajo demanda con el tipo de instancia especificado en la plantilla de lanzamiento.
1. Elija **Next** (Siguiente) para ir a la página **Configure advanced options** (Configuración de opciones avanzadas).
1. Mantenga los valores predeterminados y elija **Siguiente**.
1. En la página **Configurar el tamaño del grupo y las políticas de escalado**, mantenga los valores predeterminados de **Tamaño de grupo** de 1. Elija **Siguiente**.
1. Omita el paso para configurar notificaciones y elija **Siguiente**.
1. En la página **Añadir etiquetas**, añada una etiqueta para utilizarla cuando instale el CodeDeploy agente más adelante. Seleccione **Agregar etiqueta**.
1. En **Clave**, introduzca **Name**.
1. En **Valor**, escriba **CodeDeployDemo**.
Elija **Siguiente**.
1. Revise la información del grupo de escalado automático en la página **Revisión** y luego elija **Crear grupo de escalado automático**.
1. En la barra de navegación, con **Grupos de escalado automático** seleccionado, elija **CodeDeployDemo-AS-Group** y luego seleccione la pestaña **Administración de instancias**. No continúe hasta que el valor de **InService**aparezca en la columna **Ciclo** de vida y el valor de **Healthy** aparezca en la columna **Estado de salud**.
1. Instale el CodeDeploy agente siguiendo los pasos que se indican en [Instalar el CodeDeploy agente](https://docs.aws.amazon.com/codedeploy/latest/userguide/codedeploy-agent-operations-install.html) y utilizar las etiquetas de `Name=CodeDeployDemo` instancia.
# Paso 2: Implementar la aplicación en el grupo de escalado automático
En este paso, implementará la revisión en la única instancia de Amazon EC2 del grupo de escalado automático.
**Topics**
+ [Para crear la implementación (CLI)](#tutorials-auto-scaling-group-create-deployment-cli)
+ [Para crear la implementación (consola)](#tutorials-auto-scaling-group-create-deployment-console)
## Para crear la implementación (CLI)
1. Ejecute el comando **create-application** para crear una aplicación denominada **SimpleDemoApp**:
```
aws deploy create-application --application-name SimpleDemoApp
```
1. Ya debe haber creado un rol de servicio siguiendo las instrucciones del [Paso 2: Crear un rol de servicio para CodeDeploy](getting-started-create-service-role.md). El rol de servicio le dará CodeDeploy permiso para acceder a sus instancias de Amazon EC2 para expandir (leer) sus etiquetas. Necesitará el rol de servicio ARN. Para obtener el ARN del rol de servicio, siga las instrucciones de [Obtención del ARN del rol de servicio (CLI)](getting-started-create-service-role.md#getting-started-get-service-role-cli).
1. Ahora que tiene un ARN de rol de servicio, ejecute el comando **create-deployment-group** para crear un grupo de implementación denominado **SimpleDemoDG** asociado a la aplicación **SimpleDemoApp**, utilizando el grupo de escalado automático **CodeDeployDemo-AS-Group** y la configuración de implementación **CodeDeployDefault.OneAtATime** con el ARN del rol de servicio especificado.
**nota**
El [create-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment-group.html)comando permite crear activadores que provoquen el envío de notificaciones de Amazon SNS a los suscriptores del tema sobre eventos específicos en implementaciones e instancias. El comando también admite opciones para revertir automáticamente las implementaciones y configurar alarmas para detener las implementaciones cuando se cumplen los umbrales de monitoreo de CloudWatch las alarmas de Amazon. Los comandos para estas acciones no se incluyen en este tutorial.
En máquinas Linux, macOS o Unix locales:
```
aws deploy create-deployment-group \
--application-name SimpleDemoApp \
--auto-scaling-groups CodeDeployDemo-AS-Group \
--deployment-group-name SimpleDemoDG \
--deployment-config-name CodeDeployDefault.OneAtATime \
--service-role-arn service-role-arn
```
En los equipos locales con Windows:
```
aws deploy create-deployment-group --application-name SimpleDemoApp --auto-scaling-groups CodeDeployDemo-AS-Group --deployment-group-name SimpleDemoDG --deployment-config-name CodeDeployDefault.OneAtATime --service-role-arn service-role-arn
```
1. Ejecute el comando **create-deployment** para crear una implementación asociada a la aplicación **SimpleDemoApp**, la configuración de implementación **CodeDeployDefault.OneAtATime** y el grupo de implementaciones **SimpleDemoDG**, utilizando la revisión que se encuentra en el lugar especificado.
**Para instancias Amazon EC2 de Amazon Linux y RHEL, llamadas desde máquinas locales Linux, macOS o Unix**
```
aws deploy create-deployment \
--application-name SimpleDemoApp \
--deployment-config-name CodeDeployDefault.OneAtATime \
--deployment-group-name SimpleDemoDG \
--s3-location bucket=bucket-name,bundleType=zip,key=samples/latest/SampleApp_Linux.zip
```
*bucket-name*es el nombre del depósito de Amazon S3 que contiene los archivos del kit de CodeDeploy recursos de su región. Por ejemplo, para la región EE.UU. Este (Ohio), *bucket-name* sustitúyala por`aws-codedeploy-us-east-2`. Para obtener una lista de los nombres de los buckets, consulte [Nombres de bucket del kit de recursos por región](resource-kit.md#resource-kit-bucket-names).
**Para instancias Amazon EC2 de Amazon Linux y RHEL, llamadas desde máquinas locales Windows**
```
aws deploy create-deployment --application-name SimpleDemoApp --deployment-config-name CodeDeployDefault.OneAtATime --deployment-group-name SimpleDemoDG --s3-location bucket=bucket-name,bundleType=zip,key=samples/latest/SampleApp_Linux.zip
```
*bucket-name*es el nombre del depósito de Amazon S3 que contiene los archivos del kit de CodeDeploy recursos de su región. Por ejemplo, para la región EE.UU. Este (Ohio), *bucket-name* sustitúyala por`aws-codedeploy-us-east-2`. Para obtener una lista de los nombres de los buckets, consulte [Nombres de bucket del kit de recursos por región](resource-kit.md#resource-kit-bucket-names).
**Para instancias Amazon EC2 de Windows Server, llamadas desde máquinas locales Linux, macOS o Unix**
```
aws deploy create-deployment \
--application-name SimpleDemoApp \
--deployment-config-name CodeDeployDefault.OneAtATime \
--deployment-group-name SimpleDemoDG \
--s3-location bucket=bucket-name,bundleType=zip,key=samples/latest/SampleApp_Windows.zip
```
*bucket-name*es el nombre del depósito de Amazon S3 que contiene los archivos del kit de CodeDeploy recursos de su región. Por ejemplo, para la región EE.UU. Este (Ohio), *bucket-name* sustitúyala por`aws-codedeploy-us-east-2`. Para obtener una lista de los nombres de los buckets, consulte [Nombres de bucket del kit de recursos por región](resource-kit.md#resource-kit-bucket-names).
**Para instancias Amazon EC2 de Windows Server, llamadas desde máquinas locales Windows**
```
aws deploy create-deployment --application-name SimpleDemoApp --deployment-config-name CodeDeployDefault.OneAtATime --deployment-group-name SimpleDemoDG --s3-location bucket=bucket-name,bundleType=zip,key=samples/latest/SampleApp_Windows.zip
```
*bucket-name*es el nombre del depósito de Amazon S3 que contiene los archivos del kit de CodeDeploy recursos de su región. Por ejemplo, para la región EE.UU. Este (Ohio), *bucket-name* sustitúyala por`aws-codedeploy-us-east-2`. Para obtener una lista de los nombres de los buckets, consulte [Nombres de bucket del kit de recursos por región](resource-kit.md#resource-kit-bucket-names).
**nota**
Actualmente, CodeDeploy no proporciona una revisión de muestra para implementarla en instancias Amazon EC2 de Ubuntu Server. Para crear su propia revisión, consulte [Trabajar con revisiones de aplicaciones para CodeDeploy](application-revisions.md).
1. Ejecute el comando **get-deployment** para asegurarse de que la implementación se ha realizado correctamente.
Antes de ejecutar este comando, necesitará el ID de la implementación, que debe haber obtenido tras ejecutar el comando **create-deployment**. Si necesita obtener de nuevo el ID de la implementación, ejecute el comando **list-deployments** para la aplicación **SimpleDemoApp** y el grupo de implementaciones **SimpleDemoDG**:
```
aws deploy list-deployments --application-name SimpleDemoApp --deployment-group-name SimpleDemoDG --query "deployments" --output text
```
Llame ahora al comando **get-deployment** utilizando el ID de la implementación:
```
aws deploy get-deployment --deployment-id deployment-id --query "deploymentInfo.status" --output text
```
No continúe hasta que el valor devuelto sea `Succeeded`.
## Para crear la implementación (consola)
1. Ya debe haber creado un rol de servicio siguiendo las instrucciones del [Paso 2: Crear un rol de servicio para CodeDeploy](getting-started-create-service-role.md). El rol de servicio le dará CodeDeploy permiso para acceder a sus instancias para expandir (leer) sus etiquetas. Antes de usar la CodeDeploy consola para implementar la revisión de la aplicación, necesitará el ARN del rol de servicio. Para obtener el ARN del rol de servicio, siga las instrucciones de [Obtención del ARN del rol de servicio (consola)](getting-started-create-service-role.md#getting-started-get-service-role-console).
1. Ahora que tiene el ARN del rol de servicio, puede usar la CodeDeploy consola para implementar la revisión de la aplicación.
Inicie sesión en la CodeDeploy consola Consola de administración de AWS y ábrala en [https://console.aws.amazon.com/codedeploy.](https://console.aws.amazon.com/codedeploy)
**nota**
Inicie sesión con el mismo usuario que configuró en [Empezar con CodeDeploy](getting-started-codedeploy.md).
1. En el panel de navegación, expanda **Implementar** y, después, elija **Aplicaciones**.
1. Elija **Creación de aplicación**.
1. Elija **Custom application (Aplicación personalizada)**.
1. En **Application name (Nombre de aplicación)**, escriba **SimpleDemoApp**.
1. En **Plataforma de informática**, elija **EC2/en las instalaciones**.
1. Elija **Creación de aplicación**.
1. En la pestaña **Deployment groups (Grupos de implementaciones)**, elija **Create deployment group (Crear grupo de implementaciones)**.
1. En **Nombre de grupo de implementación**, escriba **SimpleDemoDG**.
1. En **Service Role (Rol de servicio)**, elija el nombre del rol de servicio.
1. En **Tipo de implementación**, elija **Local**.
1. En **Configuración del entorno**, seleccione **Grupos de escalado automático** y, a continuación, elija **CodeDeployDemo-AS-Group**.
1. **En **Configuración de despliegue, elija**. CodeDeployDefault OneAtATime**.
1. Desactive **Enable load balancing (Habilitar balanceo de carga)**.
1. Elija **Crear grupo de implementación**.
1. En la página del grupo de implementaciones, elija **Create deployment (Crear implementación)**.
1. En **Tipo de revisión**, elija **Mi aplicación está almacenada en Amazon S3**.
1. En **Revision location (Ubicación de la revisión)**, introduzca la ubicación de la aplicación de ejemplo para el sistema operativo y la región.
**Para instancias Amazon EC2 de Amazon Linux y RHEL**
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/tutorials-auto-scaling-group-create-deployment.html)
**Instancias de Amazon EC2 con Windows Server**
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/tutorials-auto-scaling-group-create-deployment.html)
**Para instancias de Amazon EC2 de Ubuntu Server**
Escriba la ubicación de la revisión de la aplicación personalizada almacenada en Amazon S3.
1. Deje **Deployment description (Descripción de implementación)** en blanco.
1. Expanda **Advanced (Avanzadas)**.
1. Elija **Crear implementación**.
**nota**
Si aparece **Failed (Error)** en lugar de **Succeeded (Correcto)**, puede ser conveniente probar alguna de las técnicas descritas en [Monitorización y solución de problemas de la implementación](tutorials-wordpress-deploy-application.md#tutorials-wordpress-deploy-application-monitor) (utilizando **SimpleDemoApp** como nombre de la aplicación y **SimpleDemoDG** como nombre del grupo de implementaciones).
# Paso 3: Comprobar los resultados
En este paso, comprobará si la **SimpleDemoApp** revisión CodeDeploy está instalada en la única instancia de Amazon EC2 del grupo Auto Scaling.
**Topics**
+ [Para comprobar los resultados (CLI)](#tutorials-auto-scaling-group-verify-cli)
+ [Para comprobar los resultados (consola)](#tutorials-auto-scaling-group-verify-console)
## Para comprobar los resultados (CLI)
En primer lugar, necesitará el DNS público de la instancia de Amazon EC2.
Utilice el AWS CLI para obtener el DNS público de la instancia de Amazon EC2 del grupo Auto Scaling mediante una llamada al **describe-instances** comando.
Antes de llamar a este comando, necesitará el ID de la instancia de Amazon EC2. Para obtener el ID, ejecute el comando **describe-auto-scaling-groups** con **CodeDeployDemo-AS-Group** igual que hizo anteriormente:
```
aws autoscaling describe-auto-scaling-groups --auto-scaling-group-names CodeDeployDemo-AS-Group --query "AutoScalingGroups[0].Instances[*].InstanceId" --output text
```
Llame ahora al comando **describe-instances**:
```
aws ec2 describe-instances --instance-id instance-id --query "Reservations[0].Instances[0].PublicDnsName" --output text
```
El valor devuelto es el DNS público de la instancia de Amazon EC2.
Mediante un navegador web, muestre la SimpleDemoApp revisión implementada en esa instancia de Amazon EC2 mediante una URL como la siguiente:
```
http://ec2-01-234-567-890.compute-1.amazonaws.com
```
Si ve la página de felicitaciones, ¡ha utilizado CodeDeploy correctamente la implementación de una revisión en una sola instancia de Amazon EC2 en un grupo de Auto Scaling\$1
A continuación, agregará una instancia de Amazon EC2 al grupo de escalado automático. Una vez que Amazon EC2 Auto Scaling añada la CodeDeploy instancia de Amazon EC2, implementará la revisión en la nueva instancia.
## Para comprobar los resultados (consola)
En primer lugar, necesitará el DNS público de la instancia de Amazon EC2.
Abra la consola de Amazon EC2 en [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
En el panel de navegación de Amazon EC2, en **Escalado automático**, elija **Grupos de escalado automático** y, a continuación, elija la entrada **CodeDeployDemo-AS-Group**.
En la pestaña **Instancias**, elija el ID de la instancia de Amazon EC2 en la lista.
En la página **Instances**, en la pestaña **Description**, tome nota del valor de **Public DNS**. Debe tener un aspecto similar al siguiente: **ec2-01-234-567-890.compute-1.amazonaws.com**.
Mediante un navegador web, muestre la SimpleDemoApp revisión implementada en esa instancia de Amazon EC2 mediante una URL como la siguiente:
```
http://ec2-01-234-567-890.compute-1.amazonaws.com
```
Si ve la página de felicitaciones, ¡ha utilizado CodeDeploy correctamente la implementación de una revisión en una sola instancia de Amazon EC2 en un grupo de Auto Scaling\$1
A continuación, agregará una instancia de Amazon EC2 al grupo de escalado automático. Una vez que Amazon EC2 Auto Scaling añada la CodeDeploy instancia de Amazon EC2, implementará la revisión en la nueva instancia de Amazon EC2.
# Paso 4: Aumentar el número de instancias de Amazon EC2 en el grupo de escalado automático
En este paso, indica al grupo de escalado automático que cree una instancia Amazon EC2 adicional. Una vez que Amazon EC2 Auto Scaling haya creado la instancia CodeDeploy , despliega la revisión en ella.
**Topics**
+ [Para escalar horizontalmente la cantidad de instancias de Amazon EC2 en el grupo de escalado automático (CLI)](#tutorials-auto-scaling-group-scale-up-cli)
+ [Para aumentar el número de instancias de Amazon EC2 del grupo de implementación (consola)](#tutorials-auto-scaling-group-scale-up-console)
## Para escalar horizontalmente la cantidad de instancias de Amazon EC2 en el grupo de escalado automático (CLI)
1. Llame al comando **update-auto-scaling-group** para aumentar las instancias de Amazon EC2 del grupo de escalado automático denominado **CodeDeployDemo-AS-Group** de una a dos.
En máquinas Linux, macOS o Unix locales:
```
aws autoscaling update-auto-scaling-group \
--auto-scaling-group-name CodeDeployDemo-AS-Group \
--min-size 2 \
--max-size 2 \
--desired-capacity 2
```
En los equipos locales con Windows:
```
aws autoscaling update-auto-scaling-group --auto-scaling-group-name CodeDeployDemo-AS-Group --min-size 2 --max-size 2 --desired-capacity 2
```
1. Asegúrese de que el grupo de escalado automático tenga ahora dos instancias de Amazon EC2. Llame al comando **describe-auto-scaling-groups** con **CodeDeployDemo-AS-Group**:
```
aws autoscaling describe-auto-scaling-groups --auto-scaling-group-names CodeDeployDemo-AS-Group --query "AutoScalingGroups[0].Instances[*].[HealthStatus, LifecycleState]" --output text
```
No continúe hasta que los dos valores devueltos indiquen `Healthy` y `InService`.
## Para aumentar el número de instancias de Amazon EC2 del grupo de implementación (consola)
1. En el panel de navegación de Amazon EC2, en **Escalado automático**, elija **Grupos de escalado automático** y, a continuación, elija **CodeDeployDemo-AS-Group**.
1. Seleccione **Acciones** y, a continuación, **Editar**.
1. En la pestaña **Details (Detalles)**, en los cuadros **Desired (Objetivos)**, **Min (Mínimo)** y **Max (Máximo)**, escriba **2** y luego elija** Save (Guardar)**.
1. Seleccione la pestaña **Instances**. La nueva instancia de Amazon EC2 debe aparecer en la lista. (Si la instancia no aparece, puede que tenga que pulsar el botón **Refresh** varias veces). No continúe hasta que el valor de **InService**aparezca en la columna **Ciclo** de vida y el valor de **Healthy** aparezca en la columna **Estado de salud**.
# Paso 5: Comprobar los resultados de nuevo
En este paso, comprobará si está CodeDeploy instalada la SimpleDemoApp revisión en la nueva instancia del grupo Auto Scaling.
**Topics**
+ [Para comprobar los resultados de la implementación automática (CLI)](#tutorials-auto-scaling-group-reverify-cli)
+ [Para comprobar los resultados de la implementación automática (consola)](#tutorials-auto-scaling-group-reverify-console)
## Para comprobar los resultados de la implementación automática (CLI)
1. Antes de ejecutar el comando **get-deployment**, necesitará el ID de la implementación automática. Para obtener el ID, ejecute el comando **list-deployments** con la aplicación **SimpleDemoApp** y el grupo de implementaciones **SimpleDemoDG**:
```
aws deploy list-deployments --application-name SimpleDemoApp --deployment-group-name SimpleDemoDG --query "deployments" --output text
```
Debería haber dos despliegues IDs. Utilice el que aún no haya empleado en una llamada al comando **get-deployment**:
```
aws deploy get-deployment --deployment-id deployment-id --query "deploymentInfo.[status, creator]" --output text
```
Además del estado de la implementación, en la salida del comando debe aparecer `autoScaling`. (`autoScaling` significa que Amazon EC2 Auto Scaling ha creado la implementación).
No continúe hasta que el estado de la implementación aparezca como `Succeeded`.
1. Antes de llamar al comando **describe-instances**, necesitará el ID de la instancia de Amazon EC2 nueva. Para obtener este ID, ejecute de nuevo el comando **describe-auto-scaling-groups** con **CodeDeployDemo-AS-Group**:
```
aws autoscaling describe-auto-scaling-groups --auto-scaling-group-names CodeDeployDemo-AS-Group --query "AutoScalingGroups[0].Instances[*].InstanceId" --output text
```
Ahora ejecute el comando **describe-instances**:
```
aws ec2 describe-instances --instance-id instance-id --query "Reservations[0].Instances[0].PublicDnsName" --output text
```
En la salida del comando **describe-instances**, anote el DNS público de la instancia de Amazon EC2 nueva.
1. En un navegador web, muestre la revisión `SimpleDemoApp` implementada en la instancia de Amazon EC2 mediante una URL como la siguiente:
```
http://ec2-01-234-567-890.compute-1.amazonaws.com
```
Si aparece la página de felicitaciones, ¡ CodeDeploy solía implementar una revisión en una instancia de Amazon EC2 ampliada en un grupo de Auto Scaling\$1
## Para comprobar los resultados de la implementación automática (consola)
1. [Inicie sesión Consola de administración de AWS y abra la CodeDeploy consola en /codedeploy. https://console.aws.amazon.com](https://console.aws.amazon.com/codedeploy)
**nota**
Inicie sesión con el mismo usuario que configuró en [Empezar con CodeDeploy](getting-started-codedeploy.md).
1. En el panel de navegación, expanda **Implementar** y después elija **Implementaciones**.
1. Elija el ID de la implementación que ha creado Amazon EC2 Auto Scaling.
.
1. La página **Deployment (Implementación)** muestra información sobre la implementación. Normalmente, debería crear una implementación por su cuenta, pero Amazon EC2 Auto Scaling ya ha creado una por usted para implementar la revisión en la instancia de Amazon EC2 nueva.
1. Cuando aparezca **Succeeded (Correcto)** en la parte superior de la página, compruebe los resultados en la instancia. Primero debe obtener el DNS público de la instancia:
1. En el panel de navegación de Amazon EC2, en **Escalado automático**, elija **Grupos de escalado automático** y, a continuación, elija la entrada **CodeDeployDemo-AS-Group**.
1. En la pestaña **Instances**, elija el ID de la nueva instancia de Amazon EC2.
1. En la página **Instances**, en la pestaña **Description**, tome nota del valor de **Public DNS**. Debe tener un aspecto similar al siguiente: **ec2-01-234-567-890.compute-1.amazonaws.com**.
Muestre la `SimpleDemoApp` revisión implementada en la instancia utilizando una URL como la siguiente:
```
http://ec2-01-234-567-890.compute-1.amazonaws.com
```
Si aparece la página de felicitaciones, ¡ CodeDeploy solía implementar una revisión en una instancia de Amazon EC2 ampliada en un grupo de Auto Scaling\$1
# Paso 6: limpiar
En este paso eliminará el grupo de escalado automático para evitar cargos recurrentes por los recursos utilizados durante este tutorial. Si lo desea, puede eliminar los registros de los componentes de configuración y CodeDeploy despliegue de Auto Scaling.
**Topics**
+ [Para limpiar los recursos (CLI)](#tutorials-auto-scaling-group-clean-up-cli)
+ [Para limpiar los recursos (consola)](#tutorials-auto-scaling-group-clean-up-console)
## Para limpiar los recursos (CLI)
1. Elimine el grupo de escalado automático llamando al comando **delete-auto-scaling-group** con **CodeDeployDemo-AS-Group**. Esto también terminará las instancias de Amazon EC2.
```
aws autoscaling delete-auto-scaling-group --auto-scaling-group-name CodeDeployDemo-AS-Group --force-delete
```
1. Si lo desea, puede eliminar la plantilla de lanzamiento de escalado automático llamando al comando **delete-launch-template** con la configuración de lanzamiento **CodeDeployDemo-AS-Launch-Template**:
```
aws ec2 delete-launch-template --launch-template-name CodeDeployDemo-AS-Launch-Template
```
1. Si lo desea, elimine la aplicación desde una llamada CodeDeploy al **delete-application** comando correspondiente a la aplicación nombrada**SimpleDemoApp**. Esto también eliminará los registros de implementación, grupo de implementaciones y revisión asociados.
```
aws deploy delete-application --application-name SimpleDemoApp
```
1. Para eliminar la asociación de Systems Manager State Manager, llame al comando **delete-association**.
```
aws ssm delete-association --assocation-id association-id
```
Puede obtenerlo *association-id* llamando al **describe-association** comando.
```
aws ssm describe-association --name AWS-ConfigureAWSPackage --targets Key=tag:Name,Values=CodeDeployDemo
```
## Para limpiar los recursos (consola)
Para eliminar el grupo de escalado automático, con lo que también se terminan las instancias de Amazon EC2:
1.
Inicie sesión en la consola Amazon EC2 Consola de administración de AWS y ábrala en. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. En el panel de navegación de Amazon EC2, en **Escalado automático**, elija **Grupos de escalado automático** y, a continuación, elija la entrada **CodeDeployDemo-AS-Group**.
1. Elija **Actions**, seleccione **Delete** y luego seleccione **Yes, Delete**.
(Opcional) Para eliminar la plantilla de lanzamiento:
1. En la barra de navegación, en **Escalado automático**, elija **Configuraciones de lanzamiento** y, a continuación, elija **CodeDeployDemo-AS-Launch-Template**.
1. Elija **Actions**, seleccione **Delete launch configuration** y luego seleccione **Yes, Delete**.
1. Si lo desea, elimine la aplicación de CodeDeploy. Esto también eliminará los registros de implementación, grupo de implementaciones y revisión asociados. Abra la CodeDeploy consola en [https://console.aws.amazon.com/codedeploy](https://console.aws.amazon.com/codedeploy).
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)
**nota**
Inicie sesión con el mismo usuario que configuró en [Empezar con CodeDeploy](getting-started-codedeploy.md).
En el panel de navegación, expanda **Implementar** y, después, elija **Aplicaciones**.
1. En la lista de aplicaciones, elija **SimpleDemoApp**.
1. En la página **Application details (Detalles de la aplicación)**, elija **Delete application (Eliminar aplicación)**.
1. Cuando se le pregunte, escriba **Delete** y, a continuación, elija **Delete (Eliminar)**.
Para eliminar la asociación de Systems Manager State Manager:
1. Abra la AWS Systems Manager consola en /systems-manager. https://console.aws.amazon.com
1. En el panel de navegación, elija **Administrador de estados**.
1. Elija la asociación que ha creado y, después, elija **Eliminar**.
# Tutorial: Se utiliza CodeDeploy para implementar una aplicación desde GitHub
En este tutorial, se utiliza CodeDeploy para implementar una revisión de aplicación de GitHub muestra en una sola instancia de Amazon EC2 que ejecute Amazon Linux, una sola instancia de Red Hat Enterprise Linux (RHEL) o una sola instancia de Windows Server. Para obtener información sobre la GitHub integración con CodeDeploy, consulte. [Integración CodeDeploy con GitHub](integrations-partners-github.md)
**nota**
También se puede utilizar CodeDeploy para implementar una revisión de una aplicación desde GitHub una instancia de Ubuntu Server. Puede utilizar el ejemplo de revisión descrito [Paso 2: Crear una revisión de aplicación de ejemplo](tutorials-on-premises-instance-2-create-sample-revision.md) en [Tutorial: Implemente una aplicación en una instancia local con CodeDeploy (Windows Server, Ubuntu Server o Red Hat Enterprise Linux)](tutorials-on-premises-instance.md) o puede crear una revisión compatible con una instancia de Ubuntu Server y CodeDeploy. Para crear su propia revisión, consulte [Planificación de una revisión de CodeDeploy](application-revisions-plan.md) y [Añadir un archivo de especificaciones de la aplicación a una revisión de CodeDeploy](application-revisions-appspec-file.md).
**Topics**
+ [Requisitos previos](tutorials-github-prerequisites.md)
+ [Paso 1: Configurar una GitHub cuenta](tutorials-github-create-github-account.md)
+ [Paso 2: Crea un GitHub repositorio](tutorials-github-create-github-repository.md)
+ [Paso 3: Sube una aplicación de muestra a tu GitHub repositorio](tutorials-github-upload-sample-revision.md)
+ [Paso 4: Aprovisionar una instancia](tutorials-github-provision-instance.md)
+ [Paso 5: Crear una aplicación y un grupo de implementación](tutorials-github-create-application.md)
+ [Paso 6: Implementar la aplicación en la instancia](tutorials-github-deploy-application.md)
+ [Paso 7: Monitorizar y comprobar la implementación](tutorials-github-verify.md)
+ [Paso 8: Eliminación](tutorials-github-clean-up.md)
# Requisitos previos
Antes de empezar este tutorial, haga lo siguiente:
+ Instale Git en su equipo local. Para instalar Git, consulte [Git Downloads](http://git-scm.com/downloads).
+ Complete los pasos indicados en [Empezar con CodeDeploy](getting-started-codedeploy.md), incluida la instalación y configuración de la AWS CLI. Esto es especialmente importante si quieres usarlo AWS CLI para implementar una revisión desde GitHub la instancia.
# Paso 1: Configurar una GitHub cuenta
Necesitará una GitHub cuenta para crear un GitHub repositorio en el que se almacenará la revisión. Si ya tiene una GitHub cuenta, pase a[Paso 2: Crea un GitHub repositorio](tutorials-github-create-github-repository.md).
1. Ve a [https://github.com/join](https://github.com).
1. Escriba un nombre de usuario, su dirección de correo electrónico y una contraseña.
1. Selecciona **Registrarse** y GitHub, a continuación, sigue las instrucciones.
# Paso 2: Crea un GitHub repositorio
Necesitará un GitHub repositorio para almacenar la revisión.
Si ya tiene un GitHub repositorio, asegúrese de sustituirlo por su nombre a **CodeDeployGitHubDemo** lo largo de este tutorial y, a continuación, vaya directamente a[Paso 3: Sube una aplicación de muestra a tu GitHub repositorio](tutorials-github-upload-sample-revision.md).
1. En la [página de GitHub inicio](https://github.com/dashboard), realice una de las siguientes acciones:
+ En **Your repositories**, elija **New repository**.
+ En la barra de navegación, seleccione **Create new** (**\$1**) y luego elija **New repository**.
1. En la página **Create a new repository**, haga lo siguiente:
+ En el cuadro **Repository name (Nombre del repositorio)**, indique **CodeDeployGitHubDemo**.
+ Seleccione **Public**.
**nota**
La opción predeterminada **Public** implica que cualquiera puede ver el repositorio. Puede seleccionar la opción **Private** (Privado) para limitar quién puede ver el repositorio y confirmarlo.
+ Desactive la casilla **Initialize this repository with a README**. En su lugar creará un archivo `README.md` manualmente en el siguiente paso.
+ Elija **Create repository**.
1. Siga las instrucciones correspondientes al tipo de su equipo local para crear el repositorio con la línea de comandos.
**nota**
Si ha activado la autenticación de dos factores GitHub, asegúrese de introducir su token de acceso personal en lugar de su contraseña de inicio de GitHub sesión si se le solicita una contraseña. Para obtener información, consulte [Proporcionar su código de autenticación 2FA](https://help.github.com/articles/providing-your-2fa-authentication-code/).
**En máquinas Linux, macOS o Unix locales:**
1. Desde el terminal, ejecuta los siguientes comandos, uno por uno, donde *user-name* aparece tu nombre de GitHub usuario:
```
mkdir /tmp/CodeDeployGitHubDemo
```
```
cd /tmp/CodeDeployGitHubDemo
```
```
touch README.md
```
```
git init
```
```
git add README.md
```
```
git commit -m "My first commit"
```
```
git remote add origin https://github.com/user-name/CodeDeployGitHubDemo.git
```
```
git push -u origin master
```
1. Deje el terminal abierto en la ubicación `/tmp/CodeDeployGitHubDemo`.
**En los equipos locales con Windows:**
1. Desde el símbolo del sistema abierto como administrador, ejecute sucesivamente los comandos siguientes:
```
mkdir c:\temp\CodeDeployGitHubDemo
```
```
cd c:\temp\CodeDeployGitHubDemo
```
```
notepad README.md
```
1. En el Bloc de notas, guarde el archivo `README.md`. Cierre el Bloc de notas. Ejecute los siguientes comandos, uno a la vez, donde *user-name* aparece su nombre GitHub de usuario:
```
git init
```
```
git add README.md
```
```
git commit -m "My first commit"
```
```
git remote add origin https://github.com/user-name/CodeDeployGitHubDemo.git
```
```
git push -u origin master
```
1. Deje el símbolo del sistema abierto en la ubicación `c:\temp\CodeDeployGitHubDemo`.
# Paso 3: Sube una aplicación de muestra a tu GitHub repositorio
En este paso, copiará un ejemplo de revisión de un bucket público de Amazon S3 a su GitHub repositorio. (Para simplificar, las revisiones de ejemplo incluidas para este tutorial son páginas web individuales).
**nota**
Si en lugar de nuestro ejemplo utiliza una revisión propia, esta deberá:
Seguir las directrices de [Planificación de una revisión de CodeDeploy](application-revisions-plan.md) y [Añadir un archivo de especificaciones de la aplicación a una revisión de CodeDeploy](application-revisions-appspec-file.md).
Funcionar con el tipo de instancia correspondiente.
Sea accesible desde su GitHub panel de control.
Si su revisión cumple estos requisitos, continúe en [Paso 5: Crear una aplicación y un grupo de implementación](tutorials-github-create-application.md).
Si vas a realizar el despliegue en una instancia de Ubuntu Server, tendrás que cargar en tu GitHub repositorio una revisión compatible con una instancia de Ubuntu Server y CodeDeploy. Para obtener más información, consulte [Planificación de una revisión de CodeDeploy](application-revisions-plan.md) y [Añadir un archivo de especificaciones de la aplicación a una revisión de CodeDeploy](application-revisions-appspec-file.md).
**Topics**
+ [Enviar una revisión de ejemplo desde una máquina local Linux, macOS o Unix](#tutorials-github-upload-sample-revision-unixes)
+ [Envío de una revisión de ejemplo desde un equipo local con Windows](#tutorials-github-upload-sample-revision-windows)
## Enviar una revisión de ejemplo desde una máquina local Linux, macOS o Unix
Con el terminal aún abierto, por ejemplo en la ubicación `/tmp/CodeDeployGitHubDemo`, ejecute sucesivamente los comandos siguientes:
**nota**
Si tiene previsto implementar en una instancia de Windows Server, sustituya `SampleApp_Windows.zip` por `SampleApp_Linux.zip` en los comandos.
```
(Amazon S3 copy command)
```
```
unzip SampleApp_Linux.zip
```
```
rm SampleApp_Linux.zip
```
```
git add .
```
```
git commit -m "Added sample app"
```
```
git push
```
¿Dónde *(Amazon S3 copy command)* está una de las siguientes opciones?
+ `aws s3 cp s3://aws-codedeploy-us-east-2/samples/latest/SampleApp_Linux.zip . --region us-east-2` para la región Este de EE. UU. (Ohio)
+ `aws s3 cp s3://aws-codedeploy-us-east-1/samples/latest/SampleApp_Linux.zip . --region us-east-1` para la región Este de EE. UU. (Norte de Virginia)
+ `aws s3 cp s3://aws-codedeploy-us-west-1/samples/latest/SampleApp_Linux.zip . --region us-west-1` para la región Oeste de EE. UU (Norte de California)
+ `aws s3 cp s3://aws-codedeploy-us-west-2/samples/latest/SampleApp_Linux.zip . --region us-west-2` para la región Oeste de EE. UU. (Oregón)
+ `aws s3 cp s3://aws-codedeploy-ca-central-1/samples/latest/SampleApp_Linux.zip . --region ca-central-1` para la región Canadá (centro)
+ `aws s3 cp s3://aws-codedeploy-eu-west-1/samples/latest/SampleApp_Linux.zip . --region eu-west-1` para la región Europa (Irlanda)
+ `aws s3 cp s3://aws-codedeploy-eu-west-2/samples/latest/SampleApp_Linux.zip . --region eu-west-2` para la región Europa (Londres)
+ `aws s3 cp s3://aws-codedeploy-eu-west-3/samples/latest/SampleApp_Linux.zip . --region eu-west-3` para la región Europa (París)
+ `aws s3 cp s3://aws-codedeploy-eu-central-1/samples/latest/SampleApp_Linux.zip . --region eu-central-1` para la región Europa (Fráncfort)
+ `aws s3 cp s3://aws-codedeploy-il-central-1/samples/latest/SampleApp_Linux.zip . --region il-central-1` para la región Israel (Tel Aviv)
+ `aws s3 cp s3://aws-codedeploy-ap-east-1/samples/latest/SampleApp_Linux.zip . --region ap-east-1` para la región Asia Pacífico (Hong Kong)
+ `aws s3 cp s3://aws-codedeploy-ap-northeast-1/samples/latest/SampleApp_Linux.zip . --region ap-northeast-1` para la región Asia-Pacífico (Tokio)
+ `aws s3 cp s3://aws-codedeploy-ap-northeast-2/samples/latest/SampleApp_Linux.zip . --region ap-northeast-2` para la región Asia-Pacífico (Seúl)
+ `aws s3 cp s3://aws-codedeploy-ap-southeast-1/samples/latest/SampleApp_Linux.zip . --region ap-southeast-1` para la región Asia-Pacífico (Singapur)
+ `aws s3 cp s3://aws-codedeploy-ap-southeast-2/samples/latest/SampleApp_Linux.zip . --region ap-southeast-2` para la región Asia-Pacífico (Sídney)
+ `aws s3 cp s3://aws-codedeploy-ap-southeast-4/samples/latest/SampleApp_Linux.zip . --region ap-southeast-4` para la región Asia-Pacífico (Melbourne)
+ `aws s3 cp s3://aws-codedeploy-ap-south-1/samples/latest/SampleApp_Linux.zip . --region ap-south-1` para la región Asia-Pacífico (Bombay)
+ `aws s3 cp s3://aws-codedeploy-sa-east-1/samples/latest/SampleApp_Linux.zip . --region sa-east-1` para la región América del Sur (São Paulo)
## Envío de una revisión de ejemplo desde un equipo local con Windows
Con el símbolo del sistema aún abierto, por ejemplo en la ubicación `c:\temp\CodeDeployGitHubDemo`, ejecute sucesivamente los comandos siguientes:
**nota**
Si tiene previsto realizar la implementación en una instancia de Amazon Linux o RHEL, sustituya `SampleApp_Linux.zip` por `SampleApp_Windows.zip` en los comandos.
```
(Amazon S3 copy command)
```
Descomprima el contenido `the` del archivo ZIP directamente en el directorio local (por ejemplo `c:\temp\CodeDeployGitHubDemo`), no en un nuevo subdirectorio.
```
git add .
```
```
git commit -m "Added sample app"
```
```
git push
```
Dónde *(Amazon S3 copy command)* está uno de los siguientes:
+ `aws s3 cp s3://aws-codedeploy-us-east-2/samples/latest/SampleApp_Windows.zip . --region us-east-2` para la región Este de EE. UU. (Ohio)
+ `aws s3 cp s3://aws-codedeploy-us-east-1/samples/latest/SampleApp_Windows.zip . --region us-east-1` para la región Este de EE. UU. (Norte de Virginia)
+ `aws s3 cp s3://aws-codedeploy-us-west-1/samples/latest/SampleApp_Windows.zip . --region us-west-1` para la región Oeste de EE. UU (Norte de California)
+ `aws s3 cp s3://aws-codedeploy-us-west-2/samples/latest/SampleApp_Windows.zip . --region us-west-2` para la región Oeste de EE. UU. (Oregón)
+ `aws s3 cp s3://aws-codedeploy-ca-central-1/samples/latest/SampleApp_Windows.zip . --region ca-central-1` para la región Canadá (centro)
+ `aws s3 cp s3://aws-codedeploy-eu-west-1/samples/latest/SampleApp_Windows.zip . --region eu-west-1` para la región Europa (Irlanda)
+ `aws s3 cp s3://aws-codedeploy-eu-west-2/samples/latest/SampleApp_Windows.zip . --region eu-west-2` para la región Europa (Londres)
+ `aws s3 cp s3://aws-codedeploy-eu-west-3/samples/latest/SampleApp_Windows.zip . --region eu-west-3` para la región Europa (París)
+ `aws s3 cp s3://aws-codedeploy-eu-central-1/samples/latest/SampleApp_Windows.zip . --region eu-central-1` para la región Europa (Fráncfort)
+ `aws s3 cp s3://aws-codedeploy-il-central-1/samples/latest/SampleApp_Windows.zip . --region il-central-1` para la región Israel (Tel Aviv)
+ `aws s3 cp s3://aws-codedeploy-ap-east-1/samples/latest/SampleApp_Windows.zip . --region ap-east-1` para la región Asia Pacífico (Hong Kong)
+ `aws s3 cp s3://aws-codedeploy-ap-northeast-1/samples/latest/SampleApp_Windows.zip . --region ap-northeast-1` para la región Asia-Pacífico (Tokio)
+ `aws s3 cp s3://aws-codedeploy-ap-northeast-2/samples/latest/SampleApp_Windows.zip . --region ap-northeast-2` para la región Asia-Pacífico (Seúl)
+ `aws s3 cp s3://aws-codedeploy-ap-southeast-1/samples/latest/SampleApp_Windows.zip . --region ap-southeast-1` para la región Asia-Pacífico (Singapur)
+ `aws s3 cp s3://aws-codedeploy-ap-southeast-2/samples/latest/SampleApp_Windows.zip . --region ap-southeast-2` para la región Asia-Pacífico (Sídney)
+ `aws s3 cp s3://aws-codedeploy-ap-southeast-4/samples/latest/SampleApp_Windows.zip . --region ap-southeast-4` para la región Asia-Pacífico (Melbourne)
+ `aws s3 cp s3://aws-codedeploy-ap-south-1/samples/latest/SampleApp_Windows.zip . --region ap-south-1` para la región Asia-Pacífico (Bombay)
+ `aws s3 cp s3://aws-codedeploy-sa-east-1/samples/latest/SampleApp_Windows.zip . --region sa-east-1` para la región América del Sur (São Paulo)
Para enviar su propia revisión a una instancia de Ubuntu Server, copie la revisión en el repositorio local y, a continuación, ejecute lo siguiente:
```
git add .
git commit -m "Added Ubuntu app"
git push
```
# Paso 4: Aprovisionar una instancia
En este paso creará o configurará la instancia en la que va a implementar la aplicación de ejemplo. Puede realizar la implementación en una instancia de Amazon EC2 o en una instancia local que ejecute uno de los sistemas operativos compatibles con. CodeDeploy Para obtener información, consulte [Sistemas operativos compatibles con el agente CodeDeploy](codedeploy-agent.md#codedeploy-agent-supported-operating-systems). (Si ya tiene una instancia configurada para su uso en CodeDeploy las implementaciones, vaya al paso siguiente).
**Para aprovisionar una instancia**
1. Siga las instrucciones de [Lanzamiento de una instancia de Amazon EC2 (consola)](instances-ec2-create.md#instances-ec2-create-console) para aprovisionar una instancia.
1. Al lanzar la instancia, no olvide especificar una etiqueta en la página **Añadir etiquetas**. Para obtener información detallada acerca de la forma de especificar la etiqueta, consulte [Lanzamiento de una instancia de Amazon EC2 (consola)](instances-ec2-create.md#instances-ec2-create-console).
**Para comprobar que el CodeDeploy agente se está ejecutando en la instancia**
+ Siga las instrucciones de [Compruebe que el CodeDeploy agente se esté ejecutando](codedeploy-agent-operations-verify.md) para comprobar que el agente se está ejecutando.
Una vez que hayas aprovisionado correctamente la instancia y hayas comprobado que el CodeDeploy agente se está ejecutando, continúa con el siguiente paso.
# Paso 5: Crear una aplicación y un grupo de implementación
En este paso, utilizará la CodeDeploy consola o la AWS CLI para crear un grupo de aplicaciones y despliegues que utilizará para implementar la revisión de muestra desde su GitHub repositorio.
## Creación de una aplicación y un grupo de implementación (consola)
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)
**nota**
Inicie sesión con el mismo usuario que configuró en [Empezar con CodeDeploy](getting-started-codedeploy.md).
1. En el panel de navegación, expanda **Implementar** y, después, elija **Aplicaciones**.
1. Seleccione **Create application (Crear aplicación)** y, a continuación, seleccione **Custom application (Aplicación personalizada)**.
1. En **Application name (Nombre de aplicación)**, escriba **CodeDeployGitHubDemo-App**.
1. En **Plataforma de informática**, elija **EC2/On-Premises**.
1. Elija **Creación de aplicación**.
1. En la pestaña **Deployment groups (Grupos de implementaciones)**, elija **Create deployment group (Crear grupo de implementaciones)**.
1. En **Nombre de grupo de implementación**, escriba **CodeDeployGitHubDemo-DepGrp**.
1. En **Función de servicio**, elige el nombre de la función de CodeDeploy servicio que creaste en [Crear una función de servicio](getting-started-create-service-role.md) para. CodeDeploy
1. En **Tipo de implementación**, elija **Local**.
1. En **Configuración de entorno**, en función del tipo de instancia que utiliza, seleccione **Instancias de Amazon EC2** o **Instancias en las instalaciones**. En **Key (Clave)** y **Value (Valor)**, escriba la clave y el valor de la etiqueta de instancia que se aplicó a la instancia como parte de [Paso 4: Aprovisionar una instancia](tutorials-github-provision-instance.md).
1. En **Configuración de despliegue**, elija **CodeDeployDefault. AllatOnce**.
1. En **Equilibrador de carga**, anule la selección de **Habilitar equilibración de carga**.
1. Expanda **Advanced (Avanzadas)**.
1. En **Alarms (Alarmas)**, seleccione **Ignore alarm configuration (Ignorar las alarmas)**.
1. Elija **Create deployment group (Crear grupo de implementaciones)** y vaya al paso siguiente.
## Creación de una aplicación y un grupo de implementaciones (CLI)
1. Ejecute el comando **create-application** para crear una aplicación de CodeDeploy denominada `CodeDeployGitHubDemo-App`:
```
aws deploy create-application --application-name CodeDeployGitHubDemo-App
```
1. Llame al comando **create-deployment-group** para crear un grupo de implementación denominado `CodeDeployGitHubDemo-DepGrp`:
+ Si va a realizar una implementación en una instancia de Amazon EC2, *ec2-tag-key* es la clave de etiqueta de la instancia de Amazon EC2 que se aplicó a su instancia de Amazon EC2 como parte de. [Paso 4: Aprovisionar una instancia](tutorials-github-provision-instance.md)
+ Si va a realizar una implementación en una instancia de Amazon EC2, *ec2-tag-value* es el valor de etiqueta de la instancia de Amazon EC2 que se aplicó a su instancia de Amazon EC2 como parte de. [Paso 4: Aprovisionar una instancia](tutorials-github-provision-instance.md)
+ Si va a realizar la implementación en una instancia local, *on-premises-tag-key* es la clave de etiqueta de la instancia local que se aplicó a la instancia local como parte de ella. [Paso 4: Aprovisionar una instancia](tutorials-github-provision-instance.md)
+ Si vas a realizar la implementación en una instancia local, *on-premises-tag-value* es el valor de etiqueta de la instancia local que se aplicó a la instancia local como parte de ella. [Paso 4: Aprovisionar una instancia](tutorials-github-provision-instance.md)
+ *service-role-arn*es el ARN del rol de servicio para el que creó en [Crear un rol de servicio](getting-started-create-service-role.md). CodeDeploy (Siga las instrucciones de [Obtención del ARN del rol de servicio (CLI)](getting-started-create-service-role.md#getting-started-get-service-role-cli) para determinar el ARN del rol de servicio).
```
aws deploy create-deployment-group --application-name CodeDeployGitHubDemo-App --ec2-tag-filters Key=ec2-tag-key,Type=KEY_AND_VALUE,Value=ec2-tag-value --on-premises-tag-filters Key=on-premises-tag-key,Type=KEY_AND_VALUE,Value=on-premises-tag-value --deployment-group-name CodeDeployGitHubDemo-DepGrp --service-role-arn service-role-arn
```
**nota**
El [create-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment-group.html)comando permite crear activadores que provoquen el envío de notificaciones de Amazon SNS a los suscriptores del tema sobre eventos específicos en implementaciones e instancias. El comando también admite opciones para revertir automáticamente las implementaciones y configurar alarmas para detener las implementaciones cuando se cumplen los umbrales de monitoreo de CloudWatch las alarmas de Amazon. Los comandos para estas acciones no se incluyen en este tutorial.
# Paso 6: Implementar la aplicación en la instancia
En este paso, utiliza la CodeDeploy consola o la AWS CLI para implementar la revisión de muestra del GitHub repositorio en la instancia.
## Para implementar la revisión (consola)
1. En la página **Deployment group details (Detalles del grupo de implementaciones)**, elija **Create deployment (Crear implementación)**.
1. En **Deployment group (Grupo de implementación)**, elija **`CodeDeployGitHubDemo-DepGrp`**.
1. En **Tipo de revisión**, elija **GitHub**.
1. En **Conectarse a GitHub**, realice una de las siguientes acciones:
+ Para crear una conexión de CodeDeploy aplicaciones a una GitHub cuenta, cierre sesión GitHub en una pestaña independiente del navegador web. En la **GitHub cuenta**, introduce un nombre para identificar esta conexión y, a continuación, selecciona **Conectar a GitHub**. La página web le pide que autorice CodeDeploy la interacción con GitHub la aplicación nombrada`CodeDeployGitHubDemo-App`. Continúe en el paso 5.
+ Para usar una conexión que ya haya creado, en la **GitHubcuenta**, seleccione su nombre y, a continuación, elija **Conectar a GitHub**. Continúe en el paso 7.
+ Para crear una conexión a otra GitHub cuenta, cierra sesión GitHub en otra pestaña del navegador web. Selecciona **Conectar a otra GitHub cuenta** y, a continuación, selecciona **Conectar a GitHub**. Continúe en el paso 5.
1. **Sigue las instrucciones de la página de inicio de sesión para iniciar sesión con tu GitHub cuenta.**
1. En la página **Authorize application**, elija **Authorize application**.
1. En la página CodeDeploy **Crear despliegue**, en **Nombre del repositorio**, introduzca el nombre de GitHub usuario que utilizó para iniciar sesión, seguido de una barra inclinada (`/`), seguido del nombre del repositorio en el que insertó la revisión de la aplicación (por ejemplo,***my-github-user-name*/CodeDeployGitHubDemo**).
Si no está seguro del valor que debe introducir o si desea especificar un repositorio diferente:
1. En una pestaña independiente del navegador web, dirígete al [GitHub panel](https://github.com/dashboard) de control.
1. En **Your repositories**, pase el cursor sobre el nombre del repositorio de destino. Aparece una descripción emergente en la que se muestra el nombre del GitHub usuario o la organización, seguido de una barra diagonal (`/`) seguida del nombre del repositorio. Escriba este valor en **Repository name (Nombre del repositorio)**.
**nota**
Si el nombre del repositorio de destino no aparece en **Tus repositorios**, usa el GitHub cuadro de **búsqueda para buscar** el repositorio de destino y el nombre del GitHub usuario u organización.
1. En el cuadro **ID de confirmación**, introduce el ID de la confirmación asociada a la transferencia de la revisión de tu aplicación a GitHub.
Si no está seguro del valor que debe introducir:
1. En otra pestaña del navegador web, ve a tu [GitHub panel de control](https://github.com/dashboard).
1. En **Your repositories (Sus repositorios)**, elija **CodeDeployGitHubDemo**.
1. En la lista de confirmaciones, busca y copia el ID de confirmación asociado al envío de la revisión de tu aplicación a GitHub. Este ID suele tener 40 caracteres y se compone de letras y números. (No utilice la versión corta del ID de confirmación, que suele ser los primeros 10 caracteres de la versión larga).
1. Pegue el ID de confirmación en el cuadro **Commit ID**.
1. Elija **Deploy** y continúe con el paso siguiente.
## Para implementar la revisión (CLI)
Antes de poder llamar a cualquier AWS CLI comando con el que interactúes GitHub (por ejemplo, el **create-deployment** comando al que llamarás a continuación), debes dar CodeDeploy permiso para usar tu cuenta de GitHub usuario con GitHub la que interactuar en la `CodeDeployGitHubDemo-App` aplicación. Actualmente esto debe hacerse en la consola de CodeDeploy .
1. Inicie sesión en [https://console.aws.amazon.com/codedeploy Consola de administración de AWS](https://console.aws.amazon.com/codedeploy) y abra la CodeDeploy consola.
**nota**
Inicie sesión con el mismo usuario que configuró en [Empezar con CodeDeploy](getting-started-codedeploy.md).
1. En el panel de navegación, expanda **Implementar** y, después, elija **Aplicaciones**.
1. Elija **CodeDeployGitHubDemo-App**.
1. En la pestaña **Implementaciones**, elija **Crear implementación**.
**nota**
No va a crear una nueva implementación. Actualmente, esta es la única forma de dar CodeDeploy permiso para interactuar GitHub en nombre de su cuenta de GitHub usuario.
1. En **el grupo de implementación**, seleccione **CodeDeployGitHubDemo- DepGrp**.
1. En **Tipo de revisión**, elija **GitHub**.
1. En **Conectarse a GitHub**, realice una de las siguientes acciones:
+ Para crear una conexión de CodeDeploy aplicaciones a una GitHub cuenta, cierre sesión GitHub en una pestaña independiente del navegador web. En **GitHub cuenta**, escriba un nombre para identificar esta conexión y, a continuación, seleccione **Conectar a GitHub**. La página web le pide que autorice CodeDeploy la interacción con GitHub la aplicación nombrada`CodeDeployGitHubDemo-App`. Continúe en el paso 8.
+ Para usar una conexión que ya haya creado, en la **GitHubcuenta**, seleccione su nombre y, a continuación, elija **Conectar a GitHub**. Continúe en el paso 10.
+ Para crear una conexión a otra GitHub cuenta, cierra sesión GitHub en otra pestaña del navegador web. Selecciona **Conectar a otra GitHub cuenta** y, a continuación, selecciona **Conectar a GitHub**. Continúe en el paso 8.
1. **Sigue las instrucciones de la página de inicio de sesión para iniciar sesión con tu nombre GitHub de usuario o correo electrónico y contraseña.**
1. En la página **Authorize application**, elija **Authorize application**.
1. En la página CodeDeploy **Crear despliegue**, selecciona **Cancelar**.
1. Ejecuta el **create-deployment** comando para implementar la revisión desde tu GitHub repositorio a la instancia, donde:
+ *repository*es el nombre de tu GitHub cuenta, seguido de una barra diagonal (`/`), seguido del nombre de tu repositorio (`CodeDeployGitHubDemo`), por ejemplo,. `MyGitHubUserName/CodeDeployGitHubDemo`
Si no está seguro del valor que debe indicar o si desea especificar un repositorio diferente:
1. [En otra pestaña del navegador web, ve a tu panel de control. GitHub ](https://github.com/dashboard)
1. En **Your repositories**, pase el cursor sobre el nombre del repositorio de destino. Aparece una descripción emergente en la que se muestra el nombre del GitHub usuario o la organización, seguido de una barra diagonal (`/`) seguida del nombre del repositorio. Este es el valor que debe usar.
**nota**
Si el nombre del repositorio de destino no aparece en **Tus repositorios**, usa el GitHub cuadro de **búsqueda para buscar** el repositorio de destino y el nombre de GitHub usuario u organización correspondiente.
+ *commit-id*es la confirmación asociada a la versión de la revisión de la aplicación que subiste a tu repositorio (por ejemplo,`f835159a...528eb76f`).
Si no está seguro del valor que debe usar:
1. En otra pestaña del navegador web, ve a tu [GitHub panel de control](https://github.com/dashboard).
1. En **Your repositories (Sus repositorios)**, elija **CodeDeployGitHubDemo**.
1. En la lista de confirmaciones, busca el ID de confirmación asociado al envío de la revisión de tu aplicación a GitHub. Este ID suele tener 40 caracteres y se compone de letras y números. (No utilice la versión corta del ID de confirmación, que suele ser los primeros 10 caracteres de la versión larga). Utilice este valor.
Si está trabajando en una máquina Linux, macOS o Unix local:
```
aws deploy create-deployment \
--application-name CodeDeployGitHubDemo-App \
--deployment-config-name CodeDeployDefault.OneAtATime \
--deployment-group-name CodeDeployGitHubDemo-DepGrp \
--description "My GitHub deployment demo" \
--github-location repository=repository,commitId=commit-id
```
Si se encuentra en un equipo local con Windows:
```
aws deploy create-deployment --application-name CodeDeployGitHubDemo-App --deployment-config-name CodeDeployDefault.OneAtATime --deployment-group-name CodeDeployGitHubDemo-DepGrp --description "My GitHub deployment demo" --github-location repository=repository,commitId=commit-id
```
# Paso 7: Monitorizar y comprobar la implementación
En este paso, utilizará la CodeDeploy consola o la AWS CLI para comprobar el éxito de la implementación. Utilizará el navegador web para ver la página implementada en la instancia que ha creado o configurado.
**nota**
Si se trata de una implementación en una instancia de Ubuntu Server, utilice su propia estrategia de pruebas para determinar si la revisión implementada funciona según lo previsto en la instancia y, a continuación, continúe en el paso siguiente.
**Para monitorizar y comprobar la implementación (consola)**
1. En el panel de navegación, expanda **Implementar** y después elija **Implementaciones**.
1. **En la lista de despliegues, busque la fila con un valor de **aplicación** de **CodeDeployGitHubDemo-App** y un valor de **grupo de despliegues** de CodeDeployGitHubDemo -. DepGrp** Si no aparece **Succeeded** o **Failed** en la columna **Status**, pulse el botón **Refresh** periódicamente.
1. Si aparece **Failed** en la columna **Status**, siga las instrucciones de [Visualización de los detalles de la instancia (consola)](instances-view-details.md#instances-view-details-console) para resolver los problemas de la implementación.
1. Si aparece **Succeeded** en la columna **Status**, ya puede comprobar la implementación en el navegador web. Nuestra revisión de ejemplo implementa una única página web en la instancia. Si la implementación es en una instancia de Amazon EC2, en el navegador web, vaya a `http://public-dns` para la instancia (por ejemplo, `http://ec2-01-234-567-890.compute-1.amazonaws.com`).
1. Si puede ver la página web, ¡enhorabuena\$1 Ahora que ha utilizado correctamente AWS CodeDeploy implementar una revisión desde GitHub, puede pasar a. [Paso 8: Eliminación](tutorials-github-clean-up.md)
**Para monitorizar y comprobar la implementación (CLI)**
1. Para obtener el ID de implementación, ejecute el comando **list-deployments** con la aplicación `CodeDeployGitHubDemo-App` y el grupo de implementaciones `CodeDeployGitHubDemo-DepGrp`:
```
aws deploy list-deployments --application-name CodeDeployGitHubDemo-App --deployment-group-name CodeDeployGitHubDemo-DepGrp --query "deployments" --output text
```
1. Ejecute el comando **get-deployment** indicando el ID de la implementación obtenido en la salida del comando **list-deployments**:
```
aws deploy get-deployment --deployment-id deployment-id --query "deploymentInfo.[status, creator]" --output text
```
1. Si el resultado es **Failed**, siga las instrucciones de [Visualización de los detalles de la instancia (consola)](instances-view-details.md#instances-view-details-console) para resolver los problemas de la implementación.
1. Si el resultado es **Succeeded**, ya puede comprobar la implementación en el navegador web. Nuestra revisión de ejemplo implementa una única página web en la instancia. Si la implementación es en una instancia de Amazon EC2, puede ver la página en el navegador web en la dirección `http://public-dns` para la instancia de Amazon EC2 (por ejemplo, `http://ec2-01-234-567-890.compute-1.amazonaws.com`).
1. Si puede ver la página web, ¡enhorabuena\$1 La has utilizado correctamente AWS CodeDeploy para realizar la implementación desde tu GitHub repositorio.
# Paso 8: Eliminación
Para evitar cargos adicionales por los recursos que ha utilizado en este tutorial, debe terminar la instancia de Amazon EC2 y sus recursos asociados. De forma opcional, puede eliminar los registros en CodeDeploy de los componentes de la implementación asociados a este tutorial. Si estabas usando un GitHub repositorio solo para este tutorial, también puedes eliminarlo ahora.
## Para eliminar una CloudFormation pila (si utilizó la CloudFormation plantilla para crear una instancia de Amazon EC2)
1. Inicie sesión en Consola de administración de AWS [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/) y abra la CloudFormation consola.
1. En la columna **Stacks** (Pilas) elija la pila que comience por `CodeDeploySampleStack`.
1. Elija **Eliminar**.
1. Cuando se le solicite, seleccione **Delete stack** (Eliminar pila). Se eliminará la instancia de Amazon EC2 y el perfil de instancia de IAM y el rol de servicio asociados.
## Para anular el registro y limpiar manualmente una instancia on-premises (si ha aprovisionado una instancia on-premises)
1. Usa el AWS CLI comando [deregister](https://docs.aws.amazon.com/cli/latest/reference/deploy/deregister.html) en la instancia local representada aquí por *your-instance-name* y en la región asociada por: *your-region*
```
aws deploy deregister --instance-name your-instance-name --no-delete-iam-user --region your-region
```
1. Desde la instancia en las instalaciones, llame al comando [uninstall](https://docs.aws.amazon.com/cli/latest/reference/deploy/uninstall.html):
```
aws deploy uninstall
```
## Para terminar manualmente una instancia de Amazon EC2 (si ha iniciado manualmente una instancia de Amazon EC2)
1. Inicie sesión en la consola Amazon EC2 Consola de administración de AWS y ábrala en. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. En el panel de navegación, bajo **Instances**, elija **Instances**.
1. Seleccione la casilla junto a la instancia de Amazon EC2 que desea terminar. En el menú **Actions**, seleccione **Instance State** y elija **Terminate**.
1. Cuando se le pregunte, elija **Yes, Terminate**.
## Para eliminar los registros de los componentes CodeDeploy de despliegue
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).
**nota**
Inicie sesión con el mismo usuario que configuró en [Empezar con CodeDeploy](getting-started-codedeploy.md).
1. En el panel de navegación, expanda **Implementar** y, después, elija **Aplicaciones**.
1. Elija **CodeDeployGitHubDemo-App**.
1. Elija **Eliminar aplicación**.
1. Cuando se le pregunte, escriba **Delete** y, a continuación, elija **Delete (Eliminar)**.
## Para eliminar tu repositorio GitHub
Consulte [Eliminar un repositorio](https://help.github.com/articles/deleting-a-repository/) en la [GitHub ayuda](https://help.github.com).
# Tutorial: Implementación de una aplicación en Amazon ECS
En este tutorial, aprenderá a implementar una aplicación en Amazon ECS mediante CodeDeploy. Comience con una aplicación que ya creó e implementó en Amazon ECS. El primer paso consiste en actualizar la aplicación modificando su archivo de definición de tareas con una nueva etiqueta. A continuación, debe CodeDeploy implementar la actualización. Durante la implementación, CodeDeploy instala la actualización en un nuevo conjunto de tareas de reemplazo. A continuación, desvía el tráfico de producción de la versión original del servicio de Amazon ECS, que se encuentra en su conjunto de tareas original, a la versión actualizada en el conjunto de tareas de sustitución.
Durante una implementación de Amazon ECS, CodeDeploy utiliza un balanceador de carga que está configurado con dos grupos de destino y un detector de tráfico de producción. En el siguiente diagrama se muestra cómo están relacionados el equilibrador de carga, el oyente de producción, 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.
![\[El Equilibrador de carga de aplicación o el Equilibrador de carga de red, un oyente de producción, dos grupos de destino, un conjunto de tareas y un servicio de Amazon ECS.\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/images/codedeploy-ecs-deployment-with-no-test-listener-step-1.png)
Después de una implementación correcta, el oyente 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).
![\[El Equilibrador de carga de aplicación o el Equilibrador de carga de red, un oyente de producción, dos grupos de destino y un conjunto de tareas de sustitución.\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/images/codedeploy-ecs-deployment-with-no-test-listener-step-5.png)
Para obtener información sobre cómo utilizarla AWS CLI para implementar una aplicación en Amazon ECS, consulte el [Tutorial: Creación de un servicio mediante una blue/green implementación](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-blue-green.html). Para obtener información sobre cómo detectar e implementar automáticamente los cambios en un servicio de Amazon ECS CodeDeploy, consulte el [tutorial: Crear una canalización con una fuente e ECS-to-CodeDeploy implementación de Amazon ECR](https://docs.aws.amazon.com/codepipeline/latest/userguide/tutorials-ecs-ecr-codedeploy.html). CodePipeline
Tras completar este tutorial, puede utilizar el grupo de CodeDeploy aplicaciones y despliegues que creó para añadir una prueba de validación de despliegues. [Tutorial: Implementación de un servicio de Amazon ECS con una prueba de validación](tutorial-ecs-deployment-with-hooks.md)
**Topics**
+ [Requisitos previos](tutorial-ecs-prereqs.md)
+ [Paso 2: Actualizar la aplicación de Amazon ECS](tutorial-ecs-update-the-ecs-application.md)
+ [Paso 2: Crea el AppSpec archivo](tutorial-ecs-create-appspec-file.md)
+ [Paso 3: Utilice la CodeDeploy consola para implementar la aplicación](tutorial-ecs-deployment-deploy.md)
+ [Paso 4: Limpiar](tutorial-ecs-clean-up.md)
# Requisitos previos
Para completar este tutorial, primero debe:
+ Completar los pasos 2 y 3 de [Empezar con CodeDeploy](getting-started-codedeploy.md).
+ Crear un equilibrador de carga de aplicación configurado con dos grupos de destino y un oyente. Para obtener información sobre la creación un balanceador de carga mediante la consola, consulte [Configure un balanceador de carga, grupos objetivo y agentes de escucha para las implementaciones de CodeDeploy Amazon ECS](deployment-groups-create-load-balancer-for-ecs.md). Para obtener información sobre cómo crear un balanceador de carga mediante el AWS CLI, consulte el [paso 1: Crear un balanceador de carga de aplicaciones](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-blue-green.html#create-blue-green-loadbalancer) en la Guía del usuario de *Amazon Elastic Container Service*. Cuando cree el equilibrador de carga, anote lo siguiente para este tutorial:
+ Nombre del balanceador de carga.
+ Los nombres de los grupos de destino.
+ El puerto utilizado por el agente de escucha del balanceador de carga.
+ Cree un clúster y servicio de Amazon ECS. Para obtener más información, consulte los pasos 2, 3 y 4 del [tutorial: Creación de un servicio mediante una blue/green implementación](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-blue-green.html) en la *Guía del usuario de Amazon Elastic Container Service*. Anote lo siguiente para este tutorial:
+ El nombre de su clúster de Amazon ECS.
+ El ARN de la definición de tarea utilizada por el servicio de Amazon ECS.
+ El nombre del contenedor utilizado por el servicio de Amazon ECS.
+ Cree un bucket de Amazon S3 para su AppSpec archivo.
# Paso 2: Actualizar la aplicación de Amazon ECS
En esta sección, actualizará la aplicación de Amazon ECS con una nueva revisión de su definición de tarea. La revisión actualizada añade un nuevo par de claves y etiquetas. En [Paso 3: Utilice la CodeDeploy consola para implementar la aplicación](tutorial-ecs-deployment-deploy.md), implemente la versión actualizada de la aplicación de Amazon ECS.
**Para actualizar la definición de tarea, realice el siguiente procedimiento:**
1. Abra la consola en la [https://console.aws.amazon.com/ecs/versión 2](https://console.aws.amazon.com/ecs/v2).
1. En el panel de navegación, elija **Task Definitions**.
1. Elija la definición de tarea utilizada por el servicio de Amazon ECS.
1. Seleccione la revisión de la definición de tarea y, a continuación, elija **Crear nueva revisión** y **Crear nueva revisión**.
1. En este tutorial, 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 **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 lo siguiente, ya que necesitará esa información en el siguiente paso.
+ 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.
+ En el elemento `containerDefinitions`, el valor de `name`. Este es el nombre del contenedor.
+ En el elemento `portMappings`, el valor de `containerPort`. Este es el puerto del contenedor.
# Paso 2: Crea el AppSpec archivo
En esta sección, crea el AppSpec archivo y lo carga en el bucket de Amazon S3 que creó en la [Requisitos previos](tutorial-ecs-prereqs.md) sección. El AppSpec archivo de una implementación de Amazon ECS especifica la definición de la tarea, el nombre del contenedor y el puerto del contenedor. Para obtener más información, consulte [AppSpec Ejemplo de archivo para una implementación de Amazon ECS](reference-appspec-file-example.md#appspec-file-example-ecs) y [AppSpec sección de «recursos» para las implementaciones de Amazon ECS](reference-appspec-file-structure-resources.md#reference-appspec-file-structure-resources-ecs).
**Para crear su AppSpec archivo**
1. Si quieres crear tu AppSpec archivo con YAML, crea un archivo con el nombre`appspec.yml`. Si quieres crear tu AppSpec archivo con JSON, crea un archivo con el nombre`appspec.json`.
1. Elige la pestaña adecuada, dependiendo de si usas YAML o JSON para tu AppSpec archivo, y copia su contenido en el AppSpec archivo que acabas de crear. Para la propiedad `TaskDefinition`, utilice el ARN de definición de tarea que anotó en la sección [Paso 2: Actualizar la aplicación de Amazon ECS](tutorial-ecs-update-the-ecs-application.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": "your-container-name",
"ContainerPort": your-container-port
}
}
}
}
]
}
```
------
#### [ 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: "your-container-name"
ContainerPort: your-container-port
```
------
**nota**
El conjunto de tareas de sustitución hereda la subred, el grupo de seguridad, la versión de la plataforma y los valores de IP públicas asignados del conjunto de tareas original. Puedes anular estos valores para tu conjunto de tareas de reemplazo configurando sus propiedades opcionales en el archivo. AppSpec Para obtener más información, consulte [AppSpec sección de «recursos» para las implementaciones de Amazon ECS](reference-appspec-file-structure-resources.md#reference-appspec-file-structure-resources-ecs) y [AppSpec Ejemplo de archivo para una implementación de Amazon ECS](reference-appspec-file-example.md#appspec-file-example-ecs).
1. Cargue el AppSpec archivo en el depósito de S3 que creó como requisito previo para este tutorial.
# Paso 3: Utilice la CodeDeploy consola para implementar la aplicación
En esta sección, creará un grupo de CodeDeploy aplicaciones y despliegues para implementar la aplicación actualizada en Amazon ECS. Durante la implementación, CodeDeploy traslada el tráfico de producción de la aplicación a su nueva versión en un nuevo conjunto de tareas de reemplazo. Para completar este paso, necesita lo siguiente:
+ El nombre de su clúster de Amazon ECS.
+ El nombre de servicio de Amazon ECS.
+ El nombre del equilibrador de carga de aplicación
+ El puerto del agente de escucha de producción.
+ Los nombres de grupo de destino.
+ El nombre del bucket de S3 que creó.
**Para crear una CodeDeploy aplicación**
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. Elija **Creación de aplicación**.
1. En **Application name (Nombre de aplicación)**, escriba **ecs-demo-codedeploy-app**.
1. En **Compute platform (Plataforma de computación)**, elija **Amazon ECS**.
1. Elija **Creación de aplicación**.
**Para crear un grupo CodeDeploy de implementación**
1. En la pestaña **Grupos de implementación** de la página de la aplicación, elija **Crear grupo de implementación**.
1. En **Nombre de grupo de implementación**, escriba **ecs-demo-dg**.
1. En **Función de servicio**, elija una función de servicio que conceda CodeDeploy acceso a Amazon ECS. Para obtener más información, consulte [Gestión de identidad y acceso para AWS CodeDeploy](security-iam.md).
1. En **Configuración de entorno**, elija el nombre del clúster y el nombre del servicio de Amazon ECS.
1. En **Equilibradores de carga**, seleccione el nombre del equilibrador de carga que envía tráfico a su servicio de Amazon ECS.
1. En **Puerto del oyente de producción**, elija el puerto y el protocolo del oyente que envía tráfico de producción a su servicio de Amazon ECS (por ejemplo, **HTTP: 80**). Este tutorial no incluye un oyente de prueba opcional, por lo que no elija un puerto en **Puerto de oyente de prueba**.
1. En **Target group 1 name** (Nombre de grupo de destino 1) y **Target group 2 name** (Nombre de grupo de destino 2), elija dos grupos de destino diferentes para dirigir el tráfico durante su implementación. Asegúrese de que se trata de los grupos de destino que ha creado para el equilibrador de carga. No importa el que se utilice para el grupo de destino 1 y el que se utilice para el grupo de destino 2.
1. Elija **Reroute traffic immediately** (Redirigir el tráfico de forma inmediata).
1. En **Original revision termination** (Terminación de revisión original), elija 0 days (0 días), 0 hours (0 horas) y 5 minutes (5 minutos). Esto le permite ver que la implementación se completa más rápido que si utiliza el valor predeterminado (1 hora).
![\[La sección de configuración del entorno de la CodeDeploy consola.\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/images/ecs-demo-create-acd-dg.png)
1. Elija **Crear grupo de implementación**.
**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 **Revision location** (Ubicación de la revisión), escriba el nombre de su bucket de S3.
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**.
1. En **Deployment status** (Estado de implementación), puede monitorizar la implementación. Después de que el 100 % del tráfico de producción se dirija al conjunto de tareas de sustitución y antes de que transcurra el tiempo de espera de cinco minutos, 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 que transcurra el tiempo de espera de cinco minutos especificado.
![\[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-without-test-listener.png)
# Paso 4: Limpiar
El siguiente tutorial, [Tutorial: Implementación de un servicio de Amazon ECS con una prueba de validación](tutorial-ecs-deployment-with-hooks.md), se basa en este tutorial y utiliza la aplicación de CodeDeploy y el grupo de implementaciones que ha creado. Si desea seguir los pasos de ese tutorial, omita este paso y no elimine los recursos que ha creado.
**nota**
Su AWS cuenta no incurre en cargos por los CodeDeploy recursos que creó.
Los nombres de los recursos en estos pasos 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.
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-codedeploy-app --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-codedeploy-app --region aws-region-id
```
# 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
```
# Tutorial: Implemente una función Lambda actualizada con CodeDeploy y el modelo de aplicaciones AWS sin servidor
AWS SAM es un marco de código abierto para crear aplicaciones sin servidor. Transforma y expande la sintaxis YAML de una AWS SAM plantilla en CloudFormation sintaxis para crear aplicaciones sin servidor, como una función Lambda. Para obtener más información, consulte [¿Qué es AWS Serverless Application Model?](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html).
En este tutorial, usará AWS SAM para crear una solución que haga lo siguiente:
+ Crea una función de Lambda.
+ Crea el grupo CodeDeploy de aplicaciones y despliegues.
+ Crea dos funciones Lambda que ejecutan pruebas de validación de despliegue durante los enlaces CodeDeploy del ciclo de vida.
+ Detecta cuándo se actualiza la función de Lambda. La actualización de la función Lambda desencadena un despliegue CodeDeploy que desplaza gradualmente el tráfico de producción de la versión original de la función Lambda a la versión actualizada.
**nota**
Este tutorial requiere que cree recursos que podrían dar lugar a cargos en su cuenta de AWS . Estos incluyen posibles cargos para CodeDeploy Amazon CloudWatch y AWS Lambda. Para obtener más información, consulta [CodeDeploy precios](https://aws.amazon.com/codedeploy/pricing/), [ CloudWatch precios de Amazon](https://aws.amazon.com/cloudwatch/pricing/) y [AWS Lambda precios](https://aws.amazon.com/lambda/pricing/).
**Topics**
+ [Requisitos previos](tutorial-lambda-sam-prereqs.md)
+ [Paso 1: Configurar la infraestructura](tutorial-lambda-sam-setup-infrastructure.md)
+ [Paso 2: Actualizar la función de Lambda](tutorial-lambda-sam-update-function.md)
+ [Paso 3: Implementar la función de Lambda actualizada](tutorial-lambda-sam-deploy-update.md)
+ [Paso 4: Visualizar los resultados de la implementación](tutorial-lambda-sam-deploy-view-results.md)
+ [Paso 5: Eliminar](tutorial-lambda-clean-up.md)
# Requisitos previos
Para completar este tutorial, primero debe:
+ Realice los pasos que se indican en [Empezar con CodeDeploy](getting-started-codedeploy.md).
+ Instale la AWS Serverless Application Model CLI. Para obtener más información, consulte [Instalación de la CLI de AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html).
+ Cree un bucket de S3. AWS SAM carga los artefactos a los que se hace referencia en la [plantilla de AWS SAM](https://docs.aws.amazon.com/en_us/codedeploy/latest/userguide/tutorial-lambda-sam-template.html) en este depósito.
# Paso 1: Configurar la infraestructura
En este tema, se muestra cómo AWS SAM crear archivos para la AWS SAM plantilla y las funciones de Lambda. A continuación, utilice los `deploy` comandos AWS SAM `package` y para generar los componentes de su infraestructura. Cuando la infraestructura esté lista, dispondrá de un grupo de CodeDeploy aplicaciones y despliegues, la función Lambda para actualizar e implementar y dos funciones Lambda que contienen pruebas de validación que se ejecutan al implementar la función Lambda. Cuando haya terminado, puede utilizarlos CloudFormation para ver los componentes en la consola de Lambda o AWS CLI para probar la función Lambda.
**Topics**
+ [Creación de archivos](tutorial-lambda-create-files.md)
+ [Package la aplicación AWS SAM](tutorial-lambda-sam-package.md)
+ [Implemente la aplicación AWS SAM](tutorial-lambda-sam-deploy.md)
+ [Inspección y prueba de la infraestructura (opcional)](tutorial-lambda-sam-confirm-components.md)
# Creación de archivos
Para crear su infraestructura, debe crear los siguientes archivos:
+ `template.yml`
+ `myDateTimeFunction.js`
+ `beforeAllowTraffic.js`
+ `afterAllowTraffic.js`
**Topics**
+ [Cree su plantilla SAM AWS](tutorial-lambda-sam-template.md)
+ [Creación de un archivo para la función de Lambda](tutorial-lambda-sam-create-lambda-function.md)
+ [Cree un archivo para su función BeforeAllowTraffic Lambda](tutorial-lambda-sam-create-lambda-before-traffic.md)
+ [Cree un archivo para su función AfterAllowTraffic Lambda](tutorial-lambda-sam-create-lambda-after-traffic.md)
# Cree su plantilla SAM AWS
Cree un archivo de plantilla AWS SAM que especifique los componentes de su infraestructura.
**Para crear su plantilla AWS SAM**
1. Cree un directorio llamado `SAM-Tutorial`.
1. En el directorio `SAM-Tutorial`, cree un archivo denominado `template.yml`.
1. Copie el código YAML siguiente en `template.yml`. Esta es la plantilla de AWS SAM .
```
AWSTemplateFormatVersion : '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: A sample SAM template for deploying Lambda functions.
Resources:
# Details about the myDateTimeFunction Lambda function
myDateTimeFunction:
Type: AWS::Serverless::Function
Properties:
Handler: myDateTimeFunction.handler
Runtime: nodejs18.x
# Instructs your myDateTimeFunction is published to an alias named "live".
AutoPublishAlias: live
# Grants this function permission to call lambda:InvokeFunction
Policies:
- Version: "2012-10-17"
Statement:
- Effect: "Allow"
Action:
- "lambda:InvokeFunction"
Resource: '*'
DeploymentPreference:
# Specifies the deployment configuration
Type: Linear10PercentEvery1Minute
# Specifies Lambda functions for deployment lifecycle hooks
Hooks:
PreTraffic: !Ref beforeAllowTraffic
PostTraffic: !Ref afterAllowTraffic
# Specifies the BeforeAllowTraffic lifecycle hook Lambda function
beforeAllowTraffic:
Type: AWS::Serverless::Function
Properties:
Handler: beforeAllowTraffic.handler
Policies:
- Version: "2012-10-17"
# Grants this function permission to call codedeploy:PutLifecycleEventHookExecutionStatus
Statement:
- Effect: "Allow"
Action:
- "codedeploy:PutLifecycleEventHookExecutionStatus"
Resource:
!Sub 'arn:aws:codedeploy:${AWS::Region}:${AWS::AccountId}:deploymentgroup:${ServerlessDeploymentApplication}/*'
- Version: "2012-10-17"
# Grants this function permission to call lambda:InvokeFunction
Statement:
- Effect: "Allow"
Action:
- "lambda:InvokeFunction"
Resource: !Ref myDateTimeFunction.Version
Runtime: nodejs18.x
# Specifies the name of the Lambda hook function
FunctionName: 'CodeDeployHook_beforeAllowTraffic'
DeploymentPreference:
Enabled: false
Timeout: 5
Environment:
Variables:
NewVersion: !Ref myDateTimeFunction.Version
# Specifies the AfterAllowTraffic lifecycle hook Lambda function
afterAllowTraffic:
Type: AWS::Serverless::Function
Properties:
Handler: afterAllowTraffic.handler
Policies:
- Version: "2012-10-17"
Statement:
# Grants this function permission to call codedeploy:PutLifecycleEventHookExecutionStatus
- Effect: "Allow"
Action:
- "codedeploy:PutLifecycleEventHookExecutionStatus"
Resource:
!Sub 'arn:aws:codedeploy:${AWS::Region}:${AWS::AccountId}:deploymentgroup:${ServerlessDeploymentApplication}/*'
- Version: "2012-10-17"
Statement:
# Grants this function permission to call lambda:InvokeFunction
- Effect: "Allow"
Action:
- "lambda:InvokeFunction"
Resource: !Ref myDateTimeFunction.Version
Runtime: nodejs18.x
# Specifies the name of the Lambda hook function
FunctionName: 'CodeDeployHook_afterAllowTraffic'
DeploymentPreference:
Enabled: false
Timeout: 5
Environment:
Variables:
NewVersion: !Ref myDateTimeFunction.Version
```
Esta plantilla especifica lo siguiente. Para obtener más información, consulte [Conceptos de la plantilla de AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-basics.html).
**Una función de Lambda llamada `myDateTimeFunction`**
Cuando se publica esta función de Lambda, la línea `AutoPublishAlias` de la plantilla la vincula a un alias denominado `live`. Más adelante en este tutorial, una actualización de esta función desencadena una implementación AWS CodeDeploy que desplaza gradualmente el tráfico de producción de la versión original a la versión actualizada.
**Dos funciones de validación de implementación de Lambda**
Las siguientes funciones de Lambda se ejecutan durante los enlaces CodeDeploy del ciclo de vida. Las funciones contienen código que valida la implementación de `myDateTimeFunction` actualizado. El resultado de las pruebas de validación se transfiere a CodeDeploy utilizando su método de la API de `PutLifecycleEventHookExecutionStatus`. Si la prueba de validación falla, se produce un error en la implementación y se revisa.
+ `CodeDeployHook_beforeAllowTraffic` se ejecuta durante el enlace de `BeforeAllowTraffic`.
+ `CodeDeployHook_afterAllowTraffic` se ejecuta durante el enlace de `AfterAllowTraffic`.
El nombre de ambas funciones comienza por `CodeDeployHook_`. El rol de `CodeDeployRoleForLambda` permite llamadas al método de `invoke` de Lambda solo en funciones de Lambda con nombres que comienzan con este prefijo. Para obtener más información consulte [AppSpec sección de «ganchos» para una implementación de AWS Lambda](reference-appspec-file-structure-hooks.md#appspec-hooks-lambda) y [PutLifecycleEventHookExecutionStatus](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_PutLifecycleEventHookExecutionStatus.html) en la *Referencia de la API de CodeDeploy *.
**Detección automática de una función de Lambda actualizada**
El término `AutoPublishAlias` indica al marco de trabajo que detecte cuándo cambia la función de `myDateTimeFunction` y, a continuación, la implementa con el alias `live`.
**Una configuración de implementación**
La configuración de despliegue determina la velocidad a la que la CodeDeploy aplicación desplaza el tráfico de la versión original de la función Lambda a la nueva versión. Esta plantilla especifica la configuración de implementación predefinida `Linear10PercentEvery1Minute`.
No puede especificar una configuración de despliegue personalizada en una plantilla de AWS SAM. Para obtener más información, consulte [Cree una configuración de despliegue con CodeDeploy](deployment-configurations-create.md).
**Funciones de enlace de ciclo de vida de implementación**
La sección `Hooks` especifica las funciones que se van a ejecutar durante los enlaces de eventos del ciclo de vida. `PreTraffic` especifica la función que se ejecuta durante el enlace `BeforeAllowTraffic`. `PostTraffic` especifica la función que se ejecuta durante el enlace `AfterAllowTraffic`.
**Permisos para que Lambda invoque otra función de Lambda**
El `lambda:InvokeFunction` permiso especificado otorga permiso al rol utilizado por la aplicación AWS SAM para invocar una función Lambda. Esto es necesario cuando las funciones `CodeDeployHook_beforeAllowTraffic` y `CodeDeployHook_afterAllowTraffic` invocan la función de Lambda implementada durante las pruebas de validación.
# Creación de un archivo para la función de Lambda
Cree el archivo para la función que actualizará e implementará más adelante en este tutorial.
**nota**
Una función de Lambda puede utilizar cualquier tiempo de ejecución admitido por AWS Lambda. Para obtener más información, consulte [Tiempos de ejecución de AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html).
**Para crear una función de Lambda**
1. Cree un archivo de texto y guárdelo como `myDateTimeFunction.js` en el directorio `SAM-Tutorial`.
1. Copie el siguiente código Node.js en `myDateTimeFunction.js`.
```
'use strict';
exports.handler = function(event, context, callback) {
if (event.body) {
event = JSON.parse(event.body);
}
var sc; // Status code
var result = ""; // Response payload
switch(event.option) {
case "date":
switch(event.period) {
case "yesterday":
result = setDateResult("yesterday");
sc = 200;
break;
case "today":
result = setDateResult();
sc = 200;
break;
case "tomorrow":
result = setDateResult("tomorrow");
sc = 200;
break;
default:
result = {
"error": "Must specify 'yesterday', 'today', or 'tomorrow'."
};
sc = 400;
break;
}
break;
/* Later in this tutorial, you update this function by uncommenting
this section. The framework created by AWS SAM detects the update
and triggers a deployment by CodeDeploy. The deployment shifts
production traffic to the updated version of this function.
case "time":
var d = new Date();
var h = d.getHours();
var mi = d.getMinutes();
var s = d.getSeconds();
result = {
"hour": h,
"minute": mi,
"second": s
};
sc = 200;
break;
*/
default:
result = {
"error": "Must specify 'date' or 'time'."
};
sc = 400;
break;
}
const response = {
statusCode: sc,
headers: { "Content-type": "application/json" },
body: JSON.stringify( result )
};
callback(null, response);
function setDateResult(option) {
var d = new Date(); // Today
var mo; // Month
var da; // Day
var y; // Year
switch(option) {
case "yesterday":
d.setDate(d.getDate() - 1);
break;
case "tomorrow":
d.setDate(d.getDate() + 1);
default:
break;
}
mo = d.getMonth() + 1; // Months are zero offset (0-11)
da = d.getDate();
y = d.getFullYear();
result = {
"month": mo,
"day": da,
"year": y
};
return result;
}
};
```
La función de Lambda devuelve el día, el mes y el año de ayer, hoy o mañana. Más adelante en este tutorial, quite el comentario del código que actualiza la función para devolver información sobre el día o la hora que especifique (por ejemplo, el día, el mes y el año, o la hora, minuto y segundo actuales). El marco creado por AWS SAM detecta e implementa la versión actualizada de la función.
**nota**
Esta función Lambda también se utiliza en un AWS Cloud9 tutorial. AWS Cloud9 es un entorno de desarrollo integrado basado en la nube. Para obtener información sobre cómo crear, ejecutar, actualizar y depurar esta función en AWS Cloud9, consulte el [AWS Lambda tutorial de AWS Cloud9](https://docs.aws.amazon.com/cloud9/latest/user-guide/tutorial-lambda.html).
# Cree un archivo para su función BeforeAllowTraffic Lambda
Cree el archivo para la función de Lambda del enlace `beforeAllowTraffic`.
1. Cree un archivo de texto y guárdelo como `beforeAllowTraffic.js` en el directorio `SAM-Tutorial`.
1. Copie el siguiente código Node.js en `beforeAllowTraffic.js`. Esta función se ejecuta durante el enlace `BeforeAllowTraffic` de la implementación.
```
'use strict';
const AWS = require('aws-sdk');
const codedeploy = new AWS.CodeDeploy({apiVersion: '2014-10-06'});
var lambda = new AWS.Lambda();
exports.handler = (event, context, callback) => {
console.log("Entering PreTraffic Hook!");
// Read the DeploymentId and LifecycleEventHookExecutionId from the event payload
var deploymentId = event.DeploymentId;
var lifecycleEventHookExecutionId = event.LifecycleEventHookExecutionId;
var functionToTest = process.env.NewVersion;
console.log("BeforeAllowTraffic hook tests started");
console.log("Testing new function version: " + functionToTest);
// Create parameters to pass to the updated Lambda function that
// include the newly added "time" option. If the function did not
// update, then the "time" option is invalid and function returns
// a statusCode of 400 indicating it failed.
var lambdaParams = {
FunctionName: functionToTest,
Payload: "{\"option\": \"time\"}",
InvocationType: "RequestResponse"
};
var lambdaResult = "Failed";
// Invoke the updated Lambda function.
lambda.invoke(lambdaParams, function(err, data) {
if (err){ // an error occurred
console.log(err, err.stack);
lambdaResult = "Failed";
}
else{ // successful response
var result = JSON.parse(data.Payload);
console.log("Result: " + JSON.stringify(result));
console.log("statusCode: " + result.statusCode);
// Check if the status code returned by the updated
// function is 400. If it is, then it failed. If
// is not, then it succeeded.
if (result.statusCode != "400"){
console.log("Validation succeeded");
lambdaResult = "Succeeded";
}
else {
console.log("Validation failed");
}
// Complete the PreTraffic Hook by sending CodeDeploy the validation status
var params = {
deploymentId: deploymentId,
lifecycleEventHookExecutionId: lifecycleEventHookExecutionId,
status: lambdaResult // 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("CodeDeploy Status update failed");
console.log(err, err.stack);
callback("CodeDeploy Status update failed");
} else {
// Validation succeeded.
console.log("CodeDeploy status updated successfully");
callback(null, "CodeDeploy status updated successfully");
}
});
}
});
}
```
# Cree un archivo para su función AfterAllowTraffic Lambda
Cree el archivo para la función de Lambda del enlace `afterAllowTraffic`.
1. Cree un archivo de texto y guárdelo como `afterAllowTraffic.js` en el directorio `SAM-Tutorial`.
1. Copie el siguiente código Node.js en `afterAllowTraffic.js`. Esta función se ejecuta durante el enlace `AfterAllowTraffic` de la implementación.
```
'use strict';
const AWS = require('aws-sdk');
const codedeploy = new AWS.CodeDeploy({apiVersion: '2014-10-06'});
var lambda = new AWS.Lambda();
exports.handler = (event, context, callback) => {
console.log("Entering PostTraffic Hook!");
// Read the DeploymentId and LifecycleEventHookExecutionId from the event payload
var deploymentId = event.DeploymentId;
var lifecycleEventHookExecutionId = event.LifecycleEventHookExecutionId;
var functionToTest = process.env.NewVersion;
console.log("AfterAllowTraffic hook tests started");
console.log("Testing new function version: " + functionToTest);
// Create parameters to pass to the updated Lambda function that
// include the original "date" parameter. If the function did not
// update as expected, then the "date" option might be invalid. If
// the parameter is invalid, the function returns
// a statusCode of 400 indicating it failed.
var lambdaParams = {
FunctionName: functionToTest,
Payload: "{\"option\": \"date\", \"period\": \"today\"}",
InvocationType: "RequestResponse"
};
var lambdaResult = "Failed";
// Invoke the updated Lambda function.
lambda.invoke(lambdaParams, function(err, data) {
if (err){ // an error occurred
console.log(err, err.stack);
lambdaResult = "Failed";
}
else{ // successful response
var result = JSON.parse(data.Payload);
console.log("Result: " + JSON.stringify(result));
console.log("statusCode: " + result.statusCode);
// Check if the status code returned by the updated
// function is 400. If it is, then it failed. If
// is not, then it succeeded.
if (result.statusCode != "400"){
console.log("Validation of time parameter succeeded");
lambdaResult = "Succeeded";
}
else {
console.log("Validation failed");
}
// Complete the PostTraffic Hook by sending CodeDeploy the validation status
var params = {
deploymentId: deploymentId,
lifecycleEventHookExecutionId: lifecycleEventHookExecutionId,
status: lambdaResult // 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("CodeDeploy Status update failed");
console.log(err, err.stack);
callback("CodeDeploy Status update failed");
} else {
// Validation succeeded.
console.log("CodeDeploy status updated successfully");
callback(null, "CodeDeploy status updated successfully");
}
});
}
});
}
```
# Package la aplicación AWS SAM
Ahora debería tener cuatro archivos en su directorio `SAM-Tutorial`:
+ `beforeAllowTraffic.js`
+ `afterAllowTraffic.js`
+ `myDateTimeFunction.js`
+ `template.yml`
Ahora está listo para usar el **sam package** comando AWS SAM para crear y empaquetar artefactos para sus funciones y CodeDeploy aplicaciones de Lambda. Los artefactos se cargan en un bucket de S3. El resultado del comando es un nuevo archivo llamado `package.yml`. El **sam deploy** comando AWS SAM utilizará este archivo en el siguiente paso.
**nota**
Para obtener más información sobre el comando **sam package**, consulte la [Referencia de la CLI de AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-command-reference.html) en la *Guía para desarrolladores de AWS Serverless Application Model *.
En el directorio `SAM-Tutorial`, ejecute el siguiente elemento.
```
sam package \
--template-file template.yml \
--output-template-file package.yml \
--s3-bucket amzn-s3-demo-bucket
```
Para el parámetro `s3-bucket`, especifique el bucket de Amazon S3 que ha creado como requisito previo para este tutorial. `output-template-file`Especifica el nombre del nuevo archivo que utiliza el **sam deploy** comando AWS SAM.
# Implemente la aplicación AWS SAM
Utilice el **sam deploy** comando AWS SAM con el `package.yml` archivo para crear sus funciones Lambda y su grupo de CodeDeploy aplicaciones y despliegues mediante. CloudFormation
**nota**
Para obtener más información sobre el comando **sam deploy**, consulte la [Referencia de la CLI de AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-command-reference.html) en la *Guía para desarrolladores de AWS Serverless Application Model *.
En el directorio `SAM-Tutorial`, ejecute el siguiente comando.
```
sam deploy \
--template-file package.yml \
--stack-name my-date-time-app \
--capabilities CAPABILITY_IAM
```
El parámetro `--capabilities CAPABILITY_IAM` es necesario para autorizar a CloudFormation a crear roles de IAM.
# Inspección y prueba de la infraestructura (opcional)
En este tema se muestra cómo ver los componentes de la infraestructura y probar la función de Lambda.
**Para ver el resultado de la pila después de ejecutar `sam deploy`, realice el siguiente procedimiento:**
1. Abra la CloudFormation consola en [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. En el panel de navegación, seleccione **Stacks** (Pilas). La pila `my-date-time-app` aparece en la parte superior.
1. Elija la pestaña **Events** (Eventos) para ver qué eventos se han completado. Puede ver los eventos mientras la creación de la pila está en curso. Cuando se haya completado la creación de la pila, podrá ver todos los eventos de creación esta.
1. Con la pila seleccionada, elija **Resources** (Recursos). En la columna **Tipo**, puede ver las funciones de Lambda `myDateTimeFunction`, `CodeDeployHook_beforeAllowTraffic` y `CodeDeployHook_afterAllowTraffic`. La columna **ID físico** de cada una de las funciones de Lambda contiene un enlace para ver las funciones en la consola de Lambda.
**nota**
El nombre de la función `myDateTimeFunction` Lambda va precedido del nombre de la CloudFormation pila y se le ha añadido un identificador, por lo que parece. `my-date-time-app-myDateTimeFunction-123456ABCDEF`
1. Abre la consola en CodeDeploy . [https://console.aws.amazon.com/codedeploy/](https://console.aws.amazon.com/codedeploy/)
1. En el panel de navegación, expanda **Deploy (Implementar)** y después elija **Applications (Aplicaciones)**.
1. Debería ver una nueva CodeDeploy aplicación creada por CloudFormation con un nombre que comience por`my-date-time-app-ServerlessDeploymentApplication`. Elija esta aplicación.
1. Debería ver un grupo de implementaciones con un nombre que comienza por `my-date-time-app-myDateTimeFunctionDeploymentGroup`. Elija este grupo de implementaciones.
En **Configuración de despliegue**, deberías ver **CodeDeployDefault. LambdaLinear10 PercentEvery 1 minuto.**
**Para probar la función (consola) (opcional)**
1. Abre la AWS Lambda consola en. [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/)
1. En el panel de navegación, elija la función `my-date-time-app-myDateTimeFunction`. En la consola, su nombre contiene un identificador, por lo que tendrá un aspecto similar a `my-date-time-app-myDateTimeFunction-123456ABCDEF`.
1. Seleccione **Probar**
1. En **Event name** (Nombre del evento), escriba un nombre para el evento de prueba.
1. Escriba lo siguiente para el evento de prueba y, a continuación, elija **Create** (Crear).
```
{
"option": "date",
"period": "today"
}
```
1. Seleccione **Probar** Solo debería ver el evento de prueba en la lista de eventos de prueba.
En **Execution result** (Resultado de ejecución), debería ver **succeeded** (correcto).
1. En **Execution result** (Resultado de ejecución), expanda **Details** (Detalles) para ver los resultados. Debería ver el mes, día y año actuales.
**Para probar la función (AWS CLI) (opcional):**
1. Localice el ARN de la función de Lambda. Aparece en la parte superior de la consola de Lambda cuando se visualiza la función.
1. Ejecute el comando siguiente. *your-function-arn*Sustitúyala por la función ARN.
```
aws lambda invoke \
--function your-function-arn \
--cli-binary-format raw-in-base64-out \
--payload "{\"option\": \"date\", \"period\": \"today\"}" out.txt
```
1. Abra `out.txt` para confirmar que el resultado contiene el mes, el día y el año actuales.
# Paso 2: Actualizar la función de Lambda
En este tema, actualizará el archivo `myDateTimeFunction.js`. En el siguiente paso, utilizará el archivo para implementar la función actualizada. Esto desencadena CodeDeploy su implementación al cambiar el tráfico de producción de la versión actual de la función Lambda a la versión actualizada.
**Para actualizar la función de Lambda**
1. Abra `myDateTimeFunction.js`.
1. Elimine los dos marcadores de comentario ("`/*`" y "`*/`") y el texto explicativo al principio y al final del `case` denominado `time` en el bloque `switch`.
El código sin comentarios le permite transferir un nuevo parámetro, `time`, a la función. Si pasa `time` a la función actualizada, devuelve el valor actual `hour`, `minute` y `second`.
1. Guarde `myDateTimeFunction.js`. Debe parecerse a lo siguiente:
```
'use strict';
exports.handler = function(event, context, callback) {
if (event.body) {
event = JSON.parse(event.body);
}
var sc; // Status code
var result = ""; // Response payload
switch(event.option) {
case "date":
switch(event.period) {
case "yesterday":
result = setDateResult("yesterday");
sc = 200;
break;
case "today":
result = setDateResult();
sc = 200;
break;
case "tomorrow":
result = setDateResult("tomorrow");
sc = 200;
break;
default:
result = {
"error": "Must specify 'yesterday', 'today', or 'tomorrow'."
};
sc = 400;
break;
}
break;
case "time":
var d = new Date();
var h = d.getHours();
var mi = d.getMinutes();
var s = d.getSeconds();
result = {
"hour": h,
"minute": mi,
"second": s
};
sc = 200;
break;
default:
result = {
"error": "Must specify 'date' or 'time'."
};
sc = 400;
break;
}
const response = {
statusCode: sc,
headers: { "Content-type": "application/json" },
body: JSON.stringify( result )
};
callback(null, response);
function setDateResult(option) {
var d = new Date(); // Today
var mo; // Month
var da; // Day
var y; // Year
switch(option) {
case "yesterday":
d.setDate(d.getDate() - 1);
break;
case "tomorrow":
d.setDate(d.getDate() + 1);
default:
break;
}
mo = d.getMonth() + 1; // Months are zero offset (0-11)
da = d.getDate();
y = d.getFullYear();
result = {
"month": mo,
"day": da,
"year": y
};
return result;
}
};
```
# Paso 3: Implementar la función de Lambda actualizada
En este paso, utilizará el `myDateTimeFunction.js` actualizado para actualizar e iniciar la implementación de la función de Lambda. Puede supervisar el progreso de la implementación en la AWS Lambda consola CodeDeploy o.
La `AutoPublishAlias: live` línea de la AWS SAM plantilla hace que la infraestructura detecte las actualizaciones de las funciones que utilizan el `live` alias. Una actualización de la función desencadena una implementación CodeDeploy que desplaza el tráfico de producción de la versión original de la función a la versión actualizada.
Los comandos **sam package** y **sam deploy** se utilizan para actualizar y activar la implementación de la función de Lambda. Ha ejecutado estos comandos en [Package la aplicación AWS SAM](tutorial-lambda-sam-package.md) y [Implemente la aplicación AWS SAM](tutorial-lambda-sam-deploy.md).
**Para implementar la función de Lambda actualizada**
1. En el directorio `SAM-Tutorial`, ejecute el siguiente comando.
```
sam package \
--template-file template.yml \
--output-template-file package.yml \
--s3-bucket amzn-s3-demo-bucket
```
Esto crea un nuevo conjunto de artefactos que hacen referencia a la función de Lambda actualizada en el bucket de S3.
1. En el directorio `SAM-Tutorial`, ejecute el siguiente comando.
```
sam deploy \
--template-file package.yml \
--stack-name my-date-time-app \
--capabilities CAPABILITY_IAM
```
Como el nombre de la pila sigue siendo`my-date-time-app`, CloudFormation reconoce que se trata de una actualización de la pila. Para ver la pila actualizada, regresa a la CloudFormation consola y, en el panel de navegación, selecciona **Pilas**.
**(Opcional) para ver el tráfico durante una implementación (CodeDeploy consola)**
1. Abra la CodeDeploy consola en [https://console.aws.amazon.com/codedeploy/](https://console.aws.amazon.com/codedeploy/).
1. En el panel de navegación, expanda **Aplicaciones** y, a continuación, elija su ServerlessDeploymentApplication aplicación **my-date-time-app-**.
1. En **Deployment groups** (Grupos de implementaciones), elija el grupo de implementaciones de la aplicación. Su estado debe ser **In progress** (En curso).
1. En **Deployment group history** (Historial de grupos de implementaciones), elija la implementación que está en curso.
La barra de progreso **Traffic shifting** (Desvío de tráfico) y los porcentajes de los cuadros **Original** y **Replacement** (Sustitución) de esta página muestran su progreso.
![\[La sección de progreso de los cambios de tráfico de la CodeDeploy consola.\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/images/lambda-tutorial-codedeploy-console-20-percent-deployed.png)
**Para ver el tráfico durante una implementación (consola de Lambda) (opcional)**
1. Abre la AWS Lambda consola en [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. En el panel de navegación, elija la función `my-date-time-app-myDateTimeFunction`. En la consola, su nombre contiene un identificador, por lo que tendrá un aspecto similar a `my-date-time-app-myDateTimeFunction-123456ABCDEF`.
1. Elija **Alias** y, a continuación, **directo**.
Las ponderaciones situadas junto a la versión original de la función (versión 1) y la versión actualizada de la función (versión 2) muestran la cantidad de tráfico que se ofrece a cada versión en el momento en que se cargó esta página de la consola de AWS Lambda . La página no actualiza las ponderaciones con el paso del tiempo. Si actualiza la página una vez al minuto, la ponderación de la versión 1 disminuye en un 10 por ciento y la ponderación de la versión 2 aumenta en un 10 por ciento hasta que la ponderación de la versión 2 es 100.
![\[La sección de alias de la CodeDeploy consola.\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/images/lambda-tutorial-lambda-console-20-percent-deployed.png)
# Paso 4: Visualizar los resultados de la implementación
En este paso, podrá ver los resultados de la implementación. Si la implementación se realiza correctamente, puede confirmar que la función de Lambda actualizada recibe tráfico de producción. Si su implementación falla, puede usar CloudWatch los registros para ver el resultado de las pruebas de validación en la función Lambda que se ejecutan durante los ciclos de vida de la implementación.
**Topics**
+ [Prueba de la función implementada](#tutorial-lambda-sam-deploy-test-deployed-function)
+ [Vea los eventos de los enganches en los registros CloudWatch](#tutorial-lambda-view-hook-events)
## Prueba de la función implementada
El comando **sam deploy** actualiza la función de Lambda `my-date-time-app-myDateTimeFunction`. La versión de la función se actualiza a 2 y se añade al alias `live`.
**Para ver la actualización en la consola de Lambda**
1. Abra la consola en AWS Lambda . [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/)
1. En el panel de navegación, elija la función `my-date-time-app-myDateTimeFunction`. En la consola, su nombre contiene un identificador, por lo que tendrá un aspecto similar a `my-date-time-app-myDateTimeFunction-123456ABCDEF`.
1. Elija **Qualifiers** (Cualificadores) y, a continuación, **Aliases** (Alias). Una vez completada la implementación (aproximadamente 10 minutos), para el alias`live` alias, debería ver **Version: 2** (Versión: 2).
![\[La sección de alias de la CodeDeploy consola.\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/images/lambda-tutorial-function-version.png)
1. En **Function code** (Código de función), consulte el código fuente de la función. Deben aparecer los cambios.
1. Puede utilizar las instrucciones de prueba de [Paso 2: Actualizar la función de Lambda](tutorial-lambda-sam-update-function.md) para probar la función actualizada (opcional). Cree un nuevo evento de prueba con la siguiente carga y, a continuación, confirme que el resultado contiene la hora, el minuto y el segundo actuales.
```
{
"option": "time"
}
```
Para usar la AWS CLI función actualizada, ejecute el siguiente comando y, a continuación, ábralo `out.txt` para confirmar que el resultado contiene la hora, el minuto y el segundo actuales.
```
aws lambda invoke --function your-function-arn --payload "{\"option\": \"time\"}" out.txt
```
**nota**
Si lo utiliza AWS CLI para probar la función antes de que se complete la implementación, es posible que reciba resultados inesperados. Esto se debe a que transfiere CodeDeploy gradualmente el 10 por ciento del tráfico a la versión actualizada cada minuto. Durante la implementación, parte del tráfico sigue apuntando a la versión original, por lo que `aws lambda invoke` podría utilizar la versión original. Después de 10 minutos, la implementación se ha completado y todo el tráfico apunta a la nueva versión de la función.
## Vea los eventos de los enganches en los registros CloudWatch
Durante el `BeforeAllowTraffic` enlace, CodeDeploy ejecuta la función `CodeDeployHook_beforeAllowTraffic` Lambda. Durante el `AfterAllowTraffic` enlace, CodeDeploy ejecuta la función `CodeDeployHook_afterAllowTraffic` Lambda. Cada función ejecuta una prueba de validación que invoca la versión actualizada de la función mediante el nuevo parámetro `time`. Si la actualización de la función de Lambda se realiza correctamente, la opción `time` no provoca un error y la validación se realiza correctamente. Si la función no se ha actualizado, el parámetro no reconocido provoca un error y la validación falla. Estas pruebas de validación son solo para fines de demostración. Puede escribir sus propias pruebas para validar la implementación. Puede utilizar la consola de CloudWatch registros para ver las pruebas de validación.
**Para ver los eventos de tus CodeDeploy ganchos**
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)**.
1. En la lista de grupos de registros, elija**/aws/lambda/CodeDeployHook\$1 beforeAllowTraffic** o**/aws/lambda/CodeDeployHook\$1 afterAllowTraffic**.
1. Elija el flujo de registros. Debe ver solo uno.
1. Expanda los eventos para ver sus detalles.
![\[El flujo de registros de un grupo de CodeDeployHook registros.\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/images/lambda-tutorial-cloudwatch.png)
# Paso 5: Eliminar
Para evitar cargos adicionales por los recursos que utilizó durante este tutorial, elimine los recursos creados por la AWS SAM plantilla y los CloudWatch registros creados por las funciones de validación de Lambda.
**Para eliminar tu pila CloudFormation**
1. Inicia sesión en [https://console.aws.amazon.com/cloudformation Consola de administración de AWS](https://console.aws.amazon.com/cloudformation/) y abre la CloudFormation consola.
1. En la columna **Stacks** (Pilas), elija la pila de `my-date-time-app` y, a continuación, elija **Delete** (Eliminar).
1. Cuando se le solicite, seleccione **Delete stack** (Eliminar pila). Se eliminan las funciones Lambda, el grupo de CodeDeploy aplicaciones y despliegues y las funciones de IAM creadas por AWS SAM .
**Para eliminar sus registros en Logs CloudWatch**
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)**.
1. En la lista de grupos de registros, pulse el botón situado junto a**/aws/lambda/CodeDeployHook\$1 beforeAllowTraffic**.
1. En **Actions** (Acciones), elija **Delete log group** (Eliminar grupo de registros), y, a continuación, **Yes, Delete** (Sí, eliminar).
1. En la lista de grupos de registros, pulse el botón situado junto a**/aws/lambda/CodeDeployHook\$1 afterAllowTraffic**.
1. En **Actions** (Acciones), elija **Delete log group** (Eliminar grupo de registros), y, a continuación, **Yes, Delete** (Sí, eliminar).