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.
# Trabajar con despliegues en CodeDeploy
En CodeDeploy, una implementación es el proceso, y los componentes involucrados en el proceso, de instalar contenido en una o más instancias. Este contenido puede consistir en archivos de código, web y de configuración, ejecutables, paquetes, scripts, etc. CodeDeploy despliega el contenido almacenado en un repositorio de origen, de acuerdo con las reglas de configuración que especifique.
Si utiliza la plataforma de informática de EC2/en las instalaciones, pueden ejecutarse simultáneamente dos implementaciones en el mismo conjunto de instancias.
CodeDeploy ofrece dos opciones de tipos de despliegue: los despliegues locales y los despliegues azul/verde.
+ **Implementación local**: la aplicación de cada instancia del grupo de implementación se para, se instala la última revisión de la aplicación, y se inicia y valida la nueva versión de la aplicación. Puede utilizar un equilibrador de carga de modo que se cancele el registro de cada instancia durante su implementación y, a continuación, vuelva a ponerse en servicio una vez completada la implementación. Solo las implementaciones que usan la plataforma de informática de EC2/en las instalaciones pueden utilizar implementaciones locales. Para obtener más información acerca de las implementaciones locales, consulte [Información general de la implementación local](welcome.md#welcome-deployment-overview-in-place).
+ **Implementación azul/verde**: el funcionamiento de la implementación depende de la plataforma de informática que utilice:
+ **Blue/green on an EC2/On-Plataforma informática local**: las instancias de un grupo de implementación (el entorno original) se sustituyen por un conjunto diferente de instancias (el entorno de reemplazo) siguiendo estos pasos:
+ Las instancias se aprovisionan en el entorno de sustitución.
+ La revisión de aplicación más reciente se instala en las instancias de sustitución.
+ Existe un tiempo de espera opcional para actividades como las pruebas de aplicaciones y la verificación del sistema.
+ Las instancias del entorno de sustitución se registran en uno o más equilibradores de carga de Elastic Load Balancing, lo que provoca que el tráfico se redirija a ellos. Las instancias del entorno original se anulan del registro y se pueden cerrar o mantener en ejecución para otros usos.
**nota**
Si utiliza una plataforma informática EC2/local, tenga en cuenta que las blue/green implementaciones solo funcionan con instancias de Amazon EC2.
+ **Azul/verde en una plataforma informática o AWS Lambda Amazon ECS**: el tráfico se desplaza en incrementos según una configuración **canaria**, **lineal** o **all-at-once**de implementación.
+ **Implementaciones azules/verdes CloudFormation: el tráfico pasa** de los recursos actuales a los recursos actualizados como parte de una actualización de la pila. CloudFormation Actualmente, solo se admiten las blue/green implementaciones de ECS.
Para obtener más información sobre blue/green las implementaciones, consulte. [Descripción general de una implementación blue/green](welcome.md#welcome-deployment-overview-blue-green)
Para obtener información sobre la implementación automática desde Amazon S3, consulte [Implementación automática desde Amazon S3 mediante CodeDeploy](https://aws.amazon.com/blogs/devops/automatically-deploy-from-amazon-s3-using-aws-codedeploy/).
**Topics**
+ [Creación de una implementación](deployments-create.md)
+ [Visualización de los detalles de la implementación](deployments-view-details.md)
+ [Visualización de los datos de registro de una implementación](deployments-view-logs.md)
+ [Detención de una implementación](deployments-stop.md)
+ [Volver a implementar y restaurar una implementación](deployments-rollback-and-redeploy.md)
+ [Implemente una aplicación en una AWS cuenta diferente](deployments-cross-account.md)
+ [Validación de un paquete de implementación en una máquina local](deployments-local.md)
# Cree una implementación con CodeDeploy
Puede utilizar la CodeDeploy consola, las API o las CodeDeploy API para crear una implementación que instale las revisiones de aplicaciones que ya haya enviado a Amazon S3 o, si la implementación se realiza en una plataforma informática local de EC2 GitHub, en las instancias de un grupo de implementaciones. AWS CLI
El proceso para crear una implementación depende de la plataforma de informática usada en la implementación.
**Topics**
+ [Requisitos previos para una implementación](deployments-create-prerequisites.md)
+ [Creación de una implementación en una plataforma de informática de Amazon ECS (consola)](deployments-create-console-ecs.md)
+ [Crear una implementación de AWS Lambda Compute Platform (consola)](deployments-create-console-lambda.md)
+ [Creación de una implementación en una plataforma de informática de EC2/en las instalaciones (consola)](deployments-create-console.md)
+ [Creación de una implementación en una plataforma de informática de Amazon ECS (CLI)](deployments-create-ecs-cli.md)
+ [Crear una implementación de AWS Lambda Compute Platform (CLI)](deployments-create-lambda-cli.md)
+ [Creación de una implementación en una plataforma de informática EC2/en las instalaciones (CLI)](deployments-create-cli.md)
+ [Cree una blue/green implementación de Amazon ECS mediante CloudFormation](deployments-create-ecs-cfn.md)
# Requisitos previos para una implementación
Asegúrese de seguir estos pasos antes de iniciar una implementación.
## Requisitos previos de implementación en una plataforma informática AWS Lambda
+ Cree una aplicación que incluya al menos un grupo de implementación. Para obtener más información, consulte [Cree una aplicación con CodeDeploy](applications-create.md) y [Cree un grupo de despliegue con CodeDeploy](deployment-groups-create.md).
+ Prepare la revisión de la aplicación, también conocida como AppSpec archivo, que especifica la versión de la función Lambda que desea implementar. El AppSpec archivo también puede especificar las funciones de Lambda para validar la implementación. Para obtener más información, consulte [Trabajar con revisiones de aplicaciones para CodeDeploy](application-revisions.md).
+ Si desea utilizar una configuración de implementación personalizada para su implementación, créela antes de iniciar el proceso de implementación. Para obtener información, consulte [Cree una configuración de despliegue con CodeDeploy](deployment-configurations-create.md).
## Requisitos previos para una implementación en una plataforma de informática EC2/en las instalaciones
+ Si se trata de una implementación "in-place", cree o configure las instancias en las que desea realizar la implementación. Para obtener información, consulte [Trabajar con instancias para CodeDeploy](instances.md). Para una blue/green implementación, tiene un grupo de Amazon EC2 Auto Scaling existente para usarlo como plantilla para su entorno de reemplazo, o bien tiene una o más instancias o grupos de Amazon EC2 Auto Scaling que especifique como su entorno original. 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) y [Integración CodeDeploy con Amazon EC2 Auto Scaling](integrations-aws-auto-scaling.md).
+ Cree una aplicación que incluya al menos un grupo de implementación. Para obtener más información, consulte [Cree una aplicación con CodeDeploy](applications-create.md) y [Cree un grupo de despliegue con CodeDeploy](deployment-groups-create.md).
+ Prepare la revisión de la aplicación que desea implementar en las instancias del grupo de implementaciones. Para obtener información, consulte [Trabajar con revisiones de aplicaciones para CodeDeploy](application-revisions.md).
+ Si desea utilizar una configuración de implementación personalizada para su implementación, créela antes de iniciar el proceso de implementación. Para obtener información, consulte [Cree una configuración de despliegue con CodeDeploy](deployment-configurations-create.md).
+ Si está implementando la revisión de la aplicación desde un bucket de Amazon S3, el bucket se encuentra en la misma AWS región que las instancias de su grupo de implementación.
+ Si está implementando la revisión de la aplicación desde un bucket de Amazon S3, debe haberse aplicado al bucket una política de bucket Amazon S3. Esta política concede a las instancias los permisos necesarios para descargar la revisión de la aplicación.
Por ejemplo, la siguiente política de bucket de Amazon S3 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 lugar 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"
]
}
}
]
}
```
La siguiente política de bucket de Amazon S3 permite a cualquier instancia en las instalaciones con un usuario de IAM asociado que contenga el ARN `arn:aws:iam::444455556666:user/CodeDeployUser` descargar desde cualquier lugar al bucket de Amazon S3 denominado `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:user/CodeDeployUser"
]
}
}
]
}
```
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).
+ Si va a crear una blue/green implementación o ha especificado un Classic Load Balancer, Application Load Balancer o Network Load Balancer opcionales en el grupo de implementaciones para una implementación local, ha creado una VPC mediante Amazon VPC que contiene al menos dos subredes. (CodeDeploy usa Elastic Load Balancing, que requiere que todas las instancias de un grupo de balanceadores de carga estén en una sola VPC).
Si aún no ha creado una VPC, consulte la [Guía de introducción a Amazon VPC](https://docs.aws.amazon.com/AmazonVPC/latest/GettingStartedGuide/ExerciseOverview.html).
+ Si va a crear una blue/green implementación, ha configurado al menos un Classic Load Balancer, Application Load Balancer o Network Load Balancer en Elastic Load Balancing y lo ha utilizado para registrar las instancias que componen el entorno original.
**nota**
Las instancias del entorno de sustitución se registrarán con el equilibrador de carga en otro momento.
Para obtener más información sobre la configuración de un equilibrador de carga, consulte [Configurar un balanceador de carga en Elastic Load Balancing para las implementaciones de CodeDeploy Amazon EC2](deployment-groups-create-load-balancer.md) y [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).
## Requisitos previos de despliegue para un despliegue a través de blue/green CloudFormation
+ La plantilla no necesita modelar los recursos para una CodeDeploy aplicación o un grupo de implementación.
+ La plantilla debe incluir recursos para una VPC usando Amazon VPC que contenga al menos dos subredes.
+ La plantilla debe incluir recursos para uno o más equilibradores de carga clásicos, equilibradores de carga de aplicación o equilibradores de carga de red en Elastic Load Balancing que se utilizan para dirigir el tráfico a sus grupos objetivo.
# Creación de una implementación en una plataforma de informática de Amazon ECS (consola)
En este tema se muestra cómo implementar un servicio de Amazon ECS mediante la consola. Para obtener más información, consulte [Tutorial: Implementación de una aplicación en Amazon ECS](tutorial-ecs-deployment.md) y [Tutorial: Implementación de un servicio de Amazon ECS con una prueba de validación](tutorial-ecs-deployment-with-hooks.md).
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. Realice una de las siguientes acciones:
+ Si desea implementar una aplicación, en el panel de navegación, expanda **Deploy (Implementar)** y, a continuación, elija **Applications (Aplicaciones)**. Elija el nombre de la aplicación que desea implementar. Asegúrese de que la columna **Plataforma de informática** de la aplicación sea **Amazon ECS**.
+ Si desea volver a implementar una implementación, en el panel de navegación, expanda **Implementar** y, a continuación, elija **Implementaciones**. Seleccione la implementación que desea volver a implementar y, en la columna **Application (Aplicación)**, elija el nombre de su aplicación. Asegúrese de que la columna **Plataforma de informática** de la implementación sea **Amazon ECS**.
1. En la pestaña **Implementaciones**, elija **Crear implementación**.
**nota**
La aplicación debe tener un grupo de implementación antes de poder implementarse. Si la aplicación no tiene un grupo de implementación, en la pestaña **Grupos de implementación**, elija **Crear grupo de implementación**. Para obtener más información, consulte [Cree un grupo de despliegue con CodeDeploy](deployment-groups-create.md).
1. En **Grupo de implementación**, elija el grupo de implementación que va a utilizar para esta implementación.
1. Junto a **Ubicación de la revisión**, elija el lugar donde se encuentra la revisión:
+ **Mi aplicación está almacenada en Amazon S3**: para obtener información, consulte [Especificar información acerca de una revisión almacenada en un bucket de Amazon S3](deployments-create-console-s3.md) y vuelva al paso 6.
+ **Utilizar el AppSpec editor**: selecciona JSON o YAML y, a continuación, introduce el AppSpec archivo en el editor. Para guardar el AppSpec archivo, selecciona **Guardar como archivo de texto**. Cuando elija **Implementar** al final de estos pasos, recibirá un error si el código JSON o YAML no es válido. Para obtener más información sobre la creación de un AppSpec archivo, consulte[Añadir un archivo de especificaciones de la aplicación a una revisión de CodeDeploy](application-revisions-appspec-file.md).
1. (Opcional) En el cuadro **Descripción de la implementación**, introduzca una descripción para la implementación.
1. (Opcional) En **Rollback configuration overrides**, puede especificar opciones de restauración automática de esta implementación distintas de las que se hayan especificado para el grupo de implementaciones, si las hay.
Para obtener información sobre las reversiones CodeDeploy, consulte [Reimplementaciones y restauración de implementaciones](deployment-steps-lambda.md#deployment-rollback-lambda) y[Vuelva a implementar y revertir una implementación con CodeDeploy](deployments-rollback-and-redeploy.md).
Elija una de las siguientes opciones:
+ Se **revierte cuando se produce un error en una implementación CodeDeploy: se vuelve a implementar** la última revisión válida conocida como una implementación nueva.
+ ** CodeDeploy Retirar cuando se alcanzan los umbrales de alarma: si se** agregaron alarmas al grupo de implementación, vuelve a implementar la última revisión válida conocida cuando se activan una o más de las alarmas especificadas.
+ **Deshabilitar restauraciones**: no se realizan restauraciones de esta implementación.
1. Elija **Crear implementación**.
Para realizar un seguimiento del estado de la implementación, consulte [Ver detalles CodeDeploy de la implementación](deployments-view-details.md).
# Crear una implementación de AWS Lambda Compute Platform (consola)
En este tema se muestra cómo implementar una función de Lambda mediante la consola.
1. 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. Realice una de las siguientes acciones:
+ Si desea implementar una aplicación, en el panel de navegación, expanda **Deploy (Implementar)** y, a continuación, elija **Applications (Aplicaciones)**. Elija el nombre de la aplicación que desea implementar. Asegúrese de que la columna **Plataforma de informática** de la aplicación sea **AWS Lambda**.
+ Si desea volver a implementar una implementación, en el panel de navegación, expanda **Implementar** y, a continuación, elija **Implementaciones**. Seleccione la implementación que desea volver a implementar y, en la columna **Application (Aplicación)**, elija el nombre de su aplicación. Asegúrese de que la columna **Plataforma de informática** de la implementación sea **AWS Lambda**.
1. En la pestaña **Implementaciones**, elija **Crear implementación**.
**nota**
La aplicación debe tener un grupo de implementación antes de poder implementarse. Si la aplicación no tiene un grupo de implementación, en la pestaña **Grupos de implementación**, elija **Crear grupo de implementación**. Para obtener más información, consulte [Cree un grupo de despliegue con CodeDeploy](deployment-groups-create.md).
1. En **Grupo de implementación**, elija el grupo de implementación que va a utilizar para esta implementación.
1. Junto a **Ubicación de la revisión**, elija el lugar donde se encuentra la revisión:
+ **Mi aplicación está almacenada en Amazon S3**: para obtener información, consulte [Especificar información acerca de una revisión almacenada en un bucket de Amazon S3](deployments-create-console-s3.md) y vuelva al paso 6.
+ **Utilizar el AppSpec editor**: selecciona JSON o YAML y, a continuación, introduce el AppSpec archivo en el editor. Para guardar el AppSpec archivo, selecciona **Guardar como archivo de texto**. Cuando elija **Implementar** al final de estos pasos, recibirá un error si el código JSON o YAML no es válido. Para obtener más información sobre la creación de un AppSpec archivo, consulte[Añadir un archivo de especificaciones de la aplicación a una revisión de CodeDeploy](application-revisions-appspec-file.md).
1. (Opcional) En el cuadro **Descripción de la implementación**, introduzca una descripción para la implementación.
1. (Opcional) Expanda **Anulaciones del grupo de implementación** para elegir una configuración de implementación que controle cómo se desvía el tráfico a una versión de la función de Lambda distinta de la que se especifica en el grupo de implementación.
Para obtener más información, consulte [Configuraciones de implementación en una plataforma AWS Lambda informática](deployment-configurations.md#deployment-configuration-lambda).
1. (Opcional) En **Rollback configuration overrides**, puede especificar opciones de restauración automática de esta implementación distintas de las que se hayan especificado para el grupo de implementaciones, si las hay.
Para obtener información sobre las reversiones CodeDeploy, consulte [Reimplementaciones y restauración de implementaciones](deployment-steps-lambda.md#deployment-rollback-lambda) y[Vuelva a implementar y revertir una implementación con CodeDeploy](deployments-rollback-and-redeploy.md).
Elija una de las siguientes opciones:
+ Se **revierte cuando se produce un error en una implementación CodeDeploy: se vuelve a implementar** la última revisión válida conocida como una implementación nueva.
+ ** CodeDeploy Retirar cuando se alcanzan los umbrales de alarma: si se** agregaron alarmas al grupo de implementación, vuelve a implementar la última revisión válida conocida cuando se activan una o más de las alarmas especificadas.
+ **Deshabilitar restauraciones**: no se realizan restauraciones de esta implementación.
1. Elija **Crear implementación**.
Para realizar un seguimiento del estado de la implementación, consulte [Ver detalles CodeDeploy de la implementación](deployments-view-details.md).
# Creación de una implementación en una plataforma de informática de EC2/en las instalaciones (consola)
En este tema se muestra cómo implementar una aplicación un servidor Amazon EC2 o en las instalaciones mediante la consola.
1. [Inicie sesión en la CodeDeploy consola Consola de administración de AWS y ábrala 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. Realice una de las siguientes acciones:
+ Si desea implementar una aplicación, en el panel de navegación, expanda **Deploy (Implementar)** y, a continuación, elija **Applications (Aplicaciones)**. Elija el nombre de la aplicación que desea implementar. Asegúrese de que la columna **Plataforma de informática** de la aplicación sea **EC2/en las instalaciones**.
+ Si desea volver a implementar una implementación, en el panel de navegación, expanda **Implementar** y, a continuación, elija **Implementaciones**. Localice la implementación que desea volver a implementar y, a continuación, elija el nombre de su aplicación en la columna **Application (Aplicación)**. Asegúrese de que la columna **Plataforma de informática** de la implementación sea **EC2/en las instalaciones**.
1. En la pestaña **Implementaciones**, elija **Crear implementación**.
**nota**
La aplicación debe tener un grupo de implementación antes de poder implementarse. Si la aplicación no tiene un grupo de implementación, en la pestaña **Grupos de implementación**, elija **Crear grupo de implementación**. Para obtener más información, consulte [Cree un grupo de despliegue con CodeDeploy](deployment-groups-create.md).
1. En **Grupo de implementación**, elija el grupo de implementación que va a utilizar para esta implementación.
1. Junto a **Repository type (Tipo de repositorio)**, seleccione el tipo de repositorio en el que está almacenada la revisión:
+ **Mi aplicación está almacenada en Amazon S3**: para obtener información, consulte [Especificar información acerca de una revisión almacenada en un bucket de Amazon S3](deployments-create-console-s3.md) y vuelva al paso 6.
+ **Mi aplicación está guardada en GitHub**: para obtener más información, consulte y[Especifique la información sobre una revisión almacenada en un GitHub repositorio](deployments-create-console-github.md), a continuación, vuelva al paso 6.
1. (Opcional) En el cuadro **Descripción de la implementación**, introduzca una descripción para la implementación.
1. (Opcional) Expanda **Anular la configuración de la implementación** para elegir una configuración de implementación que controle cómo se desvía el tráfico al servidor de Amazon EC2, o a uno en las instalaciones, distinto del que se especifica en el grupo de implementación.
Para obtener más información, consulte [Trabajar con configuraciones de implementación en CodeDeploy](deployment-configurations.md).
1.
1. Seleccione **No fallar la implementación si el evento del ApplicationStop ciclo de vida falla** si desea que la implementación en una instancia se realice correctamente si el evento del `ApplicationStop` ciclo de vida falla.
1. Amplíe la **configuración adicional del comportamiento de despliegue** para especificar CodeDeploy cómo se gestionan los archivos en una ubicación de destino de despliegue que no formaban parte de la anterior implementación exitosa.
Elija una de las siguientes opciones:
+ **Dar como errónea la implementación**: se notifica un error y el estado de la implementación cambia a `Failed`.
+ **Sobrescribir el contenido**: si hay un archivo del mismo nombre en la ubicación de destino, la versión de la revisión de la aplicación lo sustituye.
+ **Retener el contenido**: si hay un archivo del mismo nombre en la ubicación de destino, este se conserva y la versión de la revisión de la aplicación no se copia en la instancia.
Para obtener más información, consulte [Comportamiento de la restauración con contenido existente](deployments-rollback-and-redeploy.md#deployments-rollback-and-redeploy-content-options).
1. (Opcional) En **Rollback configuration overrides**, puede especificar opciones de restauración automática de esta implementación distintas de las que se hayan especificado para el grupo de implementaciones, si las hay.
Para obtener información sobre las reversiones CodeDeploy, consulte [Reimplementaciones y restauración de implementaciones](deployment-steps-server.md#deployment-rollback) y[Vuelva a implementar y revertir una implementación con CodeDeploy](deployments-rollback-and-redeploy.md).
Elija una de las siguientes opciones:
+ Se **revierte cuando se produce un error en una implementación CodeDeploy: se vuelve a implementar** la última revisión válida conocida como una implementación nueva.
+ **Retirar cuando se alcanzan los umbrales de alarma**: si se agregaron alarmas al grupo de implementación, CodeDeploy implementa la última revisión válida conocida cuando se activan una o más de las alarmas especificadas.
+ **Deshabilitar restauraciones**: no se realizan restauraciones de esta implementación.
1. Elija **Iniciar la implementación**.
Para realizar un seguimiento del estado de la implementación, consulte [Ver detalles CodeDeploy de la implementación](deployments-view-details.md).
**Topics**
+ [Especificar información acerca de una revisión almacenada en un bucket de Amazon S3](deployments-create-console-s3.md)
+ [Especifique la información sobre una revisión almacenada en un GitHub repositorio](deployments-create-console-github.md)
# Especificar información acerca de una revisión almacenada en un bucket de Amazon S3
Si está siguiendo los pasos descritos en [Creación de una implementación en una plataforma de informática de EC2/en las instalaciones (consola)](deployments-create-console.md), siga estos también para añadir detalles acerca de una revisión de la aplicación almacenada en un bucket de Amazon S3.
1. 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/).
Busque y seleccione la revisión.
1. Si el panel **Properties** no está visible, elija el botón **Properties**.
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.
Para especificar una ETag (suma de comprobación de archivos) como parte de la ubicación de la revisión:
+ Si el valor del campo de **enlace** termina en**?versionId=*versionId***, añada **&etag=** y ETag al final del valor del campo de **enlace**.
+ Si el valor del campo de **enlace** no especifica un identificador de versión, añada **?etag=** y el ETag valor al final del campo de **enlace**.
**nota**
Aunque no es tan fácil como copiar el valor del campo **Link**, también puede escribir la ubicación de la revisión en uno de los siguientes formatos:
**s3://*bucket-name*/*folders*/*objectName***
**s3://*bucket-name*/*folders*/*objectName*?versionId=*versionId***
**s3://*bucket-name*/*folders*/*objectName*?etag=*etag***
**s3://*bucket-name*/*folders*/*objectName*?versionId=*versionId*&etag=*etag***
***bucket-name*.s3.amazonaws.com/*folders*/*objectName***
1. Si aparece un mensaje en la lista **File type** que indique que no se ha podido detectar el tipo de archivo, seleccione el tipo de archivo de la revisión. En caso contrario, acepte el tipo de archivo detectado.
# Especifique la información sobre una revisión almacenada en un GitHub repositorio
Si sigue los pasos descritos[Creación de una implementación en una plataforma de informática de EC2/en las instalaciones (consola)](deployments-create-console.md), siga estos pasos para añadir detalles sobre una revisión de la aplicación almacenada en un GitHub repositorio.
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 en otra pestaña del navegador web GitHub. 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 su aplicación. Continúe en el paso 2.
+ 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 4.
+ Para crear una conexión a otra GitHub cuenta, cierra sesión en otra pestaña del navegador web GitHub. Selecciona **Conectarse a una GitHub cuenta diferente** y, a continuación, selecciona **Conectar a GitHub**. Continúe en el paso 2.
1. Si se te pide que inicies sesión GitHub, sigue las instrucciones de la página de inicio de **sesión**. Inicie sesión con su nombre GitHub de usuario o correo electrónico y contraseña.
1. Si aparece la página **Authorize application**, elija **Authorize application**.
1. En la página **Crear despliegue**, en el cuadro **Nombre del repositorio**, introduzca el nombre del GitHub usuario o la organización que contiene la revisión, seguido de una barra diagonal (`/`) seguida del nombre del repositorio que contiene la revisión. Si no está seguro del valor que debe especificar:
1. En otra pestaña del navegador web, ve a tu [GitHubpanel](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 el valor mostrado en el cuadro **Repository name** (Nombre de repositorio).
**nota**
Si el nombre del repositorio de destino no está visible en **Tus repositorios**, usa el GitHub cuadro de **búsqueda para buscar** el nombre del repositorio de destino y el nombre del GitHub usuario u organización.
1. En el campo **Commit ID** (ID de confirmación), escriba el ID de la confirmación que hace referencia a la revisión en el repositorio. Si no está seguro del valor que debe especificar:
1. En otra pestaña del navegador web, ve a tu [GitHubpanel](https://github.com/dashboard) de control.
1. En **Your repositories**, seleccione el nombre del repositorio que contiene la confirmación de destino.
1. En la lista de confirmaciones, busque y copie el ID de confirmación que hace referencia a la revisión en el repositorio. 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**.
# Creación de una implementación en una plataforma de informática de Amazon ECS (CLI)
Una vez creada la aplicación y la revisión (en las implementaciones de Amazon ECS, este es el AppSpec archivo):
Llame al comando [create-deployment](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment.html) especificando lo siguiente:
+ Un nombre de aplicación. Para ver una lista de nombres de aplicaciones, llame al comando [list-applications](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-applications.html).
+ El nombre del grupo de implementaciones. Para ver una lista de los nombres de los grupos de implementaciones, llame al comando [list-deployment-groups](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployment-groups.html).
+ Información acerca de la revisión a implementar:
Para revisiones almacenadas en Amazon S3:
+ Nombre del bucket de Amazon S3 que contiene la revisión.
+ El nombre de la revisión cargada.
+ (Opcional) El identificador de versión de Amazon S3 de la revisión. (Si no se especifica el identificador de la versión, CodeDeploy utiliza la versión más reciente).
+ (Opcional) El ETag de la revisión. (Si no ETag se especifica, CodeDeploy omite la validación del objeto).
Para las revisiones almacenadas en un archivo que no está en Amazon S3, necesita el nombre de archivo y su ruta. El archivo de revisión está escrito en JSON o YAML, por lo que probablemente tenga una extensión .json o .yaml.
+ Una descripción para la implementación (opcional).
El archivo de revisión se puede especificar como un archivo cargado en un bucket de Amazon S3 o como una cadena. La sintaxis de cada uno cuando se usa como parte del comando **create-deployment** es:
+ Bucket de Amazon S3:
Los parámetros `version` y `eTag` son opcionales.
```
--s3-location bucket=string,key=string,bundleType=JSON|YAML,version=string,eTag=string
```
+ Cadena:
```
--revision '{"revisionType": "String", "string": {"content":"revision-as-string"}}'
```
**nota**
El comando **create-deployment** puede cargar una revisión desde un archivo. Para obtener más información, consulte [Carga de parámetros desde un archivo](https://docs.aws.amazon.com/cli/latest/userguide/cli-using-param.html#cli-using-param-file).
Para ver las plantillas de revisión de AWS Lambda despliegue, consulte[Agregar un AppSpec archivo para una implementación de AWS Lambda](application-revisions-appspec-file.md#add-appspec-file-lambda). Para ver una revisión de ejemplo, consulte [AppSpec Ejemplo de archivo para una implementación de AWS Lambda](reference-appspec-file-example.md#appspec-file-example-lambda).
Para realizar un seguimiento del estado de la implementación, consulte [Ver detalles CodeDeploy de la implementación](deployments-view-details.md).
# Crear una implementación de AWS Lambda Compute Platform (CLI)
Una vez que haya creado la aplicación y la revisión (en las implementaciones de AWS Lambda, este es el AppSpec archivo):
Llame al comando [create-deployment](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment.html) especificando lo siguiente:
+ Un nombre de aplicación. Para ver una lista de nombres de aplicaciones, llame al comando [list-applications](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-applications.html).
+ El nombre del grupo de implementaciones. Para ver una lista de los nombres de los grupos de implementaciones, llame al comando [list-deployment-groups](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployment-groups.html).
+ Información acerca de la revisión a implementar:
Para revisiones almacenadas en Amazon S3:
+ Nombre del bucket de Amazon S3 que contiene la revisión.
+ El nombre de la revisión cargada.
+ (Opcional) El identificador de versión de Amazon S3 de la revisión. (Si no se especifica el identificador de la versión, CodeDeploy utiliza la versión más reciente).
+ (Opcional) El ETag de la revisión. (Si no ETag se especifica, CodeDeploy omite la validación del objeto).
Para las revisiones almacenadas en un archivo que no está en Amazon S3, necesita el nombre de archivo y su ruta. El archivo de revisión está escrito en JSON o YAML, por lo que probablemente tenga una extensión .json o .yaml.
+ El nombre de la configuración de implementación a utilizar (opcional). Para ver una lista de las configuraciones de implementación, realice una llamada al comando [list-deployment-configs](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployment-configs.html). (Si no se especifica, CodeDeploy utiliza una configuración de despliegue predeterminada específica).
+ Una descripción para la implementación (opcional).
El archivo de revisión se puede especificar como un archivo cargado en un bucket de Amazon S3 o como una cadena. La sintaxis de cada uno cuando se usa como parte del comando **create-deployment** es:
+ Bucket de Amazon S3:
Los parámetros `version` y `eTag` son opcionales.
```
--s3-location bucket=string,key=string,bundleType=JSON|YAML,version=string,eTag=string
```
+ Cadena:
```
--revision '{"revisionType": "String", "string": {"content":"revision-as-string"}}'
```
**nota**
El comando **create-deployment** puede cargar una revisión desde un archivo. Para obtener más información, consulte [Carga de parámetros desde un archivo](https://docs.aws.amazon.com/cli/latest/userguide/cli-using-param.html#cli-using-param-file).
Para ver las plantillas de revisión de AWS Lambda despliegue, consulte[Agregar un AppSpec archivo para una implementación de AWS Lambda](application-revisions-appspec-file.md#add-appspec-file-lambda). Para ver una revisión de ejemplo, consulte [AppSpec Ejemplo de archivo para una implementación de AWS Lambda](reference-appspec-file-example.md#appspec-file-example-lambda).
Para realizar un seguimiento del estado de la implementación, consulte [Ver detalles CodeDeploy de la implementación](deployments-view-details.md).
# Creación de una implementación en una plataforma de informática EC2/en las instalaciones (CLI)
Para usar el AWS CLI para implementar una revisión en la plataforma informática local de EC2:
1. Una vez preparadas las instancias, creada la aplicación y enviada la revisión, realice alguna de las siguientes acciones:
+ Si desea implementar una revisión de un bucket de Amazon S3, continúe con el paso 2.
+ Si desea implementar una revisión desde un GitHub repositorio, primero complete los pasos del paso 2 y, a continuación[Conectar una CodeDeploy aplicación a un GitHub repositorio](deployments-create-cli-github.md), continúe con el paso 2.
1. Llame al comando [create-deployment](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment.html) especificando lo siguiente:
+ `--application-name`: un nombre de aplicación. Para ver una lista de nombres de aplicaciones, llame al comando [list-applications](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-applications.html).
+ `--deployment-group-name`: un nombre de grupo de implementación de Amazon EC2. Para ver una lista de los nombres de los grupos de implementaciones, llame al comando [list-deployment-groups](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployment-groups.html).
+ `--revision`: información acerca de la revisión a implementar:
Para revisiones almacenadas en Amazon S3:
+ `s3Location`: nombre del bucket de Amazon S3 que contiene la revisión.
+ `s3Location --> key`: nombre de la revisión cargada.
+ `s3Location --> bundleType`: nombre y tipo de archivo de la revisión cargada.
**nota**
Los formatos de archivo tar y tar comprimido (.tar y .tar.gz) no son compatibles con las instancias de Windows Server.
+ `s3Location --> version`: (Opcional) El identificador de versión de Amazon S3 de la revisión. (Si no se especifica el identificador de versión, CodeDeploy utiliza la versión más reciente).
+ `s3Location --> eTag`: (Opcional) El ETag para la revisión. (Si no ETag se especifica, CodeDeploy omite la validación del objeto).
Para las revisiones almacenadas en GitHub:
+ `gitHubLocation --> repository`: el nombre de GitHub usuario o grupo asignado al repositorio que contiene la revisión, seguido de una barra diagonal (`/`) seguida del nombre del repositorio.
+ `gitHubLocation --> commitId`: ID de confirmación de la revisión.
+ `--deployment-config-name`: (Opcional) El nombre de la configuración de implementación a utilizar. Para ver una lista de las configuraciones de implementación, realice una llamada al comando [list-deployment-configs](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployment-configs.html). (Si no se especifica, CodeDeploy utiliza una configuración de despliegue predeterminada específica).
+ `--ignore-application-stop-failures | --no-ignore-application-stop-failures`: si desea que la implementación en una instancia continúe y pase al evento del ciclo de vida `BeforeInstall` en caso de que se produzca un error en el evento del ciclo de vida de la implementación `ApplicationStop` (opcional).
+ `--description`: una descripción para la implementación (opcional).
+ `--file-exists-behavior`: (Opcional) Como parte del proceso de implementación, el CodeDeploy agente elimina de cada instancia todos los archivos instalados en la implementación más reciente. Elija qué ocurre cuando los archivos que no formaban parte de una implementación anterior aparecen en las ubicaciones de implementación de destino.
+ `--target-instances`: Para blue/green las implementaciones, información sobre las instancias que pertenecen al entorno de reemplazo de una blue/green implementación, incluidos los nombres de uno o más grupos de Amazon EC2 Auto Scaling o la clave, el tipo y el valor del filtro de etiquetas utilizados para identificar las instancias de Amazon EC2.
**nota**
Utilice esta sintaxis como parte de la llamada a **create-deployment** para especificar información sobre una revisión en Amazon S3 directamente en la línea de comandos. Los parámetros `version` y `eTag` son opcionales.
```
--s3-location bucket=string,key=string,bundleType=tar|tgz|zip,version=string,eTag=string
```
Utilice esta sintaxis como parte de la **create-deployment** llamada para especificar la información sobre una revisión GitHub directamente en la línea de comandos:
```
--github-location repository=string,commitId=string
```
Para obtener información acerca de las revisiones que se han transferido, realice una llamada al comando [list-application-revisions](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-application-revisions.html).
Para realizar un seguimiento del estado de la implementación, consulte [Ver detalles CodeDeploy de la implementación](deployments-view-details.md).
## referencia del comando create-deployment
A continuación se muestran la estructura y las opciones del comando `create-deployment`. Para obtener más información, consulte la referencia de [create-deployment](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment.html) en la *Referencia del comando AWS CLI *.
```
create-deployment
--application-name
[--deployment-group-name ]
[--revision ]
[--deployment-config-name ]
[--description ]
[--ignore-application-stop-failures | --no-ignore-application-stop-failures]
[--target-instances ]
[--auto-rollback-configuration ]
[--update-outdated-instances-only | --no-update-outdated-instances-only]
[--file-exists-behavior ]
[--s3-location ]
[--github-location ]
[--cli-input-json ]
[--generate-cli-skeleton ]
```
# Conectar una CodeDeploy aplicación a un GitHub repositorio
Antes de poder implementar una aplicación desde un GitHub repositorio por primera vez utilizando el AWS CLI, primero debes dar CodeDeploy permiso para interactuar con ella GitHub en nombre de tu GitHub cuenta. Este paso debe completarse una vez para cada aplicación que utilice la CodeDeploy consola.
1. 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. Elija **Aplicaciones**.
1. En **Aplicaciones**, elija la aplicación que desee vincular a su cuenta de GitHub usuario y elija **Implementar** aplicación.
**nota**
No está creando una implementación. Actualmente, esta es la única forma de conceder CodeDeploy permiso para interactuar con ella GitHub en nombre de su cuenta de GitHub usuario.
1. Junto a **Tipo de repositorio**, selecciona **En qué se guarda la revisión de mi aplicación GitHub**.
1. Selecciona **Conectar a GitHub**.
**nota**
Si ves un enlace de **Conectarse a una GitHub cuenta diferente**:
Es posible que ya tengas autorización CodeDeploy para interactuar GitHub en nombre de otra GitHub cuenta de la aplicación.
Es posible que hayas revocado la autorización CodeDeploy para interactuar GitHub en nombre de la GitHub cuenta en la que has iniciado sesión en todas las aplicaciones vinculadas a ella. CodeDeploy
Para obtener más información, consulte [GitHub autenticación con aplicaciones en CodeDeploy](integrations-partners-github.md#behaviors-authentication).
1. **Si aún no ha iniciado sesión GitHub, siga las instrucciones de la página de inicio de sesión.**
1. En la página **Authorize application**, elija **Authorize application**.
1. Ahora CodeDeploy que tienes permiso, selecciona **Cancelar** y continúa con los pasos indicados[Creación de una implementación en una plataforma de informática EC2/en las instalaciones (CLI)](deployments-create-cli.md).
# Cree una blue/green implementación de Amazon ECS mediante CloudFormation
Puede utilizarlo AWS CloudFormation para gestionar las blue/green implementaciones de Amazon ECS a través CodeDeploy de. Para generar la implementación, defina los recursos verdes y azules y especifique la configuración de enrutamiento y estabilización del tráfico que se va a utilizar en CloudFormation. En este tema se describen las diferencias entre las blue/green implementaciones de Amazon ECS gestionadas por CodeDeploy y las gestionadas por. CloudFormation
*Para step-by-step obtener instrucciones sobre cómo administrar las implementaciones azul/verde de Amazon ECS, consulte [Automatizar las implementaciones azul/verde de ECS mediante CodeDeploy el uso CloudFormation en la Guía del usuario](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/blue-green.html). AWS CloudFormationAWS CloudFormation *
**nota**
La administración de blue/green las implementaciones de Amazon ECS con no CloudFormation está disponible en la región de Asia Pacífico (Osaka).
## Diferencias entre las blue/green implementaciones de Amazon ECS hasta CodeDeploy y CloudFormation
La plantilla de CloudFormation pila modela los recursos y la infraestructura relacionados con las tareas de Amazon ECS, así como las opciones de configuración para las implementaciones. Por lo tanto, existen diferencias entre las implementaciones estándar de Amazon ECS y blue/green las blue/green implementaciones que se crean mediante ellas. CloudFormation
A diferencia de blue/green las implementaciones estándar de Amazon ECS, no se modela ni se crea manualmente lo siguiente:
+ No se crea una AWS CodeDeploy aplicación especificando un nombre que represente de forma exclusiva lo que se quiere implementar.
+ No se crea un grupo AWS CodeDeploy de implementación.
+ No se especifica un archivo de *especificaciones de la aplicación (AppSpec archivo*). La información que normalmente se gestiona con el AppSpec archivo, como las opciones de configuración ponderadas o los eventos del ciclo de vida, se gestiona mediante un `AWS::CodeDeploy::BlueGreen` enlace.
En esta tabla se resumen las diferencias en el flujo de trabajo de alto nivel entre los tipos de implementación.
****
| Función | blue/green Implementaciones estándar | Implementaciones azul/verdes hasta CloudFormation |
| --- | --- | --- |
| Especifique el clúster de Amazon ECS, el servicio Amazon ECS, el Equilibrador de carga de aplicación o el Equilibrador de carga de red, el Oyente de producción, el oyente de prueba y los dos grupos de destino. | Cree un grupo de CodeDeploy despliegue que especifique estos recursos. | Cree una CloudFormation plantilla para modelar estos recursos. |
| Especifique el cambio que se va a implementar. | Cree una CodeDeploy aplicación. | Cree una CloudFormation plantilla que especifique la imagen del contenedor. |
| Especifique la definición de tarea de Amazon ECS, el nombre del contenedor y el puerto del contenedor. | Cree un AppSpec archivo que especifique estos recursos. | Cree una CloudFormation plantilla para modelar estos recursos. |
| Especifique las opciones de cambio de tráfico de implementación y los enlaces de eventos de ciclo de vida. | Cree un AppSpec archivo que especifique estas opciones. | Cree una CloudFormation plantilla que utilice los parámetros de AWS::CodeDeploy::BlueGreen gancho para especificar estas opciones. |
| CloudWatch alarmas. | Cree una CloudWatch alarma que desencadene una reversión. | Configure una CloudWatch alarma a nivel de CloudFormation pila que active una reversión. |
| Restauración/reimplementación. | Especifique las opciones de restauración y reimplementación. | Cancela la actualización de la pila en CloudFormation. |
## Supervisión de las blue/green implementaciones de Amazon ECS mediante CloudFormation
Puede monitorear las blue/green implementaciones a través de y. CloudFormation CodeDeploy Para obtener información sobre la supervisión continua CloudFormation, consulte la [sección Supervisión de blue/green eventos CloudFormation en](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/blue-green.html#blue-green-events) la *Guía del AWS CloudFormation usuario*.
**Para ver el estado de despliegue de los blue/green despliegues en CodeDeploy**
1. Inicie sesión en Consola de administración de AWS [https://console.aws.amazon.com/codedeploy](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 **Implementaciones, aparece** la implementación que se activó por la actualización de la CloudFormation pila. Elija la implementación para ver el **Deployment history (Historial de implementaciones)**.
![\[Captura de pantalla de la consola que muestra la sección Deployments (Implementaciones) y el Deployment history (Historial de implementaciones).\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/images/cfn-cd-bg-deplhist.png)
1. Elija la implementación para ver el estado de cambio de tráfico. Tenga en cuenta que el grupo de aplicación e implantación no se han creado.
![\[Captura de pantalla de la consola que muestra los detalles de implementación con el estado de implementación completado.\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/images/cfn-cd-bg-deplstatus.png)
1. Lo siguiente se aplica para restaurar o detener la implementación:
+ La implementación correcta aparece en CodeDeploy y muestra que la implementación fue iniciada por CloudFormation.
+ Si quiere detener y revertir la implementación, debe cancelar la actualización de la pila en CloudFormation.
# Ver detalles CodeDeploy de la implementación
Puede usar la CodeDeploy consola AWS CLI, la o la CodeDeploy APIs para ver los detalles de las implementaciones asociadas a su AWS cuenta.
**nota**
Puede ver los registros de las implementaciones de EC2/en las instalaciones de las instancias en las siguientes ubicaciones:
Para Amazon Linux, RHEL y Ubuntu Server: `/opt/codedeploy-agent/deployment-root/deployment-logs/codedeploy-agent-deployments.log`
Servidor Windows: C:\$1ProgramData\$1 Amazon\$1 CodeDeploy \$1 logs\$1 scripts.log
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).
**Topics**
+ [Visualización de los detalles de la implementación (consola)](#deployments-view-details-console)
+ [Visualización de los detalles de la implementación (CLI)](#deployments-view-details-cli)
## Visualización de los detalles de la implementación (consola)
Para usar la CodeDeploy consola para ver los detalles de la implementació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)
**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**.
**nota**
Si no se muestra ninguna entrada, asegúrese de seleccionar la región correcta. En la barra de navegación, en el selector de regiones, elija una de las regiones que aparecen en [Región y puntos finales](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) en. *Referencia general de AWS* CodeDeploy solo se admite en estas regiones.
1. Para ver más detalles sobre una única implementación, en **Deployment history (Historial de implementaciones)**, elija el ID de la implementación o seleccione el botón situado junto al ID de implementación y, a continuación, elija **View (Ver)**.
## Visualización de los detalles de la implementación (CLI)
Para usar el AWS CLI para ver los detalles de la implementación, llame al `get-deployment` comando o al `batch-get-deployments` comando. Puede llamar al `list-deployments` comando para obtener una lista de despliegues únicos y IDs utilizarlos como entradas para el `get-deployment` comando y el `batch-get-deployments` comando.
Para ver los detalles de una única implementación, ejecute el comando [get-deployment](https://docs.aws.amazon.com/cli/latest/reference/deploy/get-deployment.html), especificando el identificador exclusivo de la implementación. Para obtener el ID de implementación, llame al comando [list-deployments](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployments.html).
Para ver los detalles de múltiples implementaciones, ejecute el comando [batch-get-deployments](https://docs.aws.amazon.com/cli/latest/reference/deploy/batch-get-deployments.html), especificando los identificadores exclusivos de las múltiples implementaciones. Para obtener la implementación IDs, ejecute el comando [list-deployments](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployments.html).
Para ver una lista de despliegues IDs, ejecuta el comando [list-deployments](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployments.html) y especifica:
+ El nombre de la aplicación asociada a la implementación. Para ver una lista de nombres de aplicaciones, llame al comando [list-applications](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-applications.html).
+ El nombre del grupo de implementaciones asociado a la implementación. Para ver una lista de los nombres de los grupos de implementaciones, llame al comando [list-deployment-groups](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployment-groups.html).
+ Si lo prefiere, puede incluir detalles acerca de las implementaciones por su estado de implementación. (Si no se especifican, se enumerarán todas las implementaciones coincidentes, independientemente de su estado de implementación).
+ Si lo prefiere, puede incluir detalles acerca de las implementaciones por la hora de inicio o final de creación o ambas. (Si no se especifican, se enumerarán todas las implementaciones coincidentes, independientemente de sus horas de creación).
# Vea los datos de registro de las implementaciones locales CodeDeploy de EC2/
Puedes ver los datos de registro creados por una CodeDeploy implementación configurando el CloudWatch agente de Amazon para que vea los datos agregados en la CloudWatch consola o iniciando sesión en una instancia individual para revisar el archivo de registro.
**nota**
Los registros no son compatibles con las AWS implementaciones de Lambda o Amazon ECS. Solamente se pueden crear para implementaciones de EC2/en las instalaciones.
**Topics**
+ [Ver los datos de los archivos de registro en la CloudWatch consola de Amazon](#deployments-view-logs-cloudwatch)
+ [Visualización de los archivos de registro de una instancia](#deployments-view-logs-instance)
## Ver los datos de los archivos de registro en la CloudWatch consola de Amazon
Cuando el CloudWatch agente de Amazon está instalado en una instancia, los datos de despliegue de todas las implementaciones de esa instancia están disponibles para su visualización en la CloudWatch consola. Para simplificar, le recomendamos que lo utilice CloudWatch para supervisar de forma centralizada los archivos de registro en lugar de verlos instancia por instancia. Para obtener más información, consulte [Enviar los registros CodeDeploy de los agentes a CloudWatch](codedeploy-agent-operations-cloudwatch-agent.md).
## Visualización de los archivos de registro de una instancia
Para ver los datos del log de implementación de una instancia individual, puede iniciar sesión en la instancia y examinar la información sobre errores u otros eventos de implementación.
**Topics**
+ [Para ver los archivos de registro de implementación en las instancias de Amazon Linux, RHEL y Ubuntu Server](#deployments-view-logs-instance-unix)
+ [Para ver los archivos de registro de implementación en las instancias de Windows Server](#deployments-view-logs-instance-windows)
### Para ver los archivos de registro de implementación en las instancias de Amazon Linux, RHEL y Ubuntu Server
En las instancias de Amazon Linux, RHEL y Ubuntu Server, los registros de implementación se encuentran en la siguiente ubicación:
`/opt/codedeploy-agent/deployment-root/deployment-logs/codedeploy-agent-deployments.log`
Para ver o analizar los registros de implementación en las instancias de Amazon Linux, RHEL y Ubuntu Server, inicie sesión en la instancia y, a continuación, escriba el siguiente comando para abrir el archivo de registro del CodeDeploy agente:
```
less /var/log/aws/codedeploy-agent/codedeploy-agent.log
```
Ejecute los comandos siguientes para buscar mensajes de error en el archivo de registro:
| Comando | Resultado |
| --- | --- |
| & ERROR | Muestra solo los mensajes de error del archivo de registro. Utilice un único espacio delante y detrás de la palabra ERROR. |
| / ERROR | Busque el mensaje de error siguiente.¹ |
| ? ERROR | Busque el mensaje de error anterior.² Utilice un solo espacio antes y después de la palabra ERROR. |
| G | Ir al final del archivo de registro. |
| g | Ir al inicio del archivo de registro. |
| q | Salir del archivo de registro. |
| h | Conozca otros comandos. |
| ¹ Después de escribir **/ ERROR **, escriba **n** para ir al mensaje de error siguiente. Escriba **N** para ir al mensaje de error anterior. ² Después de escribir **? ERROR **, escriba **n** para ir al mensaje de error siguiente o **N** para ir al mensaje de error anterior. |
También puedes escribir el siguiente comando para abrir un archivo de registro de CodeDeploy scripts:
```
less /opt/codedeploy-agent/deployment-root/deployment-group-ID/deployment-ID/logs/scripts.log
```
Ejecute los comandos siguientes para buscar mensajes de error en el archivo de registro:
| Comando | Resultado |
| --- | --- |
| &stderr | Muestra solo los mensajes de error del archivo de registro. |
| /stderr | Busque el mensaje de error siguiente.¹ |
| ?stderr | Busca el mensaje de error anterior.² |
| G | Ir al final del archivo de registro. |
| g | Ir al inicio del archivo de registro. |
| q | Salir del archivo de registro. |
| h | Conozca otros comandos. |
| Después de escribir **/stderr**, escriba **n** para ir al mensaje de error siguiente hacia delante. Escriba **N** para ir al mensaje de error anterior hacia atrás. ² Después de escribir **?stderr**, escriba **n** para ir al mensaje de error siguiente hacia atrás. Escriba **N** para ir al mensaje de error anterior hacia delante. |
### Para ver los archivos de registro de implementación en las instancias de Windows Server
**CodeDeploy archivo de registro del agente**: en las instancias de Windows Server, el archivo de registro del CodeDeploy agente se almacena en la siguiente ubicación:
`C:\ProgramData\Amazon\CodeDeploy\log\codedeploy-agent-log.txt`
Para ver o analizar el archivo de registro del CodeDeploy agente en una instancia de Windows Server, inicie sesión en la instancia y, a continuación, escriba el siguiente comando para abrir el archivo:
```
notepad C:\ProgramData\Amazon\CodeDeploy\log\codedeploy-agent-log.txt
```
Para buscar mensajes de error en el archivo de registro, pulse CTRL\$1F, escriba **ERROR [** y, a continuación, pulse Intro para encontrar el primer error.
**CodeDeploy archivos de registro de scripts**: en las instancias de Windows Server, los registros de implementación se almacenan en la siguiente ubicación:
`C:\ProgramData\Amazon\CodeDeploy\deployment-group-id\deployment-id\logs\scripts.log`
Donde:
+ *deployment-group-id*es una cadena como `examplebf3a9c7a-7c19-4657-8684-b0c68d0cd3c4`
+ *deployment-id*es un identificador como `d-12EXAMPLE`
Escriba el siguiente comando para abrir un archivo de registro de CodeDeploy scripts:
```
notepad C:\ProgramData\Amazon\CodeDeploy\deployment-group-ID\deployment-ID\logs\scripts.log
```
Para buscar mensajes de error en el archivo de registro, pulse CTRL\$1F, escriba **stderr** y, a continuación, pulse Intro para encontrar el primer error.
# Detención de una implementación con CodeDeploy
Puede utilizar la consola de CodeDeploy, la AWS CLI o las API de CodeDeploy para detener implementaciones asociadas a su cuenta de AWS.
**aviso**
Si se detiene una implementación de EC2/en las instalaciones, es posible que algunas o todas las instancias de los grupos de implementación queden en un estado de implementación indeterminado. Para obtener más información, consulte [Implementaciones detenidas y que producen error](deployment-steps-server.md#deployment-stop-fail).
**Topics**
+ [Detención de una implementación (consola)](#deployments-stop-console)
+ [Detener una implementación (CLI)](#deployments-stop-cli)
**nota**
Si la implementación es una implementación azul/verde a través de CloudFormation, no puede realizar esta tarea en la consola de CodeDeploy. Vaya a la consola de CloudFormation para realizar esta tarea.
## Detención de una implementación (consola)
1. Inicie sesión en la Consola de administración de AWS y abra la consola de CodeDeploy 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**.
**nota**
Si no se muestra ninguna entrada, asegúrese de seleccionar la región correcta. En la barra de navegación, en el selector de regiones, elija una de las regiones que figuran en la lista de [Regiones y puntos de conexión](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) en *Referencia general de AWS*. CodeDeploy solo se admite en estas regiones.
1. Elija la implementación que desea que deje de hacer una de las siguientes acciones:
1. Elija **Stop deployment (Detener la implementación)** para detener la implementación sin realizar una restauración.
1. Elija **Stop and roll back deployment (Detener y restaurar la implementación)** para detener y restaurar la implementación.
Para obtener más información, consulte [Vuelva a implementar y revertir una implementación con CodeDeploy](deployments-rollback-and-redeploy.md).
**nota**
Si **Stop deployment (Detener la implementación)** y **Stop and roll back deployment (Detener y restaurar la implementación)** aparecen no disponibles, la implementación ha progresado hasta un punto en el que no puede detenerse.
## Detener una implementación (CLI)
Llame al comando [stop-deployment](https://docs.aws.amazon.com/cli/latest/reference/deploy/stop-deployment.html) y especifique el ID de la implementación. Para ver una lista de los ID de implementación, llame al comando [list-deployments](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployments.html).
# Vuelva a implementar y revertir una implementación con CodeDeploy
CodeDeploy revierte las implementaciones al volver a implementar una revisión de una aplicación previamente implementada como una nueva implementación. Estas implementaciones acumuladas son técnicamente nuevas, con una implementación nueva, en lugar de versiones restauradas de una implementación IDs anterior.
Las implementaciones se pueden restaurar de forma automática o manual.
**Topics**
+ [Restauraciones automáticas](#deployments-rollback-and-redeploy-automatic-rollbacks)
+ [Restauraciones manuales](#deployments-rollback-and-redeploy-manual-rollbacks)
+ [Flujo de trabajo de la restauración y reimplementación](#deployments-rollback-and-redeploy-workflow)
+ [Comportamiento de la restauración con contenido existente](#deployments-rollback-and-redeploy-content-options)
## Restauraciones automáticas
Puede configurar una implementación o un grupo de implementaciones para que se restauren automáticamente si falla una implementación o si se supera un umbral de monitorización que haya especificado. En este caso, se implementa la última versión correcta conocida de una revisión de la aplicación. Puede configurar restauraciones automáticas al crear una aplicación o al crear o actualizar un grupo de implementaciones.
Al crear una nueva implementación, también puede optar por anular la configuración de restauración automática especificada para el grupo de implementaciones.
**nota**
Puede utilizar Amazon Simple Notification Service para recibir una notificación cuando se restaure automáticamente una implementación. Para obtener información, consulte [Monitorización de implementaciones con notificaciones de eventos de Amazon SNS](monitoring-sns-event-notifications.md).
Para obtener más información acerca de cómo configurar restauraciones automáticas, consulte [Configuración de las opciones avanzadas de un grupo de implementación](deployment-groups-configure-advanced-options.md).
## Restauraciones manuales
Si no ha configurado restauraciones automáticas, puede restaurar manualmente una implementación creando una nueva implementación que utilice cualquier revisión de una aplicación implementada anteriormente y siguiendo los pasos para volver a implementar una revisión. Puede hacerlo si una aplicación se ha quedado en un estado desconocido. En lugar de dedicar mucho tiempo a resolver problemas, puede volver a implementar la aplicación a un estado operativo conocido. Para obtener más información, consulte [Cree una implementación con CodeDeploy](deployments-create.md).
**nota**
Si eliminas una instancia de un grupo de despliegues, CodeDeploy no desinstala nada que pueda estar ya instalado en esa instancia.
## Flujo de trabajo de la restauración y reimplementación
Cuando se inicia la reversión automática, o cuando se inicia manualmente una redistribución o reversión manual, CodeDeploy primero intenta eliminar de cada instancia participante todos los archivos que se instalaron correctamente por última vez. CodeDeploy lo hace comprobando el archivo de limpieza:
Archivo `/opt/codedeploy-agent/deployment-root/deployment-instructions/deployment-group-ID-cleanup` (para las instancias de Amazon Linux, Ubuntu Server y RHEL)
Archivo `C:\ProgramData\Amazon\CodeDeploy\deployment-instructions\deployment-group-ID-cleanup` (para las instancias de Windows Server)
Si existe, CodeDeploy utiliza el archivo de limpieza para eliminar de la instancia todos los archivos de la lista antes de iniciar la nueva implementación.
Por ejemplo, los dos primeros archivos de texto y los dos archivos de script ya estaban implementados una instancia de Amazon EC2 que ejecutaba Windows Server y los scripts crearon dos archivos de texto más durante los eventos del ciclo de vida de la implementación:
```
c:\temp\a.txt (previously deployed by CodeDeploy)
c:\temp\b.txt (previously deployed by CodeDeploy)
c:\temp\c.bat (previously deployed by CodeDeploy)
c:\temp\d.bat (previously deployed by CodeDeploy)
c:\temp\e.txt (previously created by c.bat)
c:\temp\f.txt (previously created by d.bat)
```
El archivo de limpieza enumerará únicamente los dos primeros archivos de texto y dos archivos de script:
```
c:\temp\a.txt
c:\temp\b.txt
c:\temp\c.bat
c:\temp\d.bat
```
Antes de la nueva implementación, CodeDeploy eliminará solo los dos primeros archivos de texto y los dos archivos de script, dejando los dos últimos archivos de texto intactos:
```
c:\temp\a.txt will be removed
c:\temp\b.txt will be removed
c:\temp\c.bat will be removed
c:\temp\d.bat will be removed
c:\temp\e.txt will remain
c:\temp\f.txt will remain
```
Como parte de este proceso, no CodeDeploy intentará revertir ni conciliar de ningún otro modo las acciones realizadas por ningún script en implementaciones anteriores durante las redistribuciones posteriores, ya sean reversiones manuales o automáticas. Por ejemplo, si los `d.bat` archivos `c.bat` y contienen la lógica de no volver a crear los `f.txt` archivos `e.txt` y si ya existen, las versiones anteriores `f.txt` permanecerán intactas cada vez que se ejecuten `e.txt` y en las implementaciones posteriores. CodeDeploy `c.bat` `d.bat` Puede añadir lógica `c.bat` y `d.bat` para comprobar y eliminar siempre las versiones anteriores de `e.txt` y `f.txt` antes de crear otras nuevas.
## Comportamiento de la restauración con contenido existente
Como parte del proceso de implementación, el CodeDeploy agente elimina de cada instancia todos los archivos instalados en la implementación más reciente. Si los archivos que no formaban parte de una implementación anterior aparecen en las ubicaciones de implementación de destino, puede elegir CodeDeploy qué pasará con ellos durante la siguiente implementación:
+ **Dar como errónea la implementación**: se notifica un error y el estado de la implementación cambia a Error.
+ **Sobrescribir el contenido**: la versión del archivo de la revisión de la aplicación sustituye a la versión ya incluida en la instancia.
+ **Conservar el contenido**: el archivo de la ubicación de destino se conserva y la versión de la revisión de la aplicación no se copia en la instancia.
Puede elegir este comportamiento si crea una implementación. Si está creando una implementación en la consola, consulte [Creación de una implementación en una plataforma de informática de EC2/en las instalaciones (consola)](deployments-create-console.md). Si va a crear una implementación con AWS CLI, consulte[Creación de una implementación en una plataforma de informática EC2/en las instalaciones (CLI)](deployments-create-cli.md).
Puede optar por conservar los archivos que desea que formen parte de la próxima implementación sin tener que añadirlos al paquete de revisión de la aplicación. Por ejemplo, podría cargar directamente en la instancia los archivos que son necesarios para la implementación pero que no se añadieron al paquete de revisión de la aplicación. O bien, puede cargar archivos a la instancia si sus aplicaciones ya están en su entorno de producción, pero quiere utilizarlos CodeDeploy por primera vez para implementarlas.
En el caso de las restauraciones, en las que se vuelve a implementar la última revisión de la aplicación implementada correctamente debido a un error de implementación, se aplica la opción de gestión de contenido de la última implementación correcta a la implementación de restauración.
Sin embargo, si la implementación errónea se configuró para sobrescribir, en lugar de para conservar los archivos, podría producirse un resultado inesperado durante la restauración. En concreto, los archivos que esperaba conservar puede que los elimine la implementación errónea. Los archivos no están en la instancia cuando se ejecuta la implementación de restauración.
En el siguiente ejemplo, existen tres implementaciones. Cualquier archivo que se sobrescribe (elimina) durante la segunda implementación errónea ya no estará disponible (no se puede conservar) cuando se implemente de nuevo la 1ª revisión de la aplicación durante la 3ª implementación:
****
| Implementación | Revisión de la aplicación | Opción de sobrescritura del contenido | Estado de la implementación | Comportamiento y resultado |
| --- | --- | --- | --- | --- |
| 1ª implementación | 1ª revisión de la aplicación | RETAIN | Realizado correctamente | CodeDeploy detecta archivos en las ubicaciones de destino que no se desplegaron en la implementación anterior. Estos archivos podrían colocarse allí deliberadamente para que formen parte de la implementación actual. Se conservan y registran como parte del paquete de implementación actual. |
| 2ª implementación | 2ª revisión de la aplicación | OVERWRITE | Con error | Durante el proceso de implementación, CodeDeploy elimina todos los archivos que forman parte de la implementación anterior exitosa. Esto incluye los archivos que se conservaron durante la 1ª implementación. Sin embargo, la implementación falla por motivos ajenos. |
| 3ª implementación | 1ª revisión de la aplicación | RETAIN | | Dado que está habilitada la restauración automática para la implementación o grupo de implementaciones, CodeDeploy implementa la última revisión de la aplicación correcta conocida: la 1ª revisión de la aplicación.Sin embargo, los archivos que quería conservar en la implementación 1 se eliminaron antes de que la implementación 2 fallara y no se pueden recuperar. AWS CodeDeploy Puede añadirlos usted mismo a la instancia si son necesarios para la 1ª revisión de la aplicación, o puede crear una nueva revisión de la aplicación. |
# Implementar una aplicación en una AWS cuenta diferente
Las organizaciones suelen tener varias AWS cuentas que utilizan para distintos fines (por ejemplo, una para las tareas de administración del sistema y otra para las tareas de desarrollo, pruebas y producción, o una asociada a los entornos de desarrollo y prueba y otra asociada al entorno de producción).
Aunque puede realizar trabajos relacionados en diferentes cuentas, los grupos de CodeDeploy despliegue y las instancias de Amazon EC2 en las que se despliegan están estrictamente vinculados a las cuentas en las que se crearon. Por ejemplo, no se puede añadir una instancia que lanzó en una cuenta a un grupo de implementaciones en otra.
Suponga que tiene dos AWS cuentas: la cuenta de desarrollo y la cuenta de producción. Trabaja principalmente en la cuenta de desarrollo, pero desea poder iniciar implementaciones en su cuenta de producción sin un conjunto completo de credenciales allí o sin tener que salir de la cuenta de desarrollo e iniciar sesión en la cuenta de producción.
Después de seguir los pasos de configuración entre cuentas, puede iniciar implementaciones que pertenecen a otra cuenta de la organización, sin necesitar un conjunto completo de credenciales para esa otra cuenta. Esto es posible, en parte, utilizando una capacidad proporcionada en el AWS Security Token Service (AWS STS) que le concede acceso temporal a esa cuenta.
## Paso 1: Crear un bucket de S3 en cualquiera de las cuentas
En la cuenta de desarrollo o en la cuenta de producción:
+ Si aún no lo ha hecho, cree un bucket de Amazon S3 en el cual se almacenarán las revisiones de la aplicación para la cuenta de producción. Para obtener información, consulte [Crear un bucket en Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingABucket.html). Incluso, puede utilizar el mismo bucket y revisiones de la aplicación para ambas cuentas, implementando los mismos archivos a su entorno de producción que ya probó y verificó en la cuenta de desarrollo.
## Paso 2: Conceder permisos de bucket de Amazon S3 al perfil de instancia de IAM de la cuenta de producción
Si el bucket de Amazon S3 que creó en el paso 1 está en la cuenta de producción, este paso no es necesario. El rol que asuma después ya tendrá acceso a este bucket porque también estará en la cuenta de producción.
Si creó el bucket de Amazon S3 en la cuenta de desarrollo, haga lo siguiente:
+ En la cuenta de producción, cree un perfil de instancia de IAM. Para obtener 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**
Anote el ARN de este perfil de instancia de IAM. Deberá añadirlo a la política de buckets cruzados que cree a continuación.
+ En la cuenta de desarrollo, conceda acceso al bucket de Amazon S3 que creó en la cuenta de desarrollo al perfil de instancia de IAM que acaba de crear en la cuenta de producción. Para obtener más información, consulte [Ejemplo 2: Propietario del bucket que concede permisos de bucket entre cuentas](https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-walkthroughs-managing-access-example2.html).
Tenga en cuenta lo siguiente cuando complete el proceso de conceder permisos de bucket entre cuentas:
+ En el ejemplo del tutorial, la Cuenta A representa la cuenta de desarrollo y la Cuenta B representa la cuenta de producción.
+ Cuando [realice las tareas de la cuenta A (cuenta de desarrollo)](https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-walkthroughs-managing-access-example2.html#access-policies-walkthrough-cross-account-permissions-acctA-tasks), modifique la siguiente política de bucket para conceder permisos entre cuentas en lugar de utilizar la política de ejemplo del tutorial.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "Cross-account permissions",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/role-name"
},
"Action": [
"s3:Get*",
"s3:List*"
],
"Resource": [
"arn:aws:s3:::bucket-name/*"
]
}
]
}
```
------
*account-id*representa el número de cuenta de la cuenta de producción en la que acaba de crear el perfil de instancia de IAM.
*role-name*representa el nombre del perfil de instancia de IAM que acaba de crear.
*bucket-name*representa el nombre del depósito que creó en el paso 1. Asegúrese de incluir `/*` después del nombre de su bucket para conceder acceso a cada uno de los archivos dentro del bucket.
## Paso 3: Crear recursos y un rol entre cuentas en la cuenta de producción
En su cuenta de producción:
+ Cree sus CodeDeploy recursos (aplicación, grupo de implementación, configuración de implementación, instancias de Amazon EC2, perfil de instancia de Amazon EC2, rol de servicio, etc.) siguiendo las instrucciones de esta guía.
+ Cree una función adicional, una función de IAM multicuenta, que un usuario de su cuenta de desarrollo pueda asumir para realizar CodeDeploy operaciones en esta cuenta de producción.
Usa el [tutorial: Delega el acceso entre AWS cuentas utilizando las funciones de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/walkthru_cross-account-with-roles.html) como guía para ayudarte a crear la función multicuenta. En lugar de añadir a tu documento de política los permisos de ejemplo que aparecen en el tutorial, deberías adjuntar al rol, como mínimo, las dos políticas AWS siguientes:
+ `AmazonS3FullAccess`: necesaria solamente si el bucket de S3 está en la cuenta de desarrollo. Proporciona el rol asumido de la cuenta de producción con acceso total a los servicios y recursos de Amazon S3 en la cuenta de desarrollo donde se almacena la revisión.
+ `AWSCodeDeployDeployerAccess`: permite a un usuario registrar e implementar revisiones.
Si desea crear y administrar grupos de implementación y no solamente iniciar implementaciones, añada la política `AWSCodeDeployFullAccess` en lugar de la política `AWSCodeDeployDeployerAccess`. Para obtener más información sobre el uso de las políticas gestionadas de IAM para conceder permisos para CodeDeploy las tareas, consulte. [AWS políticas administradas (predefinidas) para CodeDeploy](managed-policies.md)
Puede adjuntar políticas adicionales si desea ejecutar tareas en otros servicios de AWS mientras utiliza este rol entre cuentas.
**importante**
Cuando cree el rol de IAM entre cuentas, anote los detalles que necesitará para acceder a la cuenta de producción.
Para utilizarlas Consola de administración de AWS para cambiar de rol, tendrás que proporcionar uno de los siguientes datos:
Una URL para acceder a la cuenta de producción con las credenciales del rol asumido. Encontrará la URL en la página **Review**, que aparece al final del proceso de creación de rol entre cuentas.
El nombre del rol entre cuentas y el número del ID de la cuenta o el alias.
Para usar el AWS CLI para cambiar de rol, tendrás que proporcionar lo siguiente:
El ARN del rol entre cuentas que asumirá.
## Paso 4: Cargar la revisión de la aplicación al bucket de Amazon S3
En la cuenta en la que creó el bucket de Amazon S3:
+ Cargue la revisión de la aplicación al bucket de Amazon S3. Para obtener información, consulte [Enviar una revisión CodeDeploy a Amazon S3 (solo para implementaciones de EC2/on-premise)](application-revisions-push.md).
## Paso 5: Asumir el rol entre cuentas e implementar las aplicaciones
En la cuenta de desarrollo, puede utilizar la AWS CLI o la Consola de administración de AWS para asumir la función multicuenta e iniciar el despliegue en la cuenta de producción.
Para obtener instrucciones sobre cómo usarlo Consola de administración de AWS para cambiar de rol e iniciar despliegues, consulte [Cambiar a un rol (Consola de administración de AWS)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-console.html) y. [Creación de una implementación en una plataforma de informática de EC2/en las instalaciones (consola)](deployments-create-console.md)
Para obtener instrucciones sobre cómo utilizarla AWS CLI para asumir la función multicuenta e iniciar las implementaciones, consulte [Cambiar a una función de IAM (](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-cli.html)) y.AWS Command Line Interface[Creación de una implementación en una plataforma de informática EC2/en las instalaciones (CLI)](deployments-create-cli.md)
[Para obtener más información sobre cómo asumir un rol AWS STS, consulte la [Guía del AWS Security Token Service usuario](https://docs.aws.amazon.com/STS/latest/APIReference/Welcome.html) y [asume-role [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role.html)en la Referencia de comandos.AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/)
**Tema relacionado:**
+ [CodeDeploy: Implementación desde una cuenta de desarrollo a una cuenta de producción](https://aws.amazon.com/blogs/devops/aws-codedeploy-deploying-from-a-development-account-to-a-production-account/)
# Utilice el CodeDeploy agente para validar un paquete de despliegue en una máquina local
Con el CodeDeploy agente, puede implementar contenido en una instancia en la que haya iniciado sesión. Esto le permite probar la integridad del archivo de especificaciones de la aplicación (AppSpec archivo) que pretende utilizar en una implementación y el contenido que pretende implementar.
No necesita crear una aplicación ni un grupo de implementaciones. Si desea implementar contenido almacenado en la instancia local, ni siquiera necesita una AWS cuenta. Para realizar las pruebas más sencillas, puede ejecutar el **codedeploy-local** comando, sin especificar ninguna opción, en un directorio que contenga el AppSpec archivo y el contenido que se va a implementar. Existen opciones para otros escenarios de prueba en la herramienta.
Mediante la validación de un paquete de implementación en una máquina local, puede:
+ Probar la integridad de una revisión de la aplicación
+ Pruebe el contenido de un AppSpec archivo.
+ Pruébelo CodeDeploy por primera vez con el código de su aplicación actual.
+ Implementar contenido rápidamente cuando ya ha iniciado sesión en una instancia.
Puede utilizar el contenido de despliegue almacenado en la instancia local o en un tipo de repositorio remoto compatible (depósitos de Amazon S3 o GitHub repositorios públicos).
## Requisitos previos
Antes de iniciar una implementación local, siga los pasos que se indican a continuación:
+ Cree o utilice un tipo de instancia compatible con el CodeDeploy agente. Para obtener información, consulte [Sistemas operativos compatibles con el agente CodeDeploy](codedeploy-agent.md#codedeploy-agent-supported-operating-systems).
+ Instale la versión 1.0.1.1352 o posterior del agente. CodeDeploy Para obtener información, consulte [Instale el agente CodeDeploy](codedeploy-agent-operations-install.md).
+ Si va a implementar su contenido desde un GitHub depósito o repositorio de Amazon S3, aprovisione un usuario para usarlo con él CodeDeploy. Para obtener información, consulte [Paso 1: Configurar](getting-started-setting-up.md).
+ Si va a implementar la revisión de la aplicación desde un bucket de Amazon S3, cree un bucket de Amazon S3 en la región en la que está trabajando y aplique una política de bucket de Amazon S3 al bucket. Esta política concede a las instancias los permisos necesarios para descargar la revisión de la aplicación.
Por ejemplo, la siguiente política de bucket de Amazon S3 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 lugar 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"
]
}
}
]
}
```
La siguiente política de bucket de Amazon S3 permite a cualquier instancia en las instalaciones con un usuario de IAM asociado que contenga el ARN `arn:aws:iam::444455556666:user/CodeDeployUser` descargar desde cualquier lugar al bucket de Amazon S3 denominado `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:user/CodeDeployUser"
]
}
}
]
}
```
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).
+ Si va a implementar la revisión de la aplicación desde un GitHub depósito o repositorio de Amazon S3, configure un perfil de instancia de IAM y adjúntelo a la instancia. Para obtener 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), [Cree una instancia de Amazon EC2 para CodeDeploy (AWS CLI o una consola Amazon EC2)](instances-ec2-create.md) y [Crear una instancia de Amazon EC2 para CodeDeploy (plantilla)CloudFormation](instances-ec2-create-cloudformation-template.md).
+ Si va a implementar su contenido desde GitHub, cree una GitHub cuenta y un repositorio público. Para crear una GitHub cuenta, consulta [Unirse GitHub](https://github.com/join). Para crear un GitHub repositorio, consulta [Crear un repositorio](https://help.github.com/articles/create-a-repo/).
**nota**
Actualmente no se admiten repositorios privados. Si tu contenido está almacenado en un GitHub repositorio privado, puedes descargarlo en la instancia y usar la `--bundle-location` opción para especificar su ruta local.
+ Prepare el contenido (incluido un AppSpec archivo) que desee implementar en la instancia y colóquelo en la instancia local, en su bucket de Amazon S3 o en su GitHub repositorio. Para obtener información, consulte [Trabajar con revisiones de aplicaciones para CodeDeploy](application-revisions.md).
+ Si desea utilizar valores distintos de los predeterminados para otras opciones de configuración, cree el archivo de configuración y colóquelo en la instancia (`/etc/codedeploy-agent/conf/codedeployagent.yml` para instancias de Amazon Linux, RHEL o Ubuntu Server o `C:\ProgramData\Amazon\CodeDeploy\conf.yml` para instancias de Windows Server). Para obtener información, consulte [Referencia de configuración del agente de CodeDeploy](reference-agent-configuration.md).
**nota**
Si utiliza un archivo de configuración en instancias de Amazon Linux, RHEL o Ubuntu Server, debe:
Usar las variables `:root_dir:` y `:log_dir:` para especificar ubicaciones distintas de las predeterminadas para la carpeta raíz de la implementación y las carpetas del directorio de archivos log
Se usa `sudo` para ejecutar comandos de CodeDeploy agente.
## Creación de una implementación local
En la instancia en la que desea crear la implementación local, abra una sesión del terminal (para instancias de Amazon Linux, RHEL o Ubuntu Server) o un símbolo del sistema (para Windows Server) para ejecutar los comandos de la herramienta.
**nota**
El comando **codedeploy-local** se instala en las siguientes ubicaciones:
Para Amazon Linux, RHEL y Ubuntu Server: `/opt/codedeploy-agent/bin`.
Para Windows Server: `C:\ProgramData\Amazon\CodeDeploy\bin`.
** Sintaxis básica de los comandos **
```
codedeploy-local [options]
```
**Sinopsis**
```
codedeploy-local
[--bundle-location ]
[--type ]
[--file-exists-behavior ]
[--deployment-group ]
[--events ]
[--agent-configuration-file ]
[--appspec-filename ]
```
**Opciones**
**-l**, **--bundle-location**
La ubicación del paquete de revisión de la aplicación. Si no especifica una ubicación, la herramienta utiliza el directorio en el que está trabajando actualmente de forma predeterminada. Si especifica un valor en `--bundle-location`, también debe especificar uno en `--type`.
Ejemplos de formato de ubicación del paquete:
+ Instancia local de Amazon Linux, RHEL o Ubuntu Server: `/path/to/local/bundle.tgz`
+ Instancia local de Windows Server: `C:/path/to/local/bundle`
+ Bucket de Amazon S3: `s3://amzn-s3-demo-bucket/bundle.tar`
+ GitHub repositorio: `https://github.com/account-name/repository-name/`
**-t**, **--type**
El formato del paquete de revisión de la aplicación. Los tipos admitidos son `tgz`, `tar`, `zip` y `directory`. Si no especifica un tipo, la herramienta usa `directory` de manera predeterminada. Si especifica un valor en `--type`, también debe especificar uno en `--bundle-location`.
**-b**, **-- file-exists-behavior**
Indica cómo se tratan los archivos que ya existen en la ubicación de destino de una implementación pero que no forman parte de una implementación anterior realizada correctamente. Las opciones son DISALLOW, OVERWRITE, RETAIN. Para obtener más información, consulte la *[Referencia [fileExistsBehavior](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_CreateDeployment.html#CodeDeploy-CreateDeployment-request-fileExistsBehavior)de la AWS CodeDeploy API](https://docs.aws.amazon.com/codedeploy/latest/APIReference/)*.
**-g**, **--deployment-group**
La ruta a la carpeta que es la ubicación de destino del contenido que se va a implementar. Si no especificas una carpeta, la herramienta crea una con un nombre en *default-local-deployment-group*el directorio raíz de la implementación. Para cada implementación local que cree, la herramienta crea un subdirectorio dentro de esta carpeta con nombres como *d-98761234-local*.
**-e**, **--events**
Un conjunto de enlaces de eventos de anulación del ciclo de vida que desee ejecutar, en orden, en lugar de los eventos que enumeró en el AppSpec archivo. Se pueden especificar varios enlaces, separados por comas. Puede utilizar esta opción si:
+ Quieres ejecutar un conjunto diferente de eventos sin tener que actualizar el AppSpec archivo.
+ Desea ejecutar un único enlace de eventos como una excepción a lo que hay en el AppSpec archivo, por ejemplo`ApplicationStop`.
Si no especificas **DownloadBundle**ni **instalas** los eventos en la lista de anulaciones, se ejecutarán antes que todos los enlaces de eventos que especifiques. Si incluyes **DownloadBundle**e **Install** en la lista de `--events` opciones, solo deben ir precedidas de eventos que normalmente se ejecutan antes que ellos en las CodeDeploy implementaciones. Para obtener información, consulte [AppSpec sección de «ganchos»](reference-appspec-file-structure-hooks.md).
**-c****, -- agent-configuration-file**
La ubicación de un archivo de configuración que se utiliza para la implementación, si está almacenado en una ubicación distinta de la predeterminada. Un archivo de configuración especifica alternativas a otros valores y comportamientos predeterminados de una implementación.
De forma predeterminada, los archivos de configuración se almacenan en `/etc/codedeploy-agent/conf/codedeployagent.yml` (instancias de Amazon Linux, RHEL o Ubuntu Server) o en `C:/ProgramData/Amazon/CodeDeploy/conf.yml` (Windows Server). Para obtener más información, consulte [Referencia de configuración del agente de CodeDeploy](reference-agent-configuration.md).
**-A**, **--appspec-filename**
El nombre del AppSpec archivo. Para las implementaciones locales, los valores aceptados son `appspec.yml` y `appspec.yaml`. De forma predeterminada, se llama al AppSpec archivo`appspec.yml`.
**-h**, **--help**
Muestra un resumen del contenido de ayuda.
**-v**, **--version**
Muestra el número de versión de la herramienta.
## Ejemplos
A continuación se proporcionan ejemplos de formatos de comandos válidos.
```
codedeploy-local
```
```
codedeploy-local --bundle-location /path/to/local/bundle/directory
```
```
codedeploy-local --bundle-location C:/path/to/local/bundle.zip --type zip --deployment-group my-deployment-group
```
```
codedeploy-local --bundle-location /path/to/local/directory --type directory --deployment-group my-deployment-group
```
Implementar un paquete desde Amazon S3:
```
codedeploy-local --bundle-location s3://amzn-s3-demo-bucket/bundle.tgz --type tgz
```
```
codedeploy-local --bundle-location s3://amzn-s3-demo-bucket/bundle.zip?versionId=1234&etag=47e8 --type zip --deployment-group my-deployment-group
```
Implemente un paquete desde un GitHub repositorio público:
```
codedeploy-local --bundle-location https://github.com/awslabs/aws-codedeploy-sample-tomcat --type zip
```
```
codedeploy-local --bundle-location https://api.github.com/repos/awslabs/aws-codedeploy-sample-tomcat/zipball/master --type zip
```
```
codedeploy-local --bundle-location https://api.github.com/repos/awslabs/aws-codedeploy-sample-tomcat/zipball/HEAD --type zip
```
```
codedeploy-local --bundle-location https://api.github.com/repos/awslabs/aws-codedeploy-sample-tomcat/zipball/1a2b3c4d --type zip
```
Implementar un paquete especificando varios eventos del ciclo de vida:
```
codedeploy-local --bundle-location /path/to/local/bundle.tar --type tar --application-folder my-deployment --events DownloadBundle,Install,ApplicationStart,HealthCheck
```
Detenga una aplicación implementada anteriormente mediante el evento de ApplicationStop ciclo de vida:
```
codedeploy-local --bundle-location /path/to/local/bundle.tgz --type tgz --deployment-group --events ApplicationStop
```
Implementar con un ID de grupo de implementaciones específico:
```
codedeploy-local --bundle-location C:/path/to/local/bundle/directory --deployment-group 1234abcd-5dd1-4774-89c6-30b107ac5dca
```
```
codedeploy-local --bundle-location C:/path/to/local/bundle.zip --type zip --deployment-group 1234abcd-5dd1-4774-89c6-30b107ac5dca
```