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.
# Integración con otros AWS servicios
CodeDeploy está integrado con los siguientes AWS servicios:
| | |
| --- |--- |
| Amazon CloudWatch | [Amazon CloudWatch](https://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/) es un servicio de supervisión de los recursos de la AWS nube y las aplicaciones en las que se ejecuta AWS. Puedes usar Amazon CloudWatch para recopilar y rastrear métricas, recopilar y monitorear archivos de registro y configurar alarmas. CodeDeploy es compatible con las siguientes CloudWatch herramientas: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/integrations-aws.html) |
| Amazon EC2 Auto Scaling | CodeDeploy es compatible con [Amazon EC2 Auto Scaling](https://aws.amazon.com/autoscaling). Este AWS servicio puede lanzar automáticamente instancias de Amazon EC2 en función de los criterios que especifique, por ejemplo:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/integrations-aws.html) Puede escalar un grupo de instancias de Amazon EC2 siempre que las necesite y, a continuación, utilizarlas CodeDeploy para implementar revisiones de aplicaciones en ellas automáticamente. Amazon EC2 Auto Scaling termina las instancias de Amazon EC2 cuando dejan de ser necesarias. Más información: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/integrations-aws.html) |
| Amazon Elastic Container Service | Puede utilizarla CodeDeploy para implementar una aplicación contenerizada de Amazon ECS como un conjunto de tareas. CodeDeploy realiza una blue/green implementación instalando una versión actualizada de la aplicación como un nuevo conjunto de tareas de reemplazo. CodeDeploy redirige el tráfico de producción del conjunto de tareas de la aplicación original al conjunto de tareas de reemplazo. Cuando la implementación se realiza correctamente, se termina el conjunto de tareas original. Para obtener más información acerca de Amazon ECS, consulte [Amazon Elastic Container Service](https://aws.amazon.com/ecs/). Puede administrar la forma en que el tráfico se desplaza al conjunto de tareas actualizado durante una implementación eligiendo una configuración canaria, lineal o all-at-once lineal. Para obtener más información acerca de las implementaciones de Amazon ECS, consulte [Implementaciones en una plataforma de informática de Amazon ECS](https://docs.aws.amazon.com/en_us/codedeploy/latest/userguide/deployment-steps-ecs.html). |
| AWS CloudTrail | CodeDeploy está integrado con [AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/). Este servicio captura las llamadas a la API realizadas por o en su nombre CodeDeploy en su AWS cuenta y entrega los archivos de registro a un bucket de Amazon S3 que especifique. CloudTrailcaptura las llamadas a la API desde la CodeDeploy consola, desde CodeDeploy los comandos a través de ella o CodeDeploy APIs directamente desde ella. AWS CLI Mediante la información recopilada por CloudTrail, puede determinar: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/integrations-aws.html) Más información: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/integrations-aws.html) |
| AWS Cloud9 | [AWS Cloud9](https://docs.aws.amazon.com/cloud9/latest/user-guide/)es un entorno de desarrollo integrado (IDE) en línea y basado en la nube que puede utilizar para escribir, ejecutar, depurar e implementar código con solo un navegador desde una máquina conectada a Internet. AWS Cloud9 incluye un editor de código, un depurador, un terminal y herramientas esenciales, como Git. AWS CLI [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/integrations-aws.html) Para obtener más información AWS Cloud9, consulte [Qué es AWS Cloud9](https://docs.aws.amazon.com/cloud9/latest/user-guide/welcom.html) y [Cómo empezar AWS Cloud9](https://docs.aws.amazon.com/cloud9/latest/user-guide/get-started.html). |
| AWS CodePipeline | [AWS CodePipeline](https://docs.aws.amazon.com/codepipeline/latest/userguide/) es un servicio de entrega continua que permite modelar, visualizar y automatizar los pasos necesarios para lanzar software en un proceso de entrega continua. AWS CodePipeline le permite definir su propio proceso de lanzamiento para que el servicio compile, pruebe e implemente el código cada vez que cambie. Por ejemplo, puede tener tres grupos de implementaciones para una aplicación: Beta, Gamma y Prod. Puede configurar una canalización para que, cada vez que ocurra un cambio en el código fuente, las actualizaciones se implementen en cada uno de los grupos. Puede configurarlo AWS CodePipeline para usar CodeDeploy para implementar: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/integrations-aws.html) Puede crear la CodeDeploy aplicación, el despliegue y el grupo de despliegues para usarlos en una acción de despliegue en una fase, ya sea antes de crear la canalización o en el asistente de **creación de canalización**. Más información: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/integrations-aws.html) |
| AWS Modelo de aplicación sin servidor | AWS El modelo de aplicaciones sin servidor (AWS SAM) es un modelo para definir las aplicaciones sin servidor. Se amplía CloudFormation para proporcionar una forma simplificada de definir AWS Lambda las funciones, las tablas de Amazon API Gateway APIs y Amazon DynamoDB requeridas por una aplicación sin servidor. Si ya utiliza AWS SAM, puede añadir preferencias de implementación para empezar CodeDeploy a utilizarlas y administrar la forma en que se desplaza el tráfico durante la implementación de una aplicación AWS Lambda. Para obtener más información, consulte [AWS Serverless Application Model](https://github.com/awslabs/serverless-application-model). |
| Elastic Load Balancing | CodeDeploy es compatible con [Elastic Load Balancing](https://docs.aws.amazon.com/ElasticLoadBalancing/latest/DeveloperGuide/elastic-load-balancing.html), un servicio que distribuye el tráfico de aplicaciones entrante entre varias instancias de Amazon EC2. En el caso de CodeDeploy las implementaciones, los balanceadores de carga también evitan que el tráfico se dirija a las instancias cuando no están listas, se están implementando actualmente o ya no se necesitan como parte de un entorno. Más información: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/integrations-aws.html) |
**Topics**
+ [Amazon EC2 Auto Scaling](integrations-aws-auto-scaling.md)
+ [Integrating CodeDeploy with Elastic Load Balancing](integrations-aws-elastic-load-balancing.md)
# Integración CodeDeploy con Amazon EC2 Auto Scaling
CodeDeploy es compatible con Amazon EC2 Auto Scaling, AWS un servicio que lanza instancias de Amazon EC2 automáticamente según las condiciones que defina. Estas condiciones pueden incluir que se supere un límite de tiempo específico para el uso de la CPU, que se lea o escriba el disco, o el tráfico de red entrante y saliente. Amazon EC2 Auto Scaling termina las instancias cuando dejan de ser necesarias. Para obtener más información, consulte [Grupo de Amazon EC2 Auto Scaling](https://docs.aws.amazon.com/autoscaling/latest/userguide/WhatIsAutoScaling.html) en la *Guía del usuario de Amazon EC2 Auto Scaling*.
Cuando se lanzan nuevas instancias de Amazon EC2 como parte de un grupo de Amazon EC2 Auto Scaling, CodeDeploy puede implementar sus revisiones en las nuevas instancias automáticamente. También puede coordinar las implementaciones CodeDeploy con instancias de Amazon EC2 Auto Scaling registradas en los balanceadores de carga de Elastic Load Balancing. Para obtener más información, consulte [Integración CodeDeploy con Elastic Load Balancing](integrations-aws-elastic-load-balancing.md) y [Configurar un balanceador de carga en Elastic Load Balancing para las implementaciones de CodeDeploy Amazon EC2](deployment-groups-create-load-balancer.md).
**nota**
Tenga en cuenta que es posible que surjan problemas si asocia varios grupos de implementación con un único grupo de Amazon EC2 Auto Scaling. Por ejemplo, si falla una implementación, la instancia comenzará a cerrarse, pero el resto de las implementaciones en ejecución puede que tarden una hora en agotar el tiempo de espera. Para obtener más información, consulte [Under [Evite asociar varios grupos de implementación a un único grupo de Amazon EC2 Auto Scaling](troubleshooting-auto-scaling.md#troubleshooting-multiple-depgroups) the Hood: CodeDeploy y la integración de Amazon EC2 Auto Scaling](https://aws.amazon.com/blogs/devops/under-the-hood-aws-codedeploy-and-auto-scaling-integration/).
**Topics**
+ [Implementación de CodeDeploy aplicaciones en grupos de Amazon EC2 Auto Scaling](#integrations-aws-auto-scaling-deploy)
+ [Habilitación de implementaciones de terminación durante los eventos de reducción horizontal de Auto Scaling](#integrations-aws-auto-scaling-behaviors-hook-enable)
+ [Cómo funciona Amazon EC2 Auto Scaling con CodeDeploy](#integrations-aws-auto-scaling-behaviors)
+ [Uso de una AMI personalizada con CodeDeploy Amazon EC2 Auto Scaling](#integrations-aws-auto-scaling-custom-ami)
## Implementación de CodeDeploy aplicaciones en grupos de Amazon EC2 Auto Scaling
Para implementar una revisión de CodeDeploy la aplicación en un grupo de Amazon EC2 Auto Scaling:
1. Cree o localice un perfil de instancia de IAM que permita al grupo de Amazon EC2 Auto Scaling trabajar con Amazon S3. Para obtener más información, consulte [Paso 4: Crear un perfil de instancia de IAM para las instancias de Amazon EC2](getting-started-create-iam-instance-profile.md).
**nota**
También puede utilizarlas CodeDeploy para implementar revisiones de los GitHub repositorios en los grupos de Amazon EC2 Auto Scaling. Si bien las instancias de Amazon EC2 siguen necesitando un perfil de instancia de IAM, el perfil no necesita permisos adicionales para implementarse desde un repositorio. GitHub
1. Cree o utilice un grupo de Amazon EC2 Auto Scaling, especificando el perfil de instancia de IAM en su configuración o plantilla de lanzamiento. Para obtener más información, consulte [Rol de IAM para aplicaciones que se ejecutan en instancias de Amazon EC2](https://docs.aws.amazon.com/autoscaling/ec2/userguide/us-iam-role.html).
1. Cree o localice un rol de servicio que permita CodeDeploy crear un grupo de implementación que contenga el grupo Amazon EC2 Auto Scaling.
1. Cree un grupo de implementación especificando el nombre del grupo de Amazon EC2 Auto Scaling, la función de servicio y algunas opciones más. CodeDeploy Para obtener más información, consulte [Creación de un grupo de implementación para una implementación local (consola)](deployment-groups-create-in-place.md) o [Creación de un grupo de implementación para una implementación local (consola)](deployment-groups-create-in-place.md).
1. CodeDeploy Utilícela para implementar la revisión en el grupo de implementación que contiene el grupo Amazon EC2 Auto Scaling.
Para obtener más información, consulte [Tutorial: Se usa CodeDeploy para implementar una aplicación en un grupo de Auto Scaling](tutorials-auto-scaling-group.md).
## Habilitación de implementaciones de terminación durante los eventos de reducción horizontal de Auto Scaling
Un *despliegue de terminación* es un tipo de CodeDeploy despliegue que se activa automáticamente cuando se produce un [evento de escalado](https://docs.aws.amazon.com/autoscaling/ec2/userguide/ec2-auto-scaling-lifecycle.html#as-lifecycle-scale-in) interno de Auto Scaling. CodeDeploy realiza el despliegue de terminación justo antes de que el servicio Auto Scaling finalice la instancia. Durante un despliegue de terminación, CodeDeploy no despliega nada. En su lugar, genera eventos de ciclo de vida, que puede enlazar a sus propios scripts para habilitar una funcionalidad de apagado personalizada. Por ejemplo, puede enlazar el evento del ciclo de vida de `ApplicationStop` a un script que apague la aplicación sin problemas antes de que finalice la instancia.
Para obtener una lista de los eventos del ciclo de vida que se CodeDeploy generan durante un despliegue de terminación, consulte[Disponibilidad de los enlaces de eventos del ciclo de vida](reference-appspec-file-structure-hooks.md#reference-appspec-file-structure-hooks-availability).
Si la implementación de la terminación falla por algún motivo, CodeDeploy permitirá que la finalización de la instancia continúe. Esto significa que la instancia se cerrará aunque CodeDeploy no se haya ejecutado todo el conjunto (o ninguno) de los eventos del ciclo de vida hasta completarse.
Si no habilita las implementaciones de terminación, el servicio Auto Scaling seguirá cancelando las instancias de Amazon EC2 cuando se produzca un evento de escalado interno, CodeDeploy pero no generará eventos de ciclo de vida.
**nota**
Independientemente de si habilita las implementaciones de terminación o no, si el servicio Auto Scaling finaliza una instancia de Amazon EC2 mientras la implementación está en marcha, puede producirse CodeDeploy una situación de carrera entre los eventos del ciclo de vida generados por Auto Scaling y los servicios. CodeDeploy Por ejemplo, el evento `Terminating` del ciclo de vida (generado por el servicio Auto Scaling) podría anular el `ApplicationStart` evento (generado por la CodeDeploy implementación). En este escenario, es posible que se produzca un error al finalizar la instancia de Amazon EC2 o al CodeDeploy implementarse.
**Para permitir la realización CodeDeploy de despliegues de terminación**
+ Seleccione la casilla **Agregar un enlace de terminación a los grupos de Auto Scaling** al crear o actualizar su grupo de implementación. Para obtener instrucciones, consulte [Creación de un grupo de implementación para una implementación local (consola)](deployment-groups-create-in-place.md) o [Cree un grupo de despliegues para un despliegue de EC2/local (consola) blue/green](deployment-groups-create-blue-green.md).
Al activar esta casilla de verificación, CodeDeploy se instala un [enlace de ciclo](https://docs.aws.amazon.com/autoscaling/ec2/userguide/lifecycle-hooks.html) de vida de Auto Scaling en los grupos de Auto Scaling que especifique al crear o actualizar el grupo de CodeDeploy implementación. Este enlace se denomina *enlace de terminación* y permite las implementaciones de terminación.
**Una vez instalado el enlace de terminación, se produce un evento de reducción horizontal (terminación) de la siguiente manera:**
1. El servicio de Auto Scaling (o simplemente Auto Scaling) determina que debe producirse un evento de reducción horizontal y se pone en contacto con el servicio de EC2 para terminar una instancia de EC2.
1. El servicio de EC2 comienza la terminación de la instancia EC2. La instancia pasa al estado `Terminating` y, después, al estado `Terminating:Wait`.
1. Durante este proceso`Terminating:Wait`, Auto Scaling ejecuta todos los ganchos del ciclo de vida adjuntos al grupo Auto Scaling, incluido el gancho de terminación instalado por CodeDeploy.
1. El enlace de terminación envía una notificación a la [cola de Amazon SQS](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/welcome.html) que está siendo sondeada. CodeDeploy
1. [Al recibir la notificación, CodeDeploy analiza el mensaje, realiza algunas validaciones y realiza un despliegue de terminación.](#integrations-aws-auto-scaling-behaviors-hook-enable)
1. Mientras se ejecuta la implementación de terminación, CodeDeploy envía latidos cada cinco minutos a Auto Scaling para avisarle de que la instancia aún se está trabajando en la instancia.
1. Hasta ahora, la instancia de EC2 sigue en el estado `Terminating:Wait` (o posiblemente en el estado `Warmed:Pending:Wait`, si ha activado los [grupos de calentamiento de grupos de Auto Scaling](https://docs.aws.amazon.com/autoscaling/ec2/userguide/warm-pool-instance-lifecycle.html)).
1. Cuando se complete el despliegue, CodeDeploy indica a Auto Scaling `CONTINUE` el proceso de terminación de EC2, independientemente de si el despliegue de terminación se realizó correctamente o no.
## Cómo funciona Amazon EC2 Auto Scaling con CodeDeploy
Al crear o actualizar un grupo de CodeDeploy implementación para incluir un grupo de Auto Scaling, CodeDeploy accede al grupo de Auto Scaling mediante el rol de CodeDeploy servicio y, a continuación, instala los [enlaces del ciclo de vida de Auto Scaling](https://docs.aws.amazon.com/autoscaling/ec2/userguide/lifecycle-hooks.html) en sus grupos de Auto Scaling.
**nota**
Los *ganchos del ciclo de vida de Auto Scaling* son diferentes de los *eventos* *del ciclo de vida (también denominados ganchos* de eventos del ciclo [AppSpec sección de «ganchos»](reference-appspec-file-structure-hooks.md) de vida) generados CodeDeploy y descritos en esta guía.
Los ganchos del ciclo de vida de Auto Scaling que CodeDeploy instala son:
+ **Un enlace de lanzamiento**: este enlace notifica CodeDeploy que hay un [evento de escalado horizontal de](https://docs.aws.amazon.com/autoscaling/ec2/userguide/ec2-auto-scaling-lifecycle.html#as-lifecycle-scale-out) Auto Scaling en curso y que es CodeDeploy necesario iniciar una implementación de lanzamiento.
Durante una implementación de *lanzamiento*,: CodeDeploy
+ Implementa una revisión de la aplicación en la instancia escalada horizontalmente.
+ Genera eventos de ciclo de vida para indicar el progreso de la implementación. Puede enlazar estos eventos de ciclo de vida a sus propios scripts para habilitar una funcionalidad de inicio personalizada. Para obtener más información, consulte la tabla en [Disponibilidad de los enlaces de eventos del ciclo de vida](reference-appspec-file-structure-hooks.md#reference-appspec-file-structure-hooks-availability).
El enlace de lanzamiento y la implementación de lanzamiento asociada siempre están habilitados y no se pueden desactivar.
+ **Un enlace de terminación**: este enlace opcional notifica CodeDeploy que se está produciendo un [evento de escalado](https://docs.aws.amazon.com/autoscaling/ec2/userguide/ec2-auto-scaling-lifecycle.html#as-lifecycle-scale-in) automático de Auto Scaling y que CodeDeploy debe iniciar un despliegue de terminación.
Durante una *implementación de terminación*, CodeDeploy genera eventos del ciclo de vida para indicar el progreso del cierre de la instancia. Para obtener más información, consulte [Habilitación de implementaciones de terminación durante los eventos de reducción horizontal de Auto Scaling](#integrations-aws-auto-scaling-behaviors-hook-enable).
**Topics**
+ [Una vez CodeDeploy instalados los enlaces del ciclo de vida, ¿cómo se utilizan?](#integrations-aws-auto-scaling-behaviors-hook-usage)
+ [Cómo se CodeDeploy nombran los grupos de Amazon EC2 Auto Scaling](#integrations-aws-auto-scaling-behaviors-naming)
+ [Orden de ejecución de eventos de enlace de ciclo de vida personalizados](#integrations-aws-auto-scaling-behaviors-hook-order)
+ [Eventos de escalado horizontal durante una implementación](#integrations-aws-auto-scaling-behaviors-mixed-environment)
+ [Eventos de reducción horizontal durante una implementación](#integrations-aws-auto-scaling-behaviors-scale-in)
+ [Orden de los eventos en los scripts AWS CloudFormation cfn-init](#integrations-aws-auto-scaling-behaviors-event-order)
### Una vez CodeDeploy instalados los enlaces del ciclo de vida, ¿cómo se utilizan?
Una vez instalados los ganchos del ciclo de vida de lanzamiento y finalización, los utilizan CodeDeploy durante los eventos de escalado horizontal y horizontal de grupo de Auto Scaling, respectivamente.
**Un evento de escalado horizontal (lanzamiento) se desarrolla de la siguiente manera:**
1. El servicio de escalado automático (o simplemente Auto Scaling) determina que debe producirse un evento de escalado horizontal y se pone en contacto con el servicio de EC2 para lanzar una nueva instancia de EC2.
1. El servicio de EC2 lanza una nueva instancia de EC2. La instancia pasa al estado `Pending` y, después, al estado `Pending:Wait`.
1. Durante este proceso`Pending:Wait`, Auto Scaling ejecuta todos los ganchos del ciclo de vida adjuntos al grupo Auto Scaling, incluido el gancho de lanzamiento instalado por CodeDeploy.
1. El enlace de lanzamiento envía una notificación a la [cola de Amazon SQS consultada](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/welcome.html) por. CodeDeploy
1. [Al recibir la notificación, CodeDeploy analiza el mensaje, realiza algunas validaciones e inicia una implementación de lanzamiento.](#launch-deployment)
1. Mientras se ejecuta la implementación de lanzamiento, CodeDeploy envía latidos cada cinco minutos a Auto Scaling para avisarle de que la instancia aún se está trabajando en la instancia.
1. Hasta el momento, la instancia EC2 sigue en el estado `Pending:Wait`.
1. Cuando se complete la implementación, CodeDeploy indica a Auto Scaling el proceso de lanzamiento `CONTINUE` o `ABANDON` el de EC2, dependiendo de si la implementación se realizó correctamente o no.
+ Si así CodeDeploy lo indica`CONTINUE`, Auto Scaling continúa con el proceso de lanzamiento, ya sea esperando a que se completen otros enlaces o poniendo la instancia en el estado `Pending:Proceed` y luego en el `InService` estado.
+ Si así CodeDeploy lo indica`ABANDON`, Auto Scaling finaliza la instancia EC2 y reinicia el procedimiento de lanzamiento si es necesario para cumplir con el número deseado de instancias, tal como se define en la configuración de Capacidad **deseada** de Auto Scaling.
**Un evento de reducción horizontal (terminación) se desarrolla de la siguiente manera:**
Consulte [Habilitación de implementaciones de terminación durante los eventos de reducción horizontal de Auto Scaling](#integrations-aws-auto-scaling-behaviors-hook-enable).
### Cómo se CodeDeploy nombran los grupos de Amazon EC2 Auto Scaling
Durante blue/green las implementaciones en una plataforma informática local o de EC2, tiene dos opciones para añadir instancias al entorno de reemplazo (verde):
+ Utilice instancias que ya existan o que cree manualmente.
+ Utilizar la configuración de un grupo de Amazon EC2 Auto Scaling especificado para definir y crear instancias en un nuevo grupo de Amazon EC2 Auto Scaling.
Si elige la segunda opción, le CodeDeploy aprovisiona un nuevo grupo de Amazon EC2 Auto Scaling. Utiliza la siguiente convención para el nombre del grupo:
```
CodeDeploy_deployment_group_name_deployment_id
```
Por ejemplo, si una implementación con ID `10` implementa un grupo de implementación llamado `alpha-deployments`, el grupo de Amazon EC2 Auto Scaling aprovisionado se llama `CodeDeploy_alpha-deployments_10`. Para obtener más información, consulte [Cree un grupo de despliegues para un despliegue de EC2/local (consola) blue/green](deployment-groups-create-blue-green.md) y [GreenFleetProvisioningOption](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_GreenFleetProvisioningOption.html).
### Orden de ejecución de eventos de enlace de ciclo de vida personalizados
Puede añadir sus propios enlaces de ciclo de vida a los grupos de Amazon EC2 Auto Scaling en los CodeDeploy que se realiza la implementación. Sin embargo, el orden en que se ejecutan esos eventos de enlace del ciclo de vida personalizados no se puede predeterminar en relación con los eventos del ciclo de vida de la implementación CodeDeploy predeterminados. Por ejemplo, si agrega un enlace de ciclo de vida personalizado denominado `ReadyForSoftwareInstall` a un grupo de Amazon EC2 Auto Scaling, no podrá saber de antemano si se ejecutará antes del primer evento del ciclo de vida de la implementación predeterminado o después del último CodeDeploy.
Para obtener información sobre cómo añadir enlaces de ciclo de vida personalizados a un grupo de Amazon EC2 Auto Scaling, consulte [Añadir enlaces de ciclo de vida](https://docs.aws.amazon.com/autoscaling/latest/userguide/lifecycle-hooks.html#adding-lifecycle-hooks) en la *Guía del usuario de Amazon EC2 Auto Scaling*.
### Eventos de escalado horizontal durante una implementación
Si se produce un evento de escalado horizontal de Auto Scaling mientras está en curso una implementación, las nuevas instancias se actualizarán con la revisión de la aplicación que se implementó antes, no con la última revisión de la aplicación. Si la implementación se realiza correctamente, las instancias antiguas y las instancias recién escaladas horizontalmente hospedarán revisiones de la aplicación diferentes. Para actualizar las instancias con la revisión anterior, inicia CodeDeploy automáticamente una implementación posterior (inmediatamente después de la primera) para actualizar las instancias desactualizadas. Si desea cambiar este comportamiento predeterminado para que las instancias de EC2 desactualizadas permanezcan en la revisión anterior, consulte [Automatic updates to outdated instances](deployment-groups-configure-advanced-options.md#auto-updates-outdated-instances).
Si desea suspender los procesos de escalado horizontal de Amazon EC2 Auto Scaling mientras se llevan a cabo las implementaciones, puede hacerlo mediante una configuración en `common_functions.sh` el script que se utiliza para equilibrar la carga con. CodeDeploy Si `HANDLE_PROCS=true`, los siguientes eventos de escalado automático se suspenden automáticamente durante el proceso de implementación:
+ AZRebalance
+ AlarmNotification
+ ScheduledActions
+ ReplaceUnhealthy
**importante**
Solo el. CodeDeployDefault OneAtATime la configuración de despliegue admite esta funcionalidad.
Para obtener más información sobre cómo `HANDLE_PROCS=true` utilizar Amazon EC2 Auto Scaling para evitar problemas de implementación, [consulte el Aviso importante sobre la AutoScaling gestión](https://github.com/awslabs/aws-codedeploy-samples/tree/master/load-balancing/elb#important-notice-about-handling-autoscaling-processes) de procesos [aws-codedeploy-samples](https://github.com/awslabs/aws-codedeploy-samples)en GitHub on.
### Eventos de reducción horizontal durante una implementación
Si un grupo de Auto Scaling comienza a ampliarse mientras se está realizando una CodeDeploy implementación en ese grupo de Auto Scaling, podría producirse una condición de carrera entre el proceso de finalización (incluidos los eventos del ciclo de vida del despliegue de CodeDeploy terminación) y otros eventos CodeDeploy del ciclo de vida en la instancia de terminación. La implementación en esa instancia específica puede fallar si la instancia se termina antes de que se completen todos los eventos CodeDeploy del ciclo de vida. Además, la CodeDeploy implementación general puede fallar o no, en función de cómo haya establecido el valor **mínimo de hosts en buen** estado en la configuración de la implementación.
### Orden de los eventos en los scripts AWS CloudFormation cfn-init
Si utiliza `cfn-init` (o `cloud-init`) para ejecutar scripts en instancias basadas en Linux recién aprovisionadas, las implementaciones podrían fallar a menos que controle estrictamente el orden de los eventos que se producen después que se inicia la instancia.
Ese orden debe ser:
1. Se inicia la instancia recién aprovisionada.
1. Se ejecutan todos los scripts de proceso de arranque `cfn-init` hasta su finalización.
1. El CodeDeploy agente comienza.
1. Se implementa la última revisión de la aplicación en la instancia.
Si el orden de los eventos no se controla cuidadosamente, el CodeDeploy agente podría iniciar una implementación antes de que todos los scripts hayan terminado de ejecutarse.
Para controlar el orden de los eventos, utilice una de estas prácticas recomendadas:
+ Instale el CodeDeploy agente mediante un `cfn-init` script y colóquelo después de todos los demás scripts.
+ Incluya el CodeDeploy agente en una AMI personalizada y utilice un `cfn-init` script para iniciarlo, colocándolo después de todos los demás scripts.
Para obtener información acerca de cómo usar `cfn-init`, consulte [cfn-init](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-init.html) en la *Guía del usuario de AWS CloudFormation *.
## Uso de una AMI personalizada con CodeDeploy Amazon EC2 Auto Scaling
Dispone de dos opciones para especificar la AMI base que se debe usar cuando se lancen nuevas instancias de Amazon EC2 en un grupo de Amazon EC2 Auto Scaling:
+ Puede especificar una AMI base personalizada que ya tenga el CodeDeploy agente instalado. Dado que el agente ya está instalado, esta opción lanza las nuevas instancias de Amazon EC2 con mayor rapidez que la otra opción. Sin embargo, esta opción ofrece una mayor probabilidad de que las implementaciones iniciales de las instancias de Amazon EC2 fallen, especialmente si CodeDeploy el agente está desactualizado. Si elige esta opción, le recomendamos que actualice periódicamente el CodeDeploy agente en su AMI personalizada base.
+ Puede especificar una AMI base que no tenga el CodeDeploy agente instalado y tenerlo instalado cada vez que se lance una nueva instancia en un grupo de Amazon EC2 Auto Scaling. Aunque esta opción lanza las nuevas instancias de Amazon EC2 más lentamente que la otra opción, tiene mayor probabilidad de que las implementaciones iniciales de las instancias sean correctas. Esta opción utiliza la versión más reciente del CodeDeploy de agente.
# Integración CodeDeploy con Elastic Load Balancing
Durante CodeDeploy las implementaciones, un balanceador de carga evita que el tráfico de Internet se dirija a las instancias cuando no están listas, se están implementando actualmente o ya no se necesitan como parte de un entorno. Sin embargo, la función exacta que desempeña el balanceador de cargas depende de si se usa en una blue/green implementación o en una implementación local.
**nota**
El uso de los balanceadores de carga de Elastic Load Balancing es obligatorio en blue/green las implementaciones y opcional en las implementaciones locales.
## Tipos de Elastic Load Balancing
Elastic Load Balancing proporciona tres tipos de balanceadores de carga que se pueden usar en CodeDeploy las implementaciones: balanceadores de carga clásicos, balanceadores de carga de aplicaciones y balanceadores de carga de red.
Equilibrador de carga clásico
Las rutas y los equilibrios de carga se encuentran en la capa de transporte (). TCP/SSL) or the application layer (HTTP/HTTPS Es compatible con una VPC.
Los equilibradores de carga clásicos no son compatibles con las implementaciones de Amazon ECS.
Equilibrador de carga de aplicación
Enruta y equilibra la carga en la capa de la aplicación (HTTP/HTTPS) y admite el enrutamiento basado en rutas. Puede dirigir las solicitudes a puertos de cada instancia EC2 o instancia de contenedor de su nube privada virtual (VPC).
Los grupos objetivo del Equilibrador de carga de aplicación deben tener un tipo de destino `instance` para las implementaciones en instancias EC2 y `IP` para las implementaciones de Fargate. Para obtener más información, consulte [Tipo de destino](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-target-groups.html#target-type).
Equilibrador de carga de red
Enruta y equilibra la carga en la capa de transporte (capa 4 de TCP/UDP) basándose en la información de las direcciones que extrae del encabezado del paquete TCP y no de su contenido. Los balanceadores de carga de red pueden gestionar ráfagas de tráfico, conservar la IP de origen del cliente y utilizar una IP fija mientras dura la vida útil del balanceador de carga.
Para obtener más información sobre los equilibradores de carga de Elastic Load Balancing, consulte los temas siguientes:
+ [¿Qué es Elastic Load Balancing?](https://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/what-is-load-balancing.html)
+ [¿Qué es un equilibrador de carga clásico?](https://docs.aws.amazon.com/elasticloadbalancing/latest/classic/introduction.html)
+ [¿Qué es un equilibrador de carga de aplicación?](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/introduction.html)
+ [¿Qué es un equilibrador de carga de red?](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/introduction.html)
## Implementaciones azul/verde
Redireccionar el tráfico de instancias detrás de un balanceador de cargas de Elastic Load Balancing es fundamental para CodeDeploy blue/green las implementaciones.
Durante una blue/green implementación, el balanceador de carga permite enrutar el tráfico a las nuevas instancias de un grupo de implementación en el que se implementó la última revisión de la aplicación (el entorno de reemplazo), de acuerdo con las reglas que especifique, y luego bloquea el tráfico de las instancias antiguas en las que se estaba ejecutando la revisión anterior de la aplicación (el entorno original).
Una vez que las instancias de un entorno de sustitución se hayan registrado en uno o varios equilibradores de carga, se cancela el registro de las instancias del entorno original y, si así lo decide, se terminan las instancias.
Para una blue/green implementación, puede especificar uno o más grupos objetivo de Classic Load Balancers, Application Load Balancer o Network Load Balancer en su grupo de implementación. Usa la CodeDeploy consola o AWS CLI para agregar los balanceadores de carga a un grupo de implementación.
Para obtener más información sobre los equilibradores de carga en blue/green las implementaciones, consulta los siguientes temas:
+ [Configurar un balanceador de carga en Elastic Load Balancing para las implementaciones de CodeDeploy Amazon EC2](deployment-groups-create-load-balancer.md)
+ [Cree una aplicación para una blue/green implementación (consola)](applications-create-blue-green.md)
+ [Cree un grupo de despliegues para un despliegue de EC2/local (consola) blue/green](deployment-groups-create-blue-green.md)
## Implementaciones in situ
Durante una implementación local, el balanceador de carga impide que el tráfico de Internet se dirija a la instancia en la está ocurriendo, y la vuelve a poner a disposición una vez finalizada dicha implementación.
Si no se utiliza un balanceador de carga durante una implementación local, es posible que el tráfico de Internet aún se dirija a una instancia durante el proceso de implementación. Como resultado, los clientes podrían encontrarse con aplicaciones web dañadas, incompletas o anticuadas. Cuando utilizas un balanceador de cargas de Elastic Load Balancing con una implementación local, las instancias de un grupo de implementación se cancelan del balanceador de cargas, se actualizan con la última revisión de la aplicación y, a continuación, se vuelven a registrar en el balanceador de cargas como parte del mismo grupo de implementación una vez que la implementación se ha realizado correctamente. CodeDeploy esperará hasta 1 hora para que la instancia se recupere correctamente tras el balanceador de carga. Si el balanceador de carga no marca la instancia como en buen estado durante el período de espera, CodeDeploy pasa a la siguiente instancia o no se realiza la implementación, según la configuración de la implementación.
Para una implementación local, puede especificar uno o más equilibradores de carga clásicos, grupos de destino de equilibrador de carga de aplicación o grupos de destino de equilibrador de carga de red. Puedes especificar los balanceadores de carga como parte de la configuración del grupo de implementación, o puedes usar un script proporcionado por él CodeDeploy para implementar los balanceadores de carga.
### Especificación de un equilibrador de carga de una implementación local mediante un grupo de implementación
Para añadir balanceadores de carga a un grupo de implementación, usa la CodeDeploy consola o. AWS CLI Para obtener información sobre cómo especificar un balanceador de carga en un grupo de implementaciones para implementaciones in situ, consulte los siguientes temas:
+ [Creación de una aplicación para una implementación local (consola)](applications-create-in-place.md)
+ [Creación de un grupo de implementación para una implementación local (consola)](deployment-groups-create-in-place.md)
+ [Configurar un balanceador de carga en Elastic Load Balancing para las implementaciones de CodeDeploy Amazon EC2](deployment-groups-create-load-balancer.md)
### Especificación de un equilibrador de carga de una implementación local mediante un script
Utilice los pasos que se indican en el siguiente procedimiento para usar scripts de ciclo de vida para configurar el balanceo de carga para implementaciones locales.
**nota**
Deberías usar el CodeDeployDefault. OneAtATime la configuración de despliegue solo cuando se utiliza un script para configurar un equilibrador de carga para un despliegue in situ. No se admiten las ejecuciones simultáneas y las. CodeDeployDefault OneAtATime la configuración garantiza la ejecución en serie de los scripts. Para obtener más información acerca de las configuraciones de implementación, consulte [Trabajar con configuraciones de implementación en CodeDeploy](deployment-configurations.md).
En el repositorio de CodeDeploy muestras GitHub, incluimos instrucciones y ejemplos que puede adaptar para usar los balanceadores de carga de CodeDeploy Elastic Load Balancing. En estos repositorios se incluyen tres scripts de ejemplo (`register_with_elb.sh`, `deregister_from_elb.sh` y `common_functions.sh`) que proporcionan todo el código que necesitará para comenzar. Solo tiene que editar los marcadores de posición de estos tres scripts y después hacer referencia a estos scripts en el archivo `appspec.yml`.
Para configurar las implementaciones in situ en CodeDeploy instancias de Amazon EC2 que estén registradas en los balanceadores de carga de Elastic Load Balancing, haga lo siguiente:
1. Descargue los ejemplos del tipo de balanceador de carga que desea utilizar para una implementación in situ:
+ [Equilibrador de carga clásico](https://github.com/awslabs/aws-codedeploy-samples/tree/master/load-balancing/elb)
+ [Equilibrador de carga de aplicación[ o Equilibrador de carga de red](https://github.com/awslabs/aws-codedeploy-samples/tree/master/load-balancing/elb-v2) (se puede usar el mismo script para ambos tipos)](https://github.com/awslabs/aws-codedeploy-samples/tree/master/load-balancing/elb-v2)
1. Asegúrese de que cada una de las instancias de Amazon EC2 de destino la AWS CLI tenga instalada.
1. Asegúrese de que cada una de sus instancias de Amazon EC2 de destino tenga un perfil de instancia de IAM asociado con los permisos elasticloadbalancing:\$1 y autoscaling:\$1 como mínimo.
1. En el directorio de código fuente de la aplicación, incluya los scripts de evento de ciclo de vida de implementación (`register_with_elb.sh`, `deregister_from_elb.sh` y `common_functions.sh`).
1. En la `appspec.yml` revisión de la aplicación, proporcione instrucciones CodeDeploy para ejecutar el `register_with_elb.sh` script durante el **ApplicationStart**evento y el `deregister_from_elb.sh` script durante el **ApplicationStop**evento.
1. Si la instancia forma parte de un grupo de Amazon EC2 Auto Scaling, puede omitir este paso.
En el script `common_functions.sh`:
+ Si utiliza el [Equilibrador de carga clásico](https://github.com/awslabs/aws-codedeploy-samples/tree/master/load-balancing/elb), especifique los nombres de los equilibradores de carga de Elastic Load Balancing en `ELB_LIST=""` y realice los cambios que necesite en el resto de la configuración de la implementación en el archivo.
+ Si utiliza el [Equilibrador de carga de aplicación[ o el Equilibrador de carga de red](https://github.com/awslabs/aws-codedeploy-samples/tree/master/load-balancing/elb-v2)](https://github.com/awslabs/aws-codedeploy-samples/tree/master/load-balancing/elb-v2), especifique los nombres del grupo de destino de Elastic Load Balancing en `TARGET_GROUP_LIST=""` y realice los cambios que necesite en el resto de la configuración de la implementación en el archivo.
1. Empaquete el código fuente de la aplicación, el archivo `appspec.yml` y los scripts de eventos de ciclo de vida de la implementación en una revisión de la aplicación y después cargue la revisión. Implemente la revisión en las instancias de Amazon EC2. Durante la implementación, los scripts de eventos de ciclo de vida de la implementación cancelarán el registro de la instancia de Amazon EC2 con el equilibrador de carga, esperarán a que se vacíe la conexión y volverán a registrar la instancia de Amazon EC2 con el equilibrador de carga una vez que se complete la implementación.