Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Tutorial: 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**.