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 instancias para CodeDeploy
CodeDeploy admite implementaciones en instancias que ejecutan Amazon Linux, Ubuntu Server, Red Hat Enterprise Linux (RHEL) y Windows Server.
Se puede utilizar CodeDeploy para realizar la implementación tanto en instancias de Amazon EC2 como en instancias locales. Una instancia local es cualquier dispositivo físico que no sea una instancia de Amazon EC2 que pueda ejecutar CodeDeploy el agente y conectarse a puntos finales de servicio AWS público. Puede utilizarla CodeDeploy para implementar simultáneamente una aplicación en las instancias de Amazon EC2 en la nube y en el escritorio de su oficina o PCs en los servidores de su propio centro de datos.
## Comparación de las instancias de Amazon EC2 y las instancias en las instalaciones
En la siguiente tabla se comparan las instancias de Amazon EC2 y las instancias en las instalaciones:
| **Asunto** | **Instancias de Amazon EC2** | **Instancias en las instalaciones** |
| --- | --- | --- |
| Requiere que instale y ejecute una versión del CodeDeploy agente que sea compatible con el sistema operativo que se ejecuta en la instancia. | Sí | Sí |
| La instancia debe poder conectarse al servicio de CodeDeploy. | Sí | Sí |
| Es necesario adjuntar un perfil de instancia de IAM a la instancia. El perfil de la instancia de IAM debe tener permisos para participar en CodeDeploy las implementaciones. 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). | Sí | No |
| Es necesario realizar uno de los siguientes procedimientos para autenticar y registrar las instancias: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/instances.html) | No | Sí |
| Requiere que registre cada instancia CodeDeploy antes de poder realizar la implementación en ella. | No | Sí |
| Requiere que etiquete cada instancia antes de CodeDeploy poder implementarla en ella. | Sí | Sí |
| Puede participar en los escenarios de Amazon EC2 Auto Scaling y Elastic Load Balancing como parte CodeDeploy de las implementaciones. | Sí | No |
| Se puede implementar desde depósitos y GitHub repositorios de Amazon S3. | Sí | Sí |
| Admiten disparadores que solicitan el envío de notificaciones de correo electrónico o SMS cuando se producen eventos especificados en las implementaciones o instancias. | Sí | Sí |
| Se pueden facturar para implementaciones asociadas. | No | Sí |
## Tareas de instancia para CodeDeploy
Para lanzar o configurar instancias para su uso en implementaciones, elija entre las siguientes instrucciones:
| | |
| --- |--- |
| Quiero lanzar una nueva instancia de Amazon EC2 en Amazon Linux o Windows Server. | Para lanzar la instancia de Amazon EC2 con el mínimo esfuerzo, consulte [Crear una instancia de Amazon EC2 para CodeDeploy (plantilla)CloudFormation](instances-ec2-create-cloudformation-template.md). Para lanzar la instancia de Amazon EC2 por su cuenta, consulte [Cree una instancia de Amazon EC2 para CodeDeploy (AWS CLI o una consola Amazon EC2)](instances-ec2-create.md). |
| Quiero lanzar una nueva instancia de Amazon EC2 con Ubuntu Server o RHEL. | Consulte [Cree una instancia de Amazon EC2 para CodeDeploy (AWS CLI o una consola Amazon EC2)](instances-ec2-create.md). |
| Quiero configurar una instancia de Amazon EC2 en Amazon Linux, Windows Server, Ubuntu Server o RHEL. | Consulte [Configurar una instancia de Amazon EC2 con la que trabajar CodeDeploy](instances-ec2-configure.md). |
| Quiero configurar una instancia en las instalaciones (dispositivos físicos que no son instancias de Amazon EC2) en Windows Server, Ubuntu Server o RHEL. | Consulte [Trabajar con instancias locales para CodeDeploy](instances-on-premises.md). |
| Quiero CodeDeploy aprovisionar una flota de instancias de reemplazo durante una blue/green implementación. | Consulte [Trabajar con despliegues en CodeDeploy](deployments.md). |
Para preparar instancias de Amazon EC2 en grupos de Amazon EC2 Auto Scaling, debe seguir algunos pasos adicionales. Para obtener más información, consulte [Integración CodeDeploy con Amazon EC2 Auto Scaling](integrations-aws-auto-scaling.md).
**Temas**
+ [Tagging Instances for Deployments](instances-tagging.md)
+ [Working with Amazon EC2 Instances](instances-ec2.md)
+ [Working with On-Premises Instances](instances-on-premises.md)
+ [View Instance Details](instances-view-details.md)
+ [Instance Health](instances-health.md)
# Etiquetado de instancias para grupos de despliegue en CodeDeploy
Para ayudar a administrar las instancias de Amazon EC2 y las instancias en las instalaciones, puede usar etiquetas para asignar sus propios metadatos a cada recurso. Las etiquetas le permiten clasificar las instancias de diversas maneras, por ejemplo, según su finalidad, propietario o entorno. Esto es útil cuando dispone de muchas instancias. Puede identificar rápidamente una instancia o grupo de instancias en función de las etiquetas que haya asignado a ellos. Cada etiqueta está formada por una clave y un valor opcional, ambos definidos por el usuario. Para obtener más información, consulte [Etiquetado de los recursos de Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html).
Para especificar qué instancias se incluyen en un grupo de CodeDeploy implementación, especifique las etiquetas en uno o más *grupos de etiquetas*. Las instancias que cumplan sus criterios de etiqueta son las instancias en las que está instalada la última versión de la aplicación en el momento de creación de la implementación de ese grupo de implementaciones.
**nota**
También puede incluir grupos de Amazon EC2 Auto Scaling en grupos de implementación, pero estos se identifican por sus nombres y no por las etiquetas que se aplican a las instancias. Para obtener información, consulte [Integración CodeDeploy con Amazon EC2 Auto Scaling](integrations-aws-auto-scaling.md).
Los criterios de las instancias en un grupo de implementaciones pueden ser tan sencillos como una única etiqueta en un solo grupo de etiquetas. Puede ser tan complejo como 10 etiquetas cada una en un máximo de tres grupos de etiquetas.
Si utiliza un único grupo de etiquetas, cualquier instancia que se identifique mediante al menos una etiqueta del grupo se incluye en el grupo de implementaciones. Si utiliza varios grupos de etiquetas, solo se incluyen las instancias que se identifican por al menos una etiqueta en *cada* uno de los grupos de etiquetas.
En los siguientes ejemplos se muestra cómo las etiquetas y los grupos de etiquetas se pueden utilizar para seleccionar las instancias de un grupo de implementaciones.
**Topics**
+ [Ejemplo 1: un único grupo de etiquetas, una única etiqueta](#instances-tagging-example-1)
+ [Ejemplo 2: un único grupo de etiquetas, varias etiquetas](#instances-tagging-example-2)
+ [Ejemplo 3: varios grupos de etiquetas, etiquetas únicas](#instances-tagging-example-3)
+ [Ejemplo 4: varios grupos de etiquetas, varias etiquetas](#instances-tagging-example-4)
## Ejemplo 1: un único grupo de etiquetas, una única etiqueta
Puede especificar una única etiqueta en un único grupo de etiquetas:
**Grupo de etiquetas 1**
| Clave | Valor |
| --- | --- |
| Name | AppVersion-ABC |
Cada instancia que se etiqueta con `Name=AppVersion-ABC` forma parte del grupo de implementaciones, incluso si tiene otras etiquetas aplicadas.
CodeDeploy vista de configuración de la consola:
![\[La CodeDeploy consola muestra un grupo de etiquetas con una etiqueta.\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/images/TaggingExample1-polaris.png)
Estructura JSON:
```
"ec2TagSet": {
"ec2TagSetList": [
[
{
"Type": "KEY_AND_VALUE",
"Key": "Name",
"Value": "AppVersion-ABC"
}
]
]
},
```
## Ejemplo 2: un único grupo de etiquetas, varias etiquetas
También puede especificar varias etiquetas en un único grupo de etiquetas:
**Grupo de etiquetas 1**
| Clave | Valor |
| --- | --- |
| Region | Norte |
| Region | Sur |
| Region | Este |
Una instancia que se etiqueta con cualquiera de estas tres etiquetas forma parte del grupo de implementaciones, incluso si tiene otras etiquetas aplicadas. Si, por ejemplo, tenía otras instancias etiquetadas `Region=West`, estas no se incluirían en el grupo de implementaciones.
CodeDeploy vista de configuración de la consola:
![\[La CodeDeploy consola muestra un grupo de etiquetas con tres etiquetas.\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/images/TaggingExample2-polaris.png)
Estructura JSON:
```
"ec2TagSet": {
"ec2TagSetList": [
[
{
"Type": "KEY_AND_VALUE",
"Key": "Region",
"Value": "North"
},
{
"Type": "KEY_AND_VALUE",
"Key": "Region",
"Value": "South"
},
{
"Type": "KEY_AND_VALUE",
"Key": "Region",
"Value": "East"
}
]
]
},
```
## Ejemplo 3: varios grupos de etiquetas, etiquetas únicas
También puede utilizar varios conjuntos de grupos de etiquetas con un único par de clave-valor en cada uno para especificar los criterios de las instancias de un grupo de implementaciones. Cuando utiliza varios grupos de etiquetas en un grupo de implementaciones, solo las instancias identificadas por todos los grupos de etiquetas se incluyen en el grupo de implementaciones.
**Grupo de etiquetas 1**
| Clave | Valor |
| --- | --- |
| Name | AppVersion-ABC |
**Grupo de etiquetas 2**
| Clave | Valor |
| --- | --- |
| Region | Norte |
**Grupo de etiquetas 3**
| Clave | Valor |
| --- | --- |
| Tipo | t2.medium |
Puede tener instancias en varias regiones y distintos tipos de instancia etiquetados con `Name=AppVersion-ABC`. En este ejemplo, solo las instancias también etiquetadas con `Region=North` y `Type=t2.medium` forman parte del grupo de implementaciones.
CodeDeploy vista de configuración de la consola:
![\[La CodeDeploy consola muestra tres grupos de etiquetas con una etiqueta en cada uno.\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/images/TaggingExample3-polaris.png)
Estructura JSON:
```
"ec2TagSet": {
"ec2TagSetList": [
[
{
"Type": "KEY_AND_VALUE",
"Key": "Name",
"Value": "AppVersion-ABC"
}
],
[
{
"Type": "KEY_AND_VALUE",
"Key": "Region",
"Value": "North"
}
],
[
{
"Type": "KEY_AND_VALUE",
"Key": "Type",
"Value": "t2.medium"
}
],
]
},
```
## Ejemplo 4: varios grupos de etiquetas, varias etiquetas
Al utilizar varios grupos de etiquetas con varias etiquetas en uno o más grupos, una instancia debe coincidir con al menos una de las etiquetas de cada uno de los grupos.
**Grupo de etiquetas 1**
| Clave | Valor |
| --- | --- |
| Entorno | Beta |
| Entorno | Staging |
**Grupo de etiquetas 2**
| Clave | Valor |
| --- | --- |
| Region | Norte |
| Region | Sur |
| Region | Este |
**Grupo de etiquetas 3**
| Clave | Valor |
| --- | --- |
| Tipo | t2.medium |
| Tipo | t2.large |
En este ejemplo, para que se incluya en el grupo de implementaciones, una instancia debe ser etiquetada con (1) `Environment=Beta` o `Environment=Staging`, (2) `Region=North`, `Region=South`o `Region=East`, y (3) `Type=t2.medium` o `Type=t2.large`.
En modo de ilustración, las instancias con los siguientes grupos de etiquetas *estarían* entre las que se incluyen en el grupo de implementaciones:
+ `Environment=Beta`, `Region=North`,`Type=t2.medium`
+ `Environment=Staging`,`Region=East`,`Type=t2.large`
+ `Environment=Staging`,`Region=South`,`Type=t2.large`
Las instancias con los siguientes grupos de etiquetas *no* estarían entre las que se incluyen en el grupo de implementaciones. Los valores de clave **resaltados** hacen que las instancias que se excluyan:
+ `Environment=Beta`, Region=**West**,`Type=t2.medium`
+ `Environment=Staging`,`Region=East`,Type=**t2.micro**
+ Environment=**Production**,`Region=South`,`Type=t2.large`
CodeDeploy vista de configuración de la consola:
![\[La CodeDeploy consola muestra tres grupos de etiquetas con varias etiquetas en cada uno.\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/images/TaggingExample4-polaris.png)
Estructura JSON:
```
"ec2TagSet": {
"ec2TagSetList": [
[
{
"Type": "KEY_AND_VALUE",
"Key": "Environment",
"Value": "Beta"
},
{
"Type": "KEY_AND_VALUE",
"Key": "Environment",
"Value": "Staging"
}
],
[
{
"Type": "KEY_AND_VALUE",
"Key": "Region",
"Value": "North"
},
{
"Type": "KEY_AND_VALUE",
"Key": "Region",
"Value": "South"
},
{
"Type": "KEY_AND_VALUE",
"Key": "Region",
"Value": "East"
}
],
[
{
"Type": "KEY_AND_VALUE",
"Key": "Type",
"Value": "t2.medium"
},
{
"Type": "KEY_AND_VALUE",
"Key": "Type",
"Value": "t2.large"
}
],
]
},
```
# Trabajar con instancias de Amazon EC2 para CodeDeploy
Una instancia de Amazon EC2 es un entorno informático virtual que se crea y configura mediante Amazon Elastic Compute Cloud. Amazon EC2 proporciona una capacidad informática escalable en la AWS nube. Puede usar Amazon EC2 para lanzar tantos o tan pocos servidores virtuales como necesite para sus CodeDeploy implementaciones.
Para obtener más información acerca de Amazon EC2, consulte la [https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/).
Las instrucciones de esta sección muestran cómo crear y configurar instancias de Amazon EC2 para usarlas en sus CodeDeploy implementaciones.
**Topics**
+ [Cree una instancia de Amazon EC2 para CodeDeploy](instances-ec2-create.md)
+ [Crear una instancia de Amazon EC2 (plantilla)CloudFormation](instances-ec2-create-cloudformation-template.md)
+ [Configuración de una instancia de Amazon EC2](instances-ec2-configure.md)
# Cree una instancia de Amazon EC2 para CodeDeploy (AWS CLI o una consola Amazon EC2)
Estas instrucciones le muestran cómo lanzar una nueva instancia de Amazon EC2 configurada para su uso en CodeDeploy implementaciones.
Puede utilizar nuestra CloudFormation plantilla para lanzar una instancia de Amazon EC2 que ejecute Amazon Linux o Windows Server y que ya esté configurada para su uso en CodeDeploy las implementaciones. No proporcionamos una CloudFormation plantilla para las instancias de Amazon EC2 que ejecutan Ubuntu Server o Red Hat Enterprise Linux (RHEL). Si desea conocer otras alternativas al uso de la plantilla, consulte [Trabajar con instancias para CodeDeploy](instances.md).
Puede utilizar la consola Amazon EC2 o las API de Amazon EC2 para lanzar una instancia de Amazon EC2. AWS CLI
## Lanzamiento de una instancia de Amazon EC2 (consola)
### Requisitos previos
Si aún no lo ha hecho, siga las instrucciones [Empezar con CodeDeploy](getting-started-codedeploy.md) para configurar AWS CLI y crear un perfil de instancia de IAM.
### Lanzamiento de una instancia de Amazon EC2
1. Inicie sesión en la consola Amazon EC2 Consola de administración de AWS y ábrala en. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. En el panel de navegación, elija **Instances (Instancias)** y seleccione **Launch Instance (Lanzar instancia)**.
1. En la página **Step 1: Choose an Amazon Machine Image (AMI) (Paso 1: Elegir una imagen de máquina de Amazon [AMI])** de la pestaña **Quick Start (Inicio rápido)**, busque el sistema operativo y la versión que quiera usar y luego elija **Select (Seleccionar)**. Debe elegir un sistema operativo AMI Amazon EC2 compatible con. CodeDeploy Para obtener más información, consulte [Sistemas operativos compatibles con el agente CodeDeploy](codedeploy-agent.md#codedeploy-agent-supported-operating-systems).
1. En la página **Paso 2: Elegir un tipo de instancia**, elija cualquier tipo de instancia de Amazon EC2 disponible y seleccione **Siguiente: Configurar los detalles de la instancia**.
1. En la página **Paso 3: Configurar los detalles de la instancia**, en la lista **IAM role** (Rol de IAM), elija el rol de instancia que ha creado en [Paso 4: Crear un perfil de instancia de IAM para las instancias de Amazon EC2](getting-started-create-iam-instance-profile.md). Si ha utilizado el nombre de rol sugerido, elija **CodeDeployDemo-EC2-Instance-Profile**. Si ha creado su propio nombre de rol, selecciónelo.
**nota**
Si una nube privada virtual (VPC) predeterminada no aparece en la lista **Red**, debe elegir o crear una VPC y una subred de Amazon. Elija **Crear nueva VPC** o **Crear nueva subred** o ambas opciones. Para obtener más información, consulte [VPC y subredes](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html).
1. Elija **Siguiente: Agregar almacenamiento**.
1. Deje la página **Paso 4: Agregar almacenamiento** sin cambiar y elija **Siguiente: Añadir etiquetas**.
1. En la página **Paso 5: Añadir etiquetas**, elija **Añadir etiqueta**.
1. En el cuadro **Clave**, escriba **Name**. En el cuadro **Valor**, escriba **CodeDeployDemo**.
**importante**
El contenido de los cuadros **Clave** y **Valor** distingue entre mayúsculas y minúsculas.
1. Elija **Siguiente: Configurar un grupo de seguridad**.
1. En la página **Paso 6: Configurar un grupo de seguridad**, deje la opción **Crear un grupo de seguridad nuevo** seleccionada.
Se configura un rol de SSH predeterminado para instancias de Amazon EC2 que ejecutan Amazon Linux, Ubuntu Server o RHEL. Se configura un rol de RDP predeterminado para instancias de Amazon EC2 que ejecutan Windows Server.
1. Si desea abrir el puerto HTTP, elija el botón **Add Rule (Añadir regla)** y en la lista desplegable **Type (Tipo)**, elija **HTTP**. Acepte el valor **Source (Origen)** predeterminado de **Custom 0.0.0.0/0 (Personalizado 0.0.0.0/0)** y luego elija **Review and Launch (Revisar y lanzar)**.
**nota**
**En un entorno de producción, recomendamos restringir el acceso a los puertos SSH, RDP y HTTP, en lugar de especificar Anywhere 0.0.0.0/0.** CodeDeploy no requiere acceso a los puertos sin restricciones ni acceso HTTP. Para obtener más información, consulte [Sugerencias para proteger la instancia de Amazon EC2](https://aws.amazon.com/articles/1233).
Si aparece el cuadro de diálogo **Boot from General Purpose (SSD) (Arrancar desde uso general [SSD])**, siga las instrucciones y luego seleccione **Next (Siguiente)**.
1. Deje la página **Step 7: Review Instance Launch (Paso 7: Revisar el lanzamiento de la instancia)** sin cambiar y elija **Launch (Lanzar)**.
1. En el cuadro de diálogo **Select an existing key pair or create a new key pair (Seleccionar par de claves existentes o crear nuevo par de claves)**, elija **Choose an existing key pair (Elegir un par de claves existente)** o **Create a new key pair (Crear un nuevo par de claves)**. Si ya ha configurado un par de claves de la instancia de Amazon EC2, puede elegirlo aquí.
Si aún no tiene un par de claves de instancia de Amazon EC2, elija **Create a new key pair (Crear un nuevo par de claves)** y asígnele un nombre fácil de reconocer. Elija **Descargar par de claves** para descargar el par de claves de la instancia de Amazon EC2 en su equipo.
**importante**
Debe disponer de un par de claves si desea obtener acceso a su instancia de Amazon EC2 con SSH o RDP.
1. Elija **Iniciar instancias**.
1. Elija el ID de su instancia de Amazon EC2. No continúe hasta que la instancia se haya lanzado y haya superado todas las comprobaciones.
### Instale el agente CodeDeploy
El CodeDeploy agente debe estar instalado en la instancia de Amazon EC2 antes de usarlo en CodeDeploy las implementaciones. Para obtener más información, consulte [Instale el agente CodeDeploy](codedeploy-agent-operations-install.md).
**nota**
Puede configurar la instalación y las actualizaciones automáticas del CodeDeploy agente al crear el grupo de implementación en la consola.
## Lanzamiento de una instancia de Amazon EC2 (CLI)
### Requisitos previos
Si aún no lo ha hecho, siga las instrucciones [Empezar con CodeDeploy](getting-started-codedeploy.md) para configurar AWS CLI y crear un perfil de instancia de IAM.
### Lanzamiento de una instancia de Amazon EC2
1. **Solo para Windows Server** Si va a crear una instancia de Amazon EC2 que ejecuta Windows Server, llame a los comandos **create-security-group** y **authorize-security-group-ingress** para crear un grupo de seguridad que permita el acceso RDP (que no se permite de forma predeterminada) y, en su caso, el acceso HTTP. Por ejemplo, para crear un grupo de seguridad denominado *CodeDeployDemo-Windows-Security-Group*, ejecute los siguientes comandos, de uno en uno:
```
aws ec2 create-security-group --group-name CodeDeployDemo-Windows-Security-Group --description "For launching Windows Server images for use with CodeDeploy"
```
```
aws ec2 authorize-security-group-ingress --group-name CodeDeployDemo-Windows-Security-Group --to-port 3389 --ip-protocol tcp --cidr-ip 0.0.0.0/0 --from-port 3389
```
```
aws ec2 authorize-security-group-ingress --group-name CodeDeployDemo-Windows-Security-Group --to-port 80 --ip-protocol tcp --cidr-ip 0.0.0.0/0 --from-port 80
```
**nota**
Para fines de demostración, estos comandos crean un grupo de seguridad que permite acceso ilimitado a RDP a través del puerto 3389 y, en su caso, a HTTP a través del puerto 80. Es recomendable que restrinja el acceso a los puertos HTTP y RDP. CodeDeploy no requiere acceso ilimitado a los puertos y no requiere acceso HTTP. Para obtener más información, consulte [Sugerencias para proteger la instancia de Amazon EC2](https://aws.amazon.com/articles/1233).
1. Llame al comando **run-instances** para crear y lanzar la instancia de Amazon EC2.
Antes de llamar a este comando, debe recopilar lo siguiente:
+ El ID de una imagen de máquina de Amazon (AMI) (*ami-id*) que utilizas para la instancia. Para obtener el ID, consulte [Búsqueda de una AMI de Linux](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/finding-an-ami.html).
+ El nombre del tipo de instancia de Amazon EC2 (*instance-type*) que cree, por ejemplo. `t1.micro` Para ver una lista, consulte [Tipos de instancias de Amazon EC2](https://aws.amazon.com/ec2/instance-types/).
+ El nombre de un perfil de instancia de IAM con permiso para acceder al bucket de Amazon S3 donde se almacenan los archivos de instalación del CodeDeploy agente de su región.
Para obtener información sobre la creación de un perfil de instancia de IAM, consulte [Paso 4: Crear un perfil de instancia de IAM para las instancias de Amazon EC2](getting-started-create-iam-instance-profile.md).
+ El nombre de un par de claves de instancia de Amazon EC2 (*key-name*) para permitir el acceso SSH a una instancia de Amazon EC2 que ejecute Amazon Linux, Ubuntu Server o el acceso RHEL o RDP a una instancia de Amazon EC2 que ejecute Windows Server.
**importante**
Escriba solo el nombre del par de claves, no la extensión de archivo del par de claves. Por ejemplo, *my-keypair*, no *my-keypair.pem*.
[Para buscar el nombre de un par de claves, abra la consola Amazon EC2 en https://console.aws.amazon.com /ec2.](https://console.aws.amazon.com/ec2) En el panel de navegación, en **Network & Security (Red y seguridad)**, elija **Key Pairs (Pares de claves)** y anote el nombre del par de claves de la lista.
Para generar un par de claves, consulte [Crear un par de claves con Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html#having-ec2-create-your-key-pair). Compruebe que crea el par de claves en una de las regiones que se encuentran en la lista de [Regiones y puntos de enlace](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) de la *Referencia general de AWS*. De lo contrario, no podrá utilizar el par de claves de instancia de Amazon EC2 con. CodeDeploy
**Para Amazon Linux, RHEL y Ubuntu Server**
Para llamar al comando **run-instances** para lanzar una instancia de Amazon EC2 que ejecuta Amazon Linux, Ubuntu Server o RHEL y adjuntar el perfil de instancia de IAM que creó en [Paso 4: Crear un perfil de instancia de IAM para las instancias de Amazon EC2](getting-started-create-iam-instance-profile.md). Por ejemplo:
```
aws ec2 run-instances \
--image-id ami-id \
--key-name key-name \
--count 1 \
--instance-type instance-type \
--iam-instance-profile Name=iam-instance-profile
```
**nota**
Este comando crea un grupo de seguridad predeterminado para la instancia de Amazon EC2 que permite el acceso a varios puertos, incluido acceso ilimitado a SSH a través del puerto 22 y, en su caso, a HTTP a través del puerto 80. Como práctica recomendada, recomendamos restringir el acceso únicamente a los puertos SSH y HTTP. CodeDeploy no requiere acceso a los puertos sin restricciones ni acceso a los puertos HTTP. Para obtener más información, consulte [Sugerencias para proteger la instancia de Amazon EC2](https://aws.amazon.com/articles/1233).
**Para Windows Server**
Para llamar al comando **run-instances** y lanzar una instancia de Amazon EC2 ejecutando Windows Server, así como adjuntar el perfil de instancia de IAM que ha creado en [Paso 4: Crear un perfil de instancia de IAM para las instancias de Amazon EC2](getting-started-create-iam-instance-profile.md) y especificar el nombre del grupo de seguridad que ha creado en el paso 1. Por ejemplo:
```
aws ec2 run-instances --image-id ami-id --key-name key-name --count 1 --instance-type instance-type --iam-instance-profile Name=iam-instance-profile --security-groups CodeDeploy-Windows-Security-Group
```
Estos comandos lanzan una sola instancia de Amazon EC2 con la AMI, el par de claves y el tipo de instancia especificados, con el perfil de instancia de IAM indicado, y ejecutan el script especificado durante el lanzamiento.
1. Anote el valor de `InstanceID` en la salida. Si olvida este valor, puede obtenerlo más tarde si llama al comando **describe-instances** con el par de claves de la instancia de Amazon EC2.
```
aws ec2 describe-instances --filters "Name=key-name,Values=keyName" --query "Reservations[*].Instances[*].[InstanceId]" --output text
```
Use el ID de instancia para llamar al **create-tags** comando, que etiqueta la instancia de Amazon EC2 para que CodeDeploy pueda encontrarla más adelante durante una implementación. En el siguiente ejemplo, la etiqueta se denomina **CodeDeployDemo**, pero puede especificar cualquier etiqueta de instancia de Amazon EC2 que desee.
```
aws ec2 create-tags --resources instance-id --tags Key=Name,Value=CodeDeployDemo
```
Puede aplicar varias etiquetas a una instancia al mismo tiempo. Por ejemplo:
```
aws ec2 create-tags --resources instance-id --tags Key=Name,Value=testInstance Key=Region,Value=West Key=Environment,Value=Beta
```
Para verificar que la instancia de Amazon EC2 se ha lanzado y ha superado todas las comprobaciones, utilice el ID de instancia para llamar al comando **describe-instance-status**.
```
aws ec2 describe-instance-status --instance-ids instance-id --query "InstanceStatuses[*].InstanceStatus.[Status]" --output text
```
Si la instancia se ha lanzado y ha superado todas las comprobaciones, aparece `ok` en la salida:
### Instale el agente CodeDeploy
El CodeDeploy agente debe estar instalado en la instancia de Amazon EC2 antes de usarlo en CodeDeploy las implementaciones. Para obtener más información, consulte [Instale el agente CodeDeploy](codedeploy-agent-operations-install.md).
**nota**
Puede configurar la instalación y las actualizaciones automáticas del CodeDeploy agente al crear el grupo de implementación en la consola.
# Crear una instancia de Amazon EC2 para CodeDeploy (plantilla)CloudFormation
Puede utilizar nuestra CloudFormation plantilla para lanzar rápidamente una instancia de Amazon EC2 que ejecute Amazon Linux o Windows Server. Puede usar la AWS CLI CodeDeploy consola o la AWS APIs para lanzar la instancia con la plantilla. Además de lanzar la instancia, la plantilla hace lo siguiente:
+ Indica CloudFormation que dé permiso a la instancia para participar en CodeDeploy las implementaciones.
+ Etiqueta la instancia para CodeDeploy poder encontrarla durante una implementación.
+ Instala y ejecuta el CodeDeploy agente en la instancia.
No es necesario que utilice nuestro CloudFormation para configurar una instancia de Amazon EC2. Si desea conocer otras alternativas, consulte [Trabajar con instancias para CodeDeploy](instances.md).
No proporcionamos una CloudFormation plantilla para las instancias de Amazon EC2 que ejecutan Ubuntu Server o Red Hat Enterprise Linux (RHEL).
**Topics**
+ [Antes de empezar](#instances-ec2-create-cloudformation-template-before)
+ [Lance una instancia de Amazon EC2 con la CloudFormation plantilla (consola)](#instances-ec2-create-cloudformation-template-console)
+ [Lance una instancia de Amazon EC2 con la CloudFormation plantilla ()AWS CLI](#instances-ec2-create-cloudformation-template-cli)
## Antes de empezar
Antes de poder usar la CloudFormation plantilla para lanzar instancias de Amazon EC2, asegúrese de completar los siguientes pasos.
1. Asegúrese de haber creado un usuario administrativo, tal y como se describe en [Paso 1: Configurar](getting-started-setting-up.md). Compruebe que el usuario tiene los siguientes permisos mínimos y añada los que no estén presentes:
+ cloudformation:\$1
+ codedeploy:\$1
+ ec2:\$1
+ Soy: AddRoleToInstanceProfile
+ objetivo: CreateInstanceProfile
+ objetivo: CreateRole
+ objetivo: DeleteInstanceProfile
+ objetivo: DeleteRole
+ objetivo: DeleteRolePolicy
+ objetivo: GetRole
+ objetivo: DeleteRolePolicy
+ objetivo: PutRolePolicy
+ objetivo: RemoveRoleFromInstanceProfile
1. Asegúrese de tener un par de claves de instancia para permitir el acceso SSH a la instancia de Amazon EC2 que ejecuta Amazon Linux o el acceso RDP a la instancia que ejecuta Windows Server.
[Para buscar el nombre de un par de claves, abra la consola Amazon EC2 en https://console.aws.amazon.com /ec2.](https://console.aws.amazon.com/ec2) En el panel de navegación, en **Network & Security (Red y seguridad)**, elija **Key Pairs (Pares de claves)** y anote el nombre del par de claves de la lista.
Para generar un nuevo par de claves, consulte [Crear un par de claves con Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html#having-ec2-create-your-key-pair). Asegúrese de que crea el par de claves en una de las regiones que se encuentran en la lista de [Regiones y puntos de conexión](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) de la *Referencia general de AWS*. De lo contrario, no puede utilizar el par de claves de la instancia con CodeDeploy.
## Lance una instancia de Amazon EC2 con la CloudFormation plantilla (consola)
1. Inicie sesión Consola de administración de AWS y abra la CloudFormation consola en [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
**importante**
Inicia sesión en la Consola de administración de AWS con la misma cuenta que utilizaste. [Empezar con CodeDeploy](getting-started-codedeploy.md) En la barra de navegación, en el selector de regiones, elige una de las regiones que aparecen en [Región y los puntos finales](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) en *Referencia general de AWS*. CodeDeploy solo admite estas regiones.
1. Elija **Crear pila**.
1. En **Elegir una plantilla**, seleccione **Especificar una URL de plantilla de Amazon S3**. En el cuadro, escriba la ubicación de la CloudFormation plantilla para su región y, a continuación, seleccione **Siguiente**.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/instances-ec2-create-cloudformation-template.html)
1. En el cuadro **Stack name (Nombre de la pila)**, escriba un nombre para la pila (por ejemplo, **CodeDeployDemoStack**).
1. En **Parameters (Parámetros)**, escriba lo siguiente y seleccione **Next (Siguiente)**.
+ Para **InstanceCount**, escriba el número de instancias que desea lanzar. (Le recomendamos que deje el valor predeterminado, **1**).
+ Para **InstanceType**, escriba el tipo de instancia que desee lanzar (o deje **t1.micro** como valor predeterminado).
+ Para **KeyPairName**, escriba el nombre del key pair de la instancia. Escriba solo el nombre del par de claves, no la extensión de archivo del par de claves.
+ En **OperatingSystem**Box, escriba **Windows** para lanzar instancias que ejecuten Windows Server (o deje **Linux** como predeterminado).
+ Para **SSHLocation**, escriba el intervalo de direcciones IP que se utilizará para conectarse a la instancia mediante SSH o RDP (o deje el valor predeterminado **0.0.0.0/0**).
**importante**
El valor predeterminado de se proporciona únicamente con fines de **0.0.0.0/0** demostración. CodeDeploy no requiere que las instancias de Amazon EC2 tengan acceso ilimitado a los puertos. Es recomendable que restrinja el acceso a los puertos SSH (y HTTP). Para obtener más información, consulte [Sugerencias para proteger la instancia de Amazon EC2](https://aws.amazon.com/articles/1233).
+ Para **TagKey**ello, escriba la etiqueta de instancia que la clave CodeDeploy utilizará para identificar las instancias durante la implementación (o deje el **nombre** predeterminado).
+ Para **TagValue**, escriba el valor de la etiqueta de instancia que CodeDeploy se utilizará para identificar las instancias durante la implementación (o deje el valor predeterminado **CodeDeployDemo**).
1. En la página **Options (Opciones)**, deje las casillas de opción vacías y elija **Next (Siguiente)**.
**importante**
CloudFormation las etiquetas son diferentes de las CodeDeploy etiquetas. CloudFormation usa etiquetas para simplificar la administración de su infraestructura. CodeDeploy utiliza etiquetas para identificar las instancias de Amazon EC2. Ha especificado etiquetas de CodeDeploy en la página **Specify Parameters (Especificar parámetros)**.
1. **En la página de **revisión**, en **Capacidades**, seleccione la casilla **Acepto que CloudFormation podría crear recursos de IAM** y, a continuación, elija Crear.**
**Una vez CloudFormation creada la pila y lanzado las instancias de Amazon EC2, en la CloudFormation consola, se mostrará **CREATE\$1COMPLETE** en la columna Estado.** Este proceso puede tardar varios minutos.
Para comprobar que el CodeDeploy agente se está ejecutando en las instancias de Amazon EC2, consulte y, a continuación[Gestión de las operaciones CodeDeploy de los agentes](codedeploy-agent-operations.md), continúe con. [Cree una aplicación con CodeDeploy](applications-create.md)
## Lance una instancia de Amazon EC2 con la CloudFormation plantilla ()AWS CLI
1. Utilice nuestra CloudFormation plantilla en una llamada al **create-stack** comando. Esta pila lanzará una nueva instancia de Amazon EC2 con el CodeDeploy agente instalado.
Para lanzar una instancia de Amazon EC2 que ejecute Amazon Linux:
```
aws cloudformation create-stack \
--stack-name CodeDeployDemoStack \
--template-url templateURL \
--parameters ParameterKey=InstanceCount,ParameterValue=1 ParameterKey=InstanceType,ParameterValue=t1.micro \
ParameterKey=KeyPairName,ParameterValue=keyName ParameterKey=OperatingSystem,ParameterValue=Linux \
ParameterKey=SSHLocation,ParameterValue=0.0.0.0/0 ParameterKey=TagKey,ParameterValue=Name \
ParameterKey=TagValue,ParameterValue=CodeDeployDemo \
--capabilities CAPABILITY_IAM
```
Para lanzar una instancia de Amazon EC2 que ejecute Windows Server:
```
aws cloudformation create-stack --stack-name CodeDeployDemoStack --template-url template-url --parameters ParameterKey=InstanceCount,ParameterValue=1 ParameterKey=InstanceType,ParameterValue=t1.micro ParameterKey=KeyPairName,ParameterValue=keyName ParameterKey=OperatingSystem,ParameterValue=Windows ParameterKey=SSHLocation,ParameterValue=0.0.0.0/0 ParameterKey=TagKey,ParameterValue=Name ParameterKey=TagValue,ParameterValue=CodeDeployDemo --capabilities CAPABILITY_IAM
```
*keyName*es el nombre del key pair de la instancia. Escriba solo el nombre del par de claves, no la extensión de archivo del par de claves.
*template-url*es la ubicación de la CloudFormation plantilla para su región:
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/instances-ec2-create-cloudformation-template.html)
Este comando crea una CloudFormation pila denominada**CodeDeployDemoStack**, utilizando la CloudFormation plantilla del bucket de Amazon S3 especificado. La instancia de Amazon EC2 se basa en el tipo de instancia t1.micro, pero puede utilizar cualquier tipo. Está etiquetada con el valor **CodeDeployDemo**, pero se puede etiquetar con cualquier valor. Se le ha aplicado el par de claves de instancia especificado.
1. Llama al **describe-stacks** comando para comprobar que la CloudFormation pila nombrada **CodeDeployDemoStack** se creó correctamente:
```
aws cloudformation describe-stacks --stack-name CodeDeployDemoStack --query "Stacks[0].StackStatus" --output text
```
No continúe hasta que se devuelva el valor `CREATE_COMPLETE`.
Para comprobar que el CodeDeploy agente se está ejecutando en la instancia Amazon EC2, consulte y, a continuación[Gestión de las operaciones CodeDeploy de los agentes](codedeploy-agent-operations.md), continúe con. [Cree una aplicación con CodeDeploy](applications-create.md)
# Configurar una instancia de Amazon EC2 con la que trabajar CodeDeploy
Estas instrucciones muestran cómo configurar una instancia de Amazon EC2 que ejecute Amazon Linux, Ubuntu Server, Red Hat Enterprise Linux (RHEL) o Windows Server para utilizarla en las implementaciones. CodeDeploy
**nota**
Si no tiene una instancia de Amazon EC2, puede utilizar la CloudFormation plantilla para lanzar una que ejecute Amazon Linux o Windows Server. No proporcionamos una plantilla para Ubuntu Server o RHEL.
## Paso 1: Verificar que se haya asociado un perfil de instancia de IAM a la instancia de Amazon EC2
1. Inicie sesión en la consola Amazon EC2 Consola de administración de AWS y ábrala en. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. En el panel de navegación, bajo **Instances**, elija **Instances**.
1. Busque su instancia de Amazon EC2 en la lista y selecciónela.
1. En el panel de detalles de la pestaña **Description**, tome nota del valor del campo **Rol de IAM** y, a continuación, vaya a la siguiente sección.
Si el campo está vacío, puede adjuntar a la instancia un perfil de instancia de IAM. Para obtener más información, consulte [Asociar un rol de IAM a una instancia](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#attach-iam-role).
## Paso 2: Verificar que el perfil de instancia de IAM asociado tiene los permisos de acceso correctos
1. Abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Seleccione **Roles** en el panel de navegación.
1. Busque y elija el nombre de rol de IAM que anotó en el paso 4 de la sección anterior.
**nota**
Si desea utilizar el rol de servicio generado por la CloudFormation plantilla en lugar del que creó siguiendo las instrucciones que se indican en[Paso 2: Crear un rol de servicio para CodeDeploy](getting-started-create-service-role.md), tenga en cuenta lo siguiente:
En algunas versiones de nuestra CloudFormation plantilla, el nombre mostrado del perfil de instancia de IAM generado y adjunto a las instancias de Amazon EC2 no es el mismo que el nombre mostrado en la consola de IAM. Por ejemplo, el perfil de instancia de IAM podría tener un nombre de visualización de `CodeDeploySampleStack-expnyi6-InstanceRoleInstanceProfile-IK8J8A9123EX`, mientras que el perfil de la instancia de IAM en la consola de IAM podría tener un nombre de visualización de `CodeDeploySampleStack-expnyi6-InstanceRole-C5P33V1L64EX`.
Para ayudarle a identificar el perfil de instancia en la consola de IAM, verá que el prefijo de `CodeDeploySampleStack-expnyi6-InstanceRole` es el mismo para ambos. Para obtener información acerca de por qué estos nombres de visualización podrían ser diferentes, consulte [Perfiles de instancia](https://docs.aws.amazon.com/IAM/latest/UserGuide/instance-profiles.html).
1. Seleccione la pestaña **Relaciones de confianza**. Si no hay ninguna entrada en **Entidades de confianza** que diga **The identity provider(s) ec2.amazonaws.com**, no puede utilizar esta instancia de Amazon EC2. Deténgase y cree una instancia de Amazon EC2 con la información de [Trabajar con instancias para CodeDeploy](instances.md).
Si hay una entrada que dice **Los proveedores de identidad ec2.amazonaws.com y está** almacenando sus aplicaciones únicamente en GitHub repositorios, pase a. [Paso 3: Etiquetar la instancia de Amazon EC2](#instances-ec2-configure-3-tag-instance)
Si hay una entrada que dice **The identity provider(s) ec2.amazonaws.com** y almacenará sus aplicaciones en buckets de Amazon S3, elija la pestaña **Permisos**.
1. Si hay una política en el área **Políticas de permisos**, amplíe la política y, a continuación, elija **Editar política**.
1. Seleccione la pestaña **JSON**. Si está almacenando sus aplicaciones en buckets de Amazon S3, asegúrese de que `"s3:Get*"` y `"s3:List*"` estén en la lista de acciones especificadas.
Puede tener un aspecto similar al siguiente:
```
{"Statement":[{"Resource":"*","Action":[
... Some actions may already be listed here ...
"s3:Get*","s3:List*"
... Some more actions may already be listed here ...
],"Effect":"Allow"}]}
```
O puede tener un aspecto similar al siguiente:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:Get*",
"s3:List*"
],
"Resource": "*"
}
]
}
```
------
Si ni `"s3:Get*"` ni `"s3:List*"` figuran en la lista de acciones especificadas, elija **Edit (Editar)** para añadirlas y, a continuación, elija **Save (Guardar)**. (Si ni `"s3:Get*"` ni `"s3:List*"` es la última acción de la lista, asegúrese de añadir una coma después de la acción, por lo tanto se valida el documento de la política).
**nota**
Le recomendamos que restrinja esta política únicamente a los buckets de Amazon S3 a los que las instancias de Amazon EC2 deban tener acceso. Asegúrese de dar acceso a los buckets de Amazon S3 que contienen el CodeDeploy agente. De lo contrario, podría producirse un error cuando el CodeDeploy agente esté instalado o actualizado en las instancias. Para conceder al perfil de instancia de IAM acceso únicamente a algunos buckets del kit de CodeDeploy recursos de Amazon S3, utilice la siguiente política, pero elimine las líneas de los buckets a los que desee impedir el acceso:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:Get*",
"s3:List*"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:s3:::aws-codedeploy-us-east-2/*",
"arn:aws:s3:::aws-codedeploy-us-east-1/*",
"arn:aws:s3:::aws-codedeploy-us-west-1/*",
"arn:aws:s3:::aws-codedeploy-us-west-2/*",
"arn:aws:s3:::aws-codedeploy-ca-central-1/*",
"arn:aws:s3:::aws-codedeploy-eu-west-1/*",
"arn:aws:s3:::aws-codedeploy-eu-west-2/*",
"arn:aws:s3:::aws-codedeploy-eu-west-3/*",
"arn:aws:s3:::aws-codedeploy-eu-central-1/*",
"arn:aws:s3:::aws-codedeploy-eu-central-2/*",
"arn:aws:s3:::aws-codedeploy-eu-north-1/*",
"arn:aws:s3:::aws-codedeploy-eu-south-1/*",
"arn:aws:s3:::aws-codedeploy-eu-south-2/*",
"arn:aws:s3:::aws-codedeploy-il-central-1/*",
"arn:aws:s3:::aws-codedeploy-ap-east-1/*",
"arn:aws:s3:::aws-codedeploy-ap-northeast-1/*",
"arn:aws:s3:::aws-codedeploy-ap-northeast-2/*",
"arn:aws:s3:::aws-codedeploy-ap-northeast-3/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-1/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-2/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-3/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-4/*",
"arn:aws:s3:::aws-codedeploy-ap-south-1/*",
"arn:aws:s3:::aws-codedeploy-ap-south-2/*",
"arn:aws:s3:::aws-codedeploy-me-central-1/*",
"arn:aws:s3:::aws-codedeploy-me-south-1/*",
"arn:aws:s3:::aws-codedeploy-sa-east-1/*"
]
}
]
}
```
## Paso 3: Etiquetar la instancia de Amazon EC2
Para obtener instrucciones sobre cómo etiquetar la instancia de Amazon EC2 para que CodeDeploy pueda encontrarla durante una implementación, consulte [Trabajar con etiquetas en la consola](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html#Using_Tags_Console) y, a continuación, vuelva a esta página.
**nota**
Puede etiquetar la instancia de Amazon EC2 con la clave y el valor que desee. Pero asegúrese de especificar esta clave y valor cuando realice una implementación en ella.
## Paso 4: Instalar el AWS CodeDeploy agente en la instancia de Amazon EC2
Para obtener instrucciones sobre cómo instalar el CodeDeploy agente en la instancia Amazon EC2 y comprobar que se está ejecutando, consulte y, a continuación[Gestión de las operaciones CodeDeploy de los agentes](codedeploy-agent-operations.md), continúe con. [Cree una aplicación con CodeDeploy](applications-create.md)
# Trabajar con instancias locales para CodeDeploy
Una instancia local es cualquier dispositivo físico que no sea una instancia de Amazon EC2 que pueda ejecutar CodeDeploy el agente y conectarse a puntos finales de servicio AWS público.
La implementación de una revisión de CodeDeploy la aplicación en una instancia local implica dos pasos principales:
+ **Paso 1**: Configure cada instancia local, regístrela y, a continuación CodeDeploy, etiquétela.
+ **Paso 2**: Implementar revisiones de aplicaciones en la instancia en las instalaciones
**nota**
Para experimentar con la creación e implementación de una revisión de la aplicación de muestra en una instancia on-premises correctamente configurada y registrada, consulte [Tutorial: Implemente una aplicación en una instancia local con CodeDeploy (Windows Server, Ubuntu Server o Red Hat Enterprise Linux)](tutorials-on-premises-instance.md). Para obtener información sobre las instancias locales y cómo funcionan con ellas CodeDeploy, consulte. [Trabajar con instancias locales para CodeDeploy](#instances-on-premises)
Si ya no desea usar una instancia en las instalaciones en las implementaciones, simplemente puede eliminar las etiquetas de la instancia en las instalaciones de los grupos de implementación. Para utilizar un método más eficaz, elimine las etiquetas de la instancia en las instalaciones de la instancia. También puede anular el registro de una instancia on-premises de forma explícita para que ya no se pueda utilizar en ninguna implementación. Para obtener más información, consulte [Administrar las operaciones de instancias locales en CodeDeploy](on-premises-instances-operations.md).
Las instrucciones de esta sección muestran cómo configurar una instancia local y, a continuación, registrarla y etiquetarla CodeDeploy para que pueda usarse en las implementaciones. En esta sección también se describe cómo CodeDeploy obtener información sobre las instancias locales y anular el registro de una instancia local cuando ya no se planea realizar la implementación en ella.
**Topics**
+ [Requisitos previos para configurar una instancia en las instalaciones](instances-on-premises-prerequisites.md)
+ [Registro de una instancia en las instalaciones](on-premises-instances-register.md)
+ [Cómo administrar operaciones de instancias en las instalaciones](on-premises-instances-operations.md)
# Requisitos previos para configurar una instancia en las instalaciones
Se deben cumplir los siguientes requisitos previos para poder registrar una instancia en las instalaciones.
**importante**
Si utilizas el [register-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-on-premises-instance.html)comando y actualizas periódicamente las credenciales temporales generadas con AWS Security Token Service (AWS STS), existen otros requisitos previos. Para obtener información, consulte [Requisitos previos del registro de ARN de sesión de IAM](register-on-premises-instance-iam-session-arn.md#register-on-premises-instance-iam-session-arn-prerequisites).
**Requisitos de los dispositivos**
El dispositivo que deseas preparar, registrar y etiquetar como instancia local CodeDeploy debe ejecutar un sistema operativo compatible. Para ver una lista, consulte [Sistemas operativos compatibles con el agente CodeDeploy](codedeploy-agent.md#codedeploy-agent-supported-operating-systems).
Si su sistema operativo no es compatible, el CodeDeploy agente está disponible como código abierto para que lo adapte a sus necesidades. Para obtener más información, consulte el repositorio de [CodeDeploy agentes](https://github.com/aws/aws-codedeploy-agent) en GitHub.
**Comunicación saliente**
La instancia local debe poder conectarse a los puntos finales del AWS servicio público para poder comunicarse con ellos. CodeDeploy
El CodeDeploy agente se comunica de forma saliente mediante HTTPS a través del puerto 443.
**Control administrativo**
La cuenta local o de red utilizada en la instancia en las instalaciones para configurar dicha instancia debe poder ejecutarse como `sudo` o `root` (para Ubuntu Server) o como administrador (para Windows Server).
**Permisos de IAM**
La identidad de IAM que utiliza para registrar la instancia en las instalaciones debe tener permisos para completar el registro (y para anular el registro de la instancia en las instalaciones, según sea necesario).
Además de la política descrita en [Paso 3: Limitar los permisos del CodeDeploy usuario](getting-started-policy.md), asegúrese de que la identidad de IAM que efectúa la llamada tiene asocia la siguiente política adicional.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iam:CreateAccessKey",
"iam:CreateUser",
"iam:DeleteAccessKey",
"iam:DeleteUser",
"iam:DeleteUserPolicy",
"iam:ListAccessKeys",
"iam:ListUserPolicies",
"iam:PutUserPolicy",
"iam:GetUser"
],
"Resource": "*"
}
]
}
```
------
Para obtener información acerca de cómo adjuntar directivas de IAM, consulte [Administración de directivas de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage.html).
# Registre una instancia local con CodeDeploy
Para registrar una instancia on-premise, debe utilizar una identidad de IAM para autenticar las solicitudes. Puede elegir entre las siguientes opciones para la identidad de IAM y el método de registro que utilice:
+ Utilice un ARN de rol de IAM para autenticar las solicitudes.
+ Use el [register-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-on-premises-instance.html)comando y las credenciales temporales que se actualizan periódicamente generadas con AWS Security Token Service (AWS STS) para configurar manualmente la mayoría de las opciones de registro. Esta opción ofrece el nivel más alto de seguridad, ya que la autenticación se realiza mediante un token temporal que se agota y se debe actualizar periódicamente. Esta opción se recomienda para implementaciones de producción de cualquier tamaño. Para obtener información, consulte [Usa el register-on-premises-instance comando (ARN de sesión de IAM) para registrar una instancia local](register-on-premises-instance-iam-session-arn.md).
+ (No recomendado) Utilice un ARN de usuario de IAM para autenticar las solicitudes.
+ Utilice el comando [register](https://docs.aws.amazon.com/cli/latest/reference/deploy/register.html) para el proceso de registro más automatizado. Esta opción solo debe usarse para implementaciones que no sean de producción en las que la seguridad sea un problema menor. Esta opción es menos segura porque utiliza credenciales estáticas (permanentes) para la autenticación. Esta opción funciona bien para registrar una instancia en las instalaciones individual. Para obtener información, consulte [Uso del comando “register” (ARN de usuario de IAM) para registrar una instancia en las instalaciones](instances-on-premises-register-instance.md).
+ Utilice el comando [register-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-on-premises-instance.html) para configurar manualmente la mayoría de las opciones de registro. Es adecuado para registrar un pequeño número de instancias en las instalaciones. Para obtener información, consulte [Usa el register-on-premises-instance comando (ARN del usuario de IAM) para registrar una instancia local](register-on-premises-instance-iam-user-arn.md).
**Topics**
+ [Usa el register-on-premises-instance comando (ARN de sesión de IAM) para registrar una instancia local](register-on-premises-instance-iam-session-arn.md)
+ [Uso del comando “register” (ARN de usuario de IAM) para registrar una instancia en las instalaciones](instances-on-premises-register-instance.md)
+ [Usa el register-on-premises-instance comando (ARN del usuario de IAM) para registrar una instancia local](register-on-premises-instance-iam-user-arn.md)
# Usa el register-on-premises-instance comando (ARN de sesión de IAM) para registrar una instancia local
Para tener el máximo control sobre la autenticación y el registro de las instancias locales, puede usar el [register-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-on-premises-instance.html)comando y actualizar periódicamente las credenciales temporales generadas con (). AWS Security Token Service AWS STS Una función de IAM estática para la instancia asume la función de estas AWS STS credenciales actualizadas para realizar las operaciones de implementación. CodeDeploy
Este método es muy útil cuando necesita registrar un gran número de instancias. Permite automatizar el proceso de registro con. CodeDeploy Puede usar su propio sistema de identidad y autenticación para autenticar las instancias locales y distribuir las credenciales de sesión de IAM del servicio a las instancias para su uso. CodeDeploy
**nota**
Como alternativa, puedes usar un usuario de IAM compartido distribuido entre todas las instancias locales para llamar a la AWS STS [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)API y recuperar las credenciales de sesión de las instancias locales. Este método es menos seguro y no se recomienda para entornos de producción o críticos.
Usa la información de los siguientes temas para configurar una instancia local con las credenciales de seguridad temporales generadas con. AWS STS
**Topics**
+ [Requisitos previos del registro de ARN de sesión de IAM](#register-on-premises-instance-iam-session-arn-prerequisites)
+ [Paso 1: Crear el rol de IAM que asumirán las instancias en las instalaciones](#register-on-premises-instance-iam-session-arn-1)
+ [Paso 2: Genera credenciales temporales para una instancia individual mediante AWS STS](#register-on-premises-instance-iam-session-arn-2)
+ [Paso 3: Añadir un archivo de configuración a la instancia en las instalaciones](#register-on-premises-instance-iam-session-arn-3)
+ [Paso 4: Prepare una instancia local para las implementaciones CodeDeploy](#register-on-premises-instance-iam-session-arn-4)
+ [Paso 5: Registre la instancia local con CodeDeploy](#register-on-premises-instance-iam-session-arn-5)
+ [Paso 6: Etiquetar la instancia en las instalaciones](#register-on-premises-instance-iam-session-arn-6)
+ [Paso 7: Implementar revisiones de aplicaciones en la instancia on-premises](#register-on-premises-instance-iam-session-arn-7)
+ [Paso 8: Hacer un seguimiento de las implementaciones en la instancia en las instalaciones](#register-on-premises-instance-iam-session-arn-8)
## Requisitos previos del registro de ARN de sesión de IAM
Además de los requisitos previos indicados en [Requisitos previos para configurar una instancia en las instalaciones](instances-on-premises-prerequisites.md), deben cumplirse los siguientes requisitos adicionales:
**Permisos de IAM**
La identidad de IAM que utilices para registrar una instancia local debe tener permisos para realizar operaciones. CodeDeploy Asegúrese de que la política administrada **AWSCodeDeployFullAccess** está asociada a la identidad de IAM. Para obtener más información, consulte [Políticas administradas de AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_managed-vs-inline.html#aws-managed-policies) en la *Guía del usuario de IAM*.
**Sistema para actualizar las credenciales temporales**
Si utiliza un ARN de sesión de IAM para registrar instancias on-premises, debe disponer de un sistema para actualizar periódicamente las credenciales temporales. Las credenciales temporales caducan después de una hora o antes si se especifica un periodo más corto cuando se generan las credenciales. Existen dos métodos para actualizar las credenciales:
+ **Método 1**: utilice el sistema de identidad y autenticación de su red corporativa con un script CRON que sondee periódicamente el sistema de identidad y autenticación y copie las credenciales de la última sesión en la instancia. Esto le permite integrar su estructura de autenticación e identidad AWS sin necesidad de realizar cambios en el CodeDeploy agente o el servicio para admitir los tipos de autenticación que utiliza en su organización.
+ **Método 2**: ejecuta periódicamente un trabajo CRON en la instancia para activar la AWS STS [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)acción y escribir las credenciales de la sesión en un archivo al que pueda acceder el CodeDeploy agente. Este método requiere igualmente utilizar un usuario de IAM y copiar las credenciales en la instancia on-premises, pero puede volver a utilizar el mismo usuario de IAM y las mismas credenciales en toda la flota de instancias on-premises.
**nota**
Independientemente de si utilizas el método 1 o el 2, debes configurar un proceso para reiniciar el CodeDeploy agente una vez que se hayan actualizado las credenciales de sesión temporales, de modo que las nuevas credenciales surtan efecto.
Para obtener información sobre cómo crear AWS STS credenciales y trabajar con ellas, consulte [Referencia de AWS Security Token Service API](https://docs.aws.amazon.com/STS/latest/APIReference/) y [Uso de credenciales de seguridad temporales para solicitar acceso a AWS los recursos](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html).
## Paso 1: Crear el rol de IAM que asumirán las instancias en las instalaciones
Puede usar la consola de IAM AWS CLI o la consola de IAM para crear un rol de IAM que las instancias locales utilizarán para autenticarse e interactuar con él. CodeDeploy
Solo tiene que crear un único rol de IAM. Cada una de las instancias on-premises puede asumir este rol para recuperar las credenciales de seguridad temporales que proporcionan los permisos concedidos a este rol.
El rol que cree necesitará los siguientes permisos para acceder a los archivos necesarios para instalar el agente: CodeDeploy
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"s3:Get*",
"s3:List*"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
------
Le recomendamos que restrinja esta política únicamente a los buckets de Amazon S3 a los que su instancia en las instalaciones necesite tener acceso. Si restringe esta política, asegúrese de dar acceso a los buckets de Amazon S3 que contienen el CodeDeploy agente. De lo contrario, podría producirse un error cada vez que el CodeDeploy agente se instale o actualice en la instancia local. Para obtener más información acerca del control del acceso a los recursos de Amazon S3, consulte [Administración de permisos de acceso para los recursos de Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-access-control.html).
**Creación del rol de IAM**
1. Llame al comando [create-role](https://docs.aws.amazon.com/cli/latest/reference/iam/create-role.html) usando la opción `--role-name` para especificar un nombre para el rol de IAM (por ejemplo, `CodeDeployInstanceRole`) y la opción `--assume-role-policy-document` para proporcionar los permisos.
Cuando cree el rol de IAM para esta instancia, puede asignarle el nombre `CodeDeployInstanceRole` e incluir los permisos necesarios en un archivo denominado `CodeDeployRolePolicy.json`:
```
aws iam create-role --role-name CodeDeployInstanceRole --assume-role-policy-document file://CodeDeployRolePolicy.json
```
1. En la salida de la llamada al comando **create-role**, anote el valor del campo ARN. Por ejemplo:
```
arn:aws:iam::123456789012:role/CodeDeployInstanceRole
```
Necesitará el rol ARN cuando utilice la AWS STS [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html)API para generar credenciales a corto plazo para cada instancia.
Para obtener más información sobre la creación de funciones de IAM, consulte [Crear una función para delegar permisos a un AWS servicio](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) en la Guía del usuario de *IAM*.
[Para obtener información sobre la asignación de permisos a un rol existente, consulte [put-role-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/put-role-policy.html)la Referencia de comandos.AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/)
## Paso 2: Genera credenciales temporales para una instancia individual mediante AWS STS
Antes de generar las credenciales temporales que se utilizarán para registrar una instancia on-premises, debe crear o elegir la identidad de IAM (usuario o rol) para la que se generarán las credenciales temporales. El permiso `sts:AssumeRole` debe estar incluido en la configuración de política de esta identidad de IAM.
Para obtener información sobre la concesión de `sts:AssumeRole` permisos a una identidad de IAM, consulte [Crear un rol para delegar permisos a un AWS servicio](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) y [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html).
Hay dos formas de generar credenciales temporales:
+ Use el comando [assume-role](https://docs.aws.amazon.com/cli/latest/reference/sts/assume-role.html) con la AWS CLI. Por ejemplo:
```
aws sts assume-role --role-arn arn:aws:iam::12345ACCOUNT:role/role-arn --role-session-name session-name
```
Donde:
+ *12345ACCOUNT*es el número de cuenta de 12 dígitos de su organización.
+ *role-arn*es el ARN del rol que se va a asumir, que se generó en. [Paso 1: Crear el rol de IAM que asumirán las instancias en las instalaciones](#register-on-premises-instance-iam-session-arn-1)
+ *session-name*es el nombre que desea asignar a la sesión de rol que está creando ahora.
**nota**
Si utilizas un script CRON que sondea periódicamente el sistema de identidad y autenticación y copia las credenciales de sesión más recientes en la instancia (el método 1 para actualizar las credenciales temporales se describe en[Requisitos previos del registro de ARN de sesión de IAM](#register-on-premises-instance-iam-session-arn-prerequisites)), puedes utilizar cualquier AWS SDK compatible para realizar la llamada [AssumeRole](https://docs.aws.amazon.com/STS/latest/APIReference/API_AssumeRole.html).
+ Usa una herramienta proporcionada por AWS.
La aws-codedeploy-session-helper herramienta genera AWS STS credenciales y las escribe en un archivo que coloques en la instancia. Esta herramienta es adecuada para el método 2 de actualización de credenciales temporales que se describe en [Requisitos previos del registro de ARN de sesión de IAM](#register-on-premises-instance-iam-session-arn-prerequisites). En este método, la aws-codedeploy-session-helper herramienta se coloca en cada instancia y ejecuta el comando con los permisos de un usuario de IAM. Cada instancia utiliza las mismas credenciales de usuario de IAM junto con esta herramienta.
Para obtener más información, consulta el [aws-codedeploy-session-helper](https://github.com/awslabs/aws-codedeploy-samples/tree/master/utilities/aws-codedeploy-session-helper) GitHub repositorio.
**nota**
Una vez que haya creado las credenciales de inicio de sesión de IAM, colóquelas en cualquier ubicación de la instancia on-premises. En el siguiente paso, configurará el CodeDeploy agente para que acceda a las credenciales de esta ubicación.
Antes de continuar, asegúrese de que el sistema que se utilizará para actualizar periódicamente las credenciales temporales está instalado. Si las credenciales temporales no se actualizan, las implementaciones en la instancia on-premises producirán un error. Para obtener más información, consulte "Sistema para actualizar las credenciales temporales" en [Requisitos previos del registro de ARN de sesión de IAM](#register-on-premises-instance-iam-session-arn-prerequisites).
## Paso 3: Añadir un archivo de configuración a la instancia en las instalaciones
Añada un archivo de configuración a la instancia on-premises, utilizando los permisos raíz o de administrador. Este archivo de configuración se utiliza para declarar las credenciales de IAM y la AWS región de destino para CodeDeploy la que se van a utilizar. El archivo debe añadirse a una ubicación específica de la instancia on-premises. El archivo debe incluir el ARN de la sesión temporal de IAM, su ID de clave secreta y su clave de acceso secreta, y la AWS región de destino.
**Para añadir un archivo de configuración**
1. Cree un archivo denominado `codedeploy.onpremises.yml` (si se trata de una instancia en las instalaciones de Ubuntu Server o RHEL) o `conf.onpremises.yml` (en el caso de una instancia en las instalaciones de Windows) en la siguiente ubicación de la instancia en las instalaciones:
+ Para Ubuntu Server: `/etc/codedeploy-agent/conf`
+ Para Windows Server: `C:\ProgramData\Amazon\CodeDeploy`
1. Utilice un editor de texto para añadir la siguiente información al archivo `codedeploy.onpremises.yml` (Linux) o `conf.onpremises.yml` (Windows) recién creado:
```
---
iam_session_arn: iam-session-arn
aws_credentials_file: credentials-file
region: supported-region
```
Donde:
+ *iam-session-arn*es el ARN de sesión de IAM en el que anotó. [Paso 2: Genera credenciales temporales para una instancia individual mediante AWS STS](#register-on-premises-instance-iam-session-arn-2)
+ *credentials-file*es la ubicación del archivo de credenciales del ARN de sesión temporal, como se indica en. [Paso 2: Genera credenciales temporales para una instancia individual mediante AWS STS](#register-on-premises-instance-iam-session-arn-2)
+ *supported-region*es una de las regiones CodeDeploy compatibles, tal y como se indica en [Región y puntos finales](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) en. *Referencia general de AWS*
## Paso 4: Prepare una instancia local para las implementaciones CodeDeploy
**Instale y configure el AWS CLI **
Instale y configure AWS CLI la instancia local. (Se AWS CLI usará para descargar e instalar el CodeDeploy agente en la instancia local).
1. Para instalarlo AWS CLI en la instancia local, siga las instrucciones que se indican en la Guía del *AWS Command Line Interface usuario* sobre [cómo configurarlo AWS CLI con](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-set-up.html) el.
**nota**
CodeDeploy los comandos para trabajar con instancias locales estuvieron disponibles en la versión 1.7.19 de. AWS CLI Si AWS CLI ya tienes una versión de la instalada, puedes comprobar su versión llamando a. **aws --version**
1. Para configurar AWS CLI la instancia local, siga las instrucciones de la *Guía del AWS Command Line Interface usuario* sobre [cómo configurar AWS CLI la](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) instancia local.
**importante**
Al configurar la AWS CLI (por ejemplo, mediante una llamada al **aws configure** comando), asegúrese de especificar el ID de clave secreta y la clave de acceso secreta de un usuario de IAM que tenga, como mínimo, los permisos descritos en. [Requisitos previos del registro de ARN de sesión de IAM](#register-on-premises-instance-iam-session-arn-prerequisites)
**Establezca la variable de AWS\$1REGION entorno (solo para servidores Ubuntu y RHEL)**
Si no está ejecutando Ubuntu Server o RHEL en su instancia local, omita este paso y vaya directamente a «Instalar el CodeDeploy agente».
Instala el CodeDeploy agente en una instancia local de Ubuntu Server o RHEL y habilita la instancia para que actualice el CodeDeploy agente cada vez que haya una nueva versión disponible. Para ello, tiene que establecer en la instancia la variable de entorno `AWS_REGION` en el identificador de una de las regiones admitidas por CodeDeploy. Le recomendamos que establezca el valor en la región en la que se encuentran CodeDeploy las aplicaciones, los grupos de implementación y las revisiones de las aplicaciones (por ejemplo,`us-west-2`). Para obtener una lista de regiones, consulte [Regiones y puntos de conexión](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) en la *Referencia general de AWS*.
Para establecer la variable de entorno, llame al siguiente comando desde el terminal:
```
export AWS_REGION=supported-region
```
Dónde *supported-region* está el identificador de la región (por ejemplo,`us-west-2`).
**Instale el CodeDeploy agente**
+ Si se trata de una instancia en las instalaciones de Ubuntu Server, siga las instrucciones de [Instale el CodeDeploy agente para Ubuntu Server](codedeploy-agent-operations-install-ubuntu.md) y después vuelva a esta página.
+ Si se trata de una instancia en las instalaciones de RHEL, siga las instrucciones de [Instalar el CodeDeploy agente para Amazon Linux o RHEL](codedeploy-agent-operations-install-linux.md) y después vuelva a esta página.
+ Si se trata de una instancia en las instalaciones de Windows Server, siga las instrucciones de [Instale el CodeDeploy agente para Windows Server](codedeploy-agent-operations-install-windows.md) y después vuelva a esta página.
## Paso 5: Registre la instancia local con CodeDeploy
En las instrucciones de este paso se da por supuesto que va a registrar la instancia on-premises desde la propia instancia on-premises. Puede registrar una instancia local desde un dispositivo o instancia independiente que la tenga AWS CLI instalada y configurada.
AWS CLI Utilízala para registrar la instancia local y CodeDeploy poder utilizarla en las implementaciones.
Antes de poder usar el AWS CLI, necesitará el ARN de las credenciales de sesión temporales en las que creó. [Paso 3: Añadir un archivo de configuración a la instancia en las instalaciones](#register-on-premises-instance-iam-session-arn-3) Por ejemplo, en el caso de una instancia que identifique como `AssetTag12010298EX`:
```
arn:sts:iam::123456789012:assumed-role/CodeDeployInstanceRole/AssetTag12010298EX
```
Ejecute el comando [register-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-on-premises-instance.html) especificando lo siguiente:
+ Un nombre que identifique de manera única la instancia en las instalaciones (con la opción `--instance-name`).
**importante**
Para ayudar a identificar la instancia on-premises, especialmente a efectos de depuración, es absolutamente recomendable que especifique un nombre que se corresponda con algunas características exclusivas de la instancia on-premises (por ejemplo, el nombre de sesión de las credenciales de STS y el número de serie de un identificador de recurso interno, si procede). Si especifica una dirección MAC como nombre, tenga en cuenta que las direcciones MAC contienen caracteres CodeDeploy no permitidos, como dos puntos (:)). Para obtener una lista de los caracteres permitidos, consulte [CodeDeploy cuotas](limits.md).
+ El ARN de sesión de IAM que configura para autenticar varias instancias on-premises en [Paso 1: Crear el rol de IAM que asumirán las instancias en las instalaciones](#register-on-premises-instance-iam-session-arn-1).
Por ejemplo:
```
aws deploy register-on-premises-instance --instance-name name-of-instance --iam-session-arn arn:aws:sts::account-id:assumed-role/role-to-assume/session-name
```
Donde:
+ *name-of-instance*es el nombre que se utiliza para identificar la instancia local, por ejemplo. `AssetTag12010298EX`
+ *account-id*es el ID de cuenta de 12 dígitos de su organización, por ejemplo. `111222333444`
+ *role-to-assume*es el nombre del rol de IAM que creaste para la instancia, por ejemplo. `CodeDeployInstanceRole`
+ *session-name*es el nombre del rol de sesión que especificó. [Paso 2: Genera credenciales temporales para una instancia individual mediante AWS STS](#register-on-premises-instance-iam-session-arn-2)
## Paso 6: Etiquetar la instancia en las instalaciones
Puede usar la consola AWS CLI o la CodeDeploy consola para etiquetar la instancia local. (CodeDeployusa etiquetas de instancias locales para identificar los objetivos de implementación durante una implementación).
**Para etiquetar la instancia en las instalaciones (CLI)**
+ Llama al comando [add-tags-to-on-premises-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/add-tags-to-on-premises-instances.html) y especifica:
+ El nombre que identifica de manera única la instancia on-premises (con la opción `--instance-names`).
+ El nombre de la clave de etiqueta y el valor de etiqueta de la instancia on-premises que desea utilizar (con la opción `--tags`). Debe especificar un nombre y un valor. CodeDeploy no permite etiquetas de instancias locales que solo tengan valores.
Por ejemplo:
```
aws deploy add-tags-to-on-premises-instances --instance-names AssetTag12010298EX --tags Key=Name,Value=CodeDeployDemo-OnPrem
```
**Para etiquetar la instancia on-premises (consola)**
1. Inicia sesión Consola de administración de AWS y abre 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 elija **Instancias en las instalaciones**.
1. En la lista de instancias on-premises, elija el nombre de la instancia on-premises que desea etiquetar.
1. En la lista de etiquetas, seleccione o introduzca la clave y el valor que desee para la etiqueta. Cuando introduzca la clave y el valor de la etiqueta, aparecerá otra fila. Puede repetir esta acción para un máximo de 10 etiquetas. Para eliminar una etiqueta, elija **Eliminar**.
1. Después de añadir las etiquetas, seleccione **Update Tags**.
## Paso 7: Implementar revisiones de aplicaciones en la instancia on-premises
Ahora está listo para implementar revisiones de aplicaciones en la instancia on-premises registrada y etiquetada.
La implementación de revisiones de aplicaciones en instancias en las instalaciones es similar a la implementación de revisiones de aplicaciones en instancias de Amazon EC2. Para obtener instrucciones, consulte [Cree una implementación con CodeDeploy](deployments-create.md). Estas instrucciones incluyen un enlace a los requisitos previos, incluida la creación de una aplicación, la creación de un grupo de implementaciones y la preparación de la revisión de una aplicación. Si necesita una revisión de una aplicación sencilla para implementar, puede crear la que se describe en [Paso 2: Crear una revisión de aplicación de ejemplo](tutorials-on-premises-instance-2-create-sample-revision.md) en el [Tutorial: Implemente una aplicación en una instancia local con CodeDeploy (Windows Server, Ubuntu Server o Red Hat Enterprise Linux)](tutorials-on-premises-instance.md).
**importante**
Si reutilizas un rol de CodeDeploy servicio como parte de la creación de un grupo de implementación orientado a instancias locales, debes `Tag:get*` incluirlo en esa `Action` parte de la declaración de política del rol de servicio. Para obtener más información, consulte [Paso 2: Crear un rol de servicio para CodeDeploy](getting-started-create-service-role.md).
## Paso 8: Hacer un seguimiento de las implementaciones en la instancia en las instalaciones
Después de implementar una revisión de una aplicación en instancias en las instalaciones registradas y etiquetadas, puede hacer un seguimiento del progreso de la implementación.
El seguimiento de las implementaciones en instancias en las instalaciones es similar al seguimiento de las implementaciones en instancias de Amazon EC2. Para obtener instrucciones, consulte [Ver detalles CodeDeploy de la implementación](deployments-view-details.md).
# Uso del comando “register” (ARN de usuario de IAM) para registrar una instancia en las instalaciones
**importante**
No se recomienda registrar una instancia con un usuario de IAM porque utiliza credenciales estáticas (permanentes) para la autenticación. Para mejorar la seguridad, recomendamos registrar una instancia con credenciales temporales para la autenticación. Para obtener más información, consulte [Usa el register-on-premises-instance comando (ARN de sesión de IAM) para registrar una instancia local](register-on-premises-instance-iam-session-arn.md).
**importante**
Asegúrese de tener un plan para rotar las claves de acceso del usuario de IAM (credenciales permanentes). Para obtener más información, consulte [Rotación de las claves de acceso](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_credentials_access-keys.html#Using_RotateAccessKey).
Esta sección describe cómo configurar una instancia on-premises y cómo registrarla y etiquetarla en CodeDeploy con el mínimo esfuerzo. El comando **register** resulta especialmente útil cuando se trabaja con una sola flota o con flotas pequeñas de instancias en las instalaciones. Solo puede utilizar el comando **register** si emplea un ARN de usuario de IAM para autenticar una instancia. No puede utilizar el comando **register** con un ARN de sesión de IAM para la autenticación.
Cuando usas el **register** comando, puedes CodeDeploy hacer lo siguiente:
+ Crea un usuario de IAM AWS Identity and Access Management para la instancia local si no especificas uno con el comando.
+ Guardar las credenciales del usuario de IAM en un archivo de configuración de la instancia en las instalaciones.
+ Registre la instancia local con. CodeDeploy
+ Añadir etiquetas a la instancia en las instalaciones, si las especifica como parte del comando.
**nota**
El [register-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-on-premises-instance.html)comando es una alternativa al comando [register](https://docs.aws.amazon.com/cli/latest/reference/deploy/register.html). Utilice el comando **register-on-premises-instance** si desea configurar una instancia on-premises y registrarla y etiquetarla con CodeDeploy por su cuenta. El comando **register-on-premises-instance** también le da la opción de utilizar un ARN de sesión de IAM para registrar instancias en lugar de un ARN de usuario de IAM. Este enfoque proporciona una gran ventaja si tiene grandes flotas de instancias en las instalaciones. Específicamente, puede utilizar un solo ARN de sesión de IAM para autenticar múltiples instancias en lugar de tener que crear un usuario de IAM para cada instancia en las instalaciones a la vez. Para obtener más información, consulte [Usa el register-on-premises-instance comando (ARN del usuario de IAM) para registrar una instancia local](register-on-premises-instance-iam-user-arn.md) y [Usa el register-on-premises-instance comando (ARN de sesión de IAM) para registrar una instancia local](register-on-premises-instance-iam-session-arn.md).
**Topics**
+ [Paso 1: Instalar y configurar AWS CLI la instancia local](#instances-on-premises-register-instance-1-install-cli)
+ [Paso 2: Llamar al comando “register”](#instances-on-premises-register-instance-2-register-command)
+ [Paso 3: Llamar al comando “install”](#instances-on-premises-register-instance-3-install-command)
+ [Paso 4: Implementar revisiones de la aplicación en la instancia en las instalaciones](#instances-on-premises-register-instance-4-deploy-revision)
+ [Paso 5: Hacer un seguimiento de las implementaciones en la instancia en las instalaciones](#instances-on-premises-register-instance-5-track-deployment)
## Paso 1: Instalar y configurar AWS CLI la instancia local
1. Instálelo AWS CLI en la instancia local. Siga las instrucciones en [Configuración inicial de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-set-up.html) en la *Guía del usuario de la AWS Command Line Interface *.
**nota**
CodeDeploy Los comandos para trabajar con instancias locales están disponibles en la AWS CLI versión 1.7.19 y versiones posteriores. Si AWS CLI ya la tienes instalada, llama **aws --version** para comprobar su versión.
1. Configure AWS CLI la instancia local. Siga las instrucciones de [Configuración de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) en la *Guía del usuario de la AWS Command Line Interface *.
**importante**
Al configurar AWS CLI (por ejemplo, mediante una llamada al **aws configure** comando), asegúrese de especificar el ID de clave secreta y la clave de acceso secreta de un usuario de IAM que tenga, como mínimo, los siguientes permisos de AWS acceso además de los permisos especificados en. [Requisitos previos para configurar una instancia en las instalaciones](instances-on-premises-prerequisites.md) Esto permite descargar e instalar el CodeDeploy agente en la instancia local. Los permisos de acceso podrían tener un aspecto similar a este:
****
```
{
"Version":"2012-10-17",
"Statement" : [
{
"Effect" : "Allow",
"Action" : [
"codedeploy:*",
"iam:CreateAccessKey",
"iam:CreateUser",
"iam:DeleteAccessKey",
"iam:DeleteUser",
"iam:DeleteUserPolicy",
"iam:ListAccessKeys",
"iam:ListUserPolicies",
"iam:PutUserPolicy",
"iam:GetUser",
"tag:getTagKeys",
"tag:getTagValues",
"tag:GetResources"
],
"Resource" : "*"
},
{
"Effect" : "Allow",
"Action" : [
"s3:Get*",
"s3:List*"
],
"Resource" : [
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:s3:::amzn-s3-demo-bucket1/*"
]
}
]
}
```
Si ve errores de acceso denegado al intentar acceder a uno de los buckets de Amazon S3 mostrados anteriormente, intente omitir la parte de `/*` del ARN de recursos del bucket, por ejemplo `arn:aws:s3:::aws-codedeploy-sa-east-1`.
****
```
{
"Version":"2012-10-17",
"Statement" : [
{
"Effect" : "Allow",
"Action" : [
"codedeploy:*",
"iam:CreateAccessKey",
"iam:CreateUser",
"iam:DeleteAccessKey",
"iam:DeleteUser",
"iam:DeleteUserPolicy",
"iam:ListAccessKeys",
"iam:ListUserPolicies",
"iam:PutUserPolicy",
"iam:GetUser",
"tag:GetResources"
],
"Resource" : "*"
},
{
"Effect" : "Allow",
"Action" : [
"s3:Get*",
"s3:List*"
],
"Resource" : [
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:s3:::amzn-s3-demo-bucket2/*"
]
}
]
}
```
## Paso 2: Llamar al comando “register”
Para este paso se da por sentado que va a registrar la instancia on-premises desde la propia instancia on-premises. También puede registrar una instancia local desde un dispositivo o instancia independiente que la tenga AWS CLI instalada y configurada tal y como se describe en el paso anterior.
Use el comando register AWS CLI para llamar al comando [register](https://docs.aws.amazon.com/cli/latest/reference/deploy/register.html) y especifique:
+ Un nombre que identifica de forma exclusiva a la instancia local CodeDeploy (con la `--instance-name` opción).
**importante**
Para ayudarle a identificar la instancia on-premises en otro momento, especialmente a efectos de depuración, recomendamos encarecidamente que utilice un nombre que se asigne a algunas características exclusivas de la instancia on-premises (por ejemplo, el número de serie o algún identificador único de recurso interno, si procede). Si especificas una dirección MAC para un nombre, ten en cuenta que las direcciones MAC contienen caracteres CodeDeploy no permitidos, como dos puntos (`:`). Para obtener una lista de los caracteres permitidos, consulte [CodeDeploy cuotas](limits.md).
+ Si lo desea, el ARN de un usuario de IAM existente que desea asociar a esta instancia en las instalaciones (con la opción `--iam-user-arn`). Para obtener el ARN de un usuario de IAM, llame al comando [get-user](https://docs.aws.amazon.com/cli/latest/reference/iam/get-user.html) o elija el nombre de usuario de IAM en la sección **Users** de la consola de IAM y, a continuación, busque el valor **User ARN** en la sección **Summary**. Si no se especifica esta opción, CodeDeploy creará un usuario de IAM en su nombre en su AWS cuenta y lo asociará a la instancia local.
**importante**
Si especifica la opción `--iam-user-arn`, además debe crear manualmente el archivo de configuración de la instancia en las instalaciones, como se describe en [Paso 4: Añadir un archivo de configuración a la instancia en las instalaciones](register-on-premises-instance-iam-user-arn.md#register-on-premises-instance-iam-user-arn-4).
Puede asociar un solo usuario de IAM a una sola instancia en las instalaciones. Intentar asociar un solo usuario de IAM a múltiples instancias en las instalaciones puede producir errores, implementaciones fallidas en dichas instancias en las instalaciones o implementaciones en dichas instancias en las instalaciones que permanecen en estado pendiente perpetuo.
+ Opcionalmente, un conjunto de etiquetas de instancias locales (con la `--tags` opción) que CodeDeploy se utilizarán para identificar el conjunto de instancias de Amazon EC2 en las que se va a implementar. Especifique cada etiqueta con `Key=tag-key,Value=tag-value` (por ejemplo, `Key=Name,Value=Beta Key=Name,Value=WestRegion`). Si no se especifica esta opción, no se registrarán etiquetas. Para registrar las etiquetas más adelante, ejecute el comando [add-tags-to-on-premises-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/add-tags-to-on-premises-instances.html).
+ De forma opcional, la AWS región en la que se registrará la instancia local CodeDeploy (con la opción). `--region` Debe ser una de las regiones admitidas que se encuentran en la lista de [Regiones y puntos de enlace](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) de la *Referencia general de AWS* (por ejemplo, `us-west-2`). Si no se especifica esta opción, se utilizará la AWS región predeterminada asociada al usuario de IAM que realiza la llamada.
Por ejemplo:
```
aws deploy register --instance-name AssetTag12010298EX --iam-user-arn arn:aws:iam::444455556666:user/CodeDeployUser-OnPrem --tags Key=Name,Value=CodeDeployDemo-OnPrem --region us-west-2
```
El comando **register** hace lo siguiente:
1. Si no se especifica un usuario de IAM existente, lo crea, le asocia los permisos necesarios y genera la clave secreta y la clave de acceso secreta correspondientes. La instancia local utilizará este usuario de IAM y sus permisos y credenciales para autenticarse e interactuar con él. CodeDeploy
1. Registra la instancia local con. CodeDeploy
1. Si se especifica, asocia CodeDeploy las etiquetas especificadas con la `--tags` opción al nombre de la instancia local registrada.
1. Si ya se ha creado el usuario de IAM, también crea el archivo de configuración necesario en el mismo directorio desde el que se ejecutó el comando **register**.
Si este comando encuentra algún error, aparece un mensaje en el que se describe cómo realizar manualmente los pasos faltantes. En caso contrario, aparece un mensaje de confirmación en el que se describe cómo ejecutar el comando **install** según se indica en el siguiente paso.
## Paso 3: Llamar al comando “install”
Desde la instancia local, usa el comando AWS CLI para llamar al comando [install](https://docs.aws.amazon.com/cli/latest/reference/deploy/install.html) y especifica:
+ La ruta al archivo de configuración (con la opción `--config-file`).
+ Si lo desea, si se reemplazará el archivo de configuración que ya existe en la instancia on-premises (con la opción `--override-config`). Si no se especifica, no se sustituirá el archivo de configuración existente.
+ De forma opcional, la AWS región en la que se registrará la instancia local CodeDeploy (con la `--region` opción). Debe ser una de las regiones admitidas que se encuentran en la lista de [Regiones y puntos de enlace](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) de la *Referencia general de AWS* (por ejemplo, `us-west-2`). Si no se especifica esta opción, se utilizará la AWS región predeterminada asociada al usuario de IAM que realiza la llamada.
+ Opcionalmente, una ubicación personalizada desde la que instalar el CodeDeploy agente (con la `--agent-installer` opción). Esta opción resulta útil para instalar una versión personalizada del CodeDeploy agente que CodeDeploy no sea compatible oficialmente (por ejemplo, una versión personalizada basada en el repositorio de [CodeDeployagentes](https://github.com/aws/aws-codedeploy-agent) de GitHub). El valor debe ser la ruta a un bucket de Amazon S3 que contenga cualquiera de los siguientes:
+ Un script de instalación del CodeDeploy agente (para sistemas operativos basados en Linux o Unix, similar al archivo de instalación del repositorio del [CodeDeployagente](https://github.com/aws/aws-codedeploy-agent/blob/master/bin/install)). GitHub
+ Un archivo de paquete de instalación del CodeDeploy agente (.msi) (para sistemas operativos basados en Windows).
Si no se especifica esta opción, CodeDeploy intentará instalar desde su propia ubicación una versión oficial del CodeDeploy agente que sea compatible con el sistema operativo de la instancia local.
Por ejemplo:
```
aws deploy install --override-config --config-file /tmp/codedeploy.onpremises.yml --region us-west-2 --agent-installer s3://aws-codedeploy-us-west-2/latest/codedeploy-agent.msi
```
El comando **install** hace lo siguiente:
1. Comprueba si la instancia en las instalaciones es una instancia de Amazon EC2. Si lo es, aparece un mensaje de error.
1. Copia el archivo de configuración de las instancias locales de la ubicación especificada de la instancia a la ubicación en la que el CodeDeploy agente espera encontrarlo, siempre que el archivo no esté ya en esa ubicación.
Para Ubuntu Server y Red Hat Enterprise Linux (RHEL), es `/etc/codedeploy-agent/conf`/`codedeploy.onpremises.yml`.
Para Windows Server, es `C:\ProgramData\Amazon\CodeDeploy`\$1`conf.onpremises.yml`.
Si se especificó la opción `--override-config`, crea o sobrescribe el archivo.
1. Instala el CodeDeploy agente en la instancia local y, a continuación, la inicia.
## Paso 4: Implementar revisiones de la aplicación en la instancia en las instalaciones
Ahora está listo para implementar revisiones de aplicaciones en la instancia on-premises registrada y etiquetada.
La implementación de revisiones de aplicaciones en instancias en las instalaciones es similar a la implementación de revisiones de aplicaciones en instancias de Amazon EC2. Para obtener instrucciones, consulte [Cree una implementación con CodeDeploy](deployments-create.md). Estas instrucciones incluyen un enlace a los requisitos previos, incluida la creación de una aplicación, la creación de un grupo de implementaciones y la preparación de la revisión de una aplicación. Si necesita una revisión de una aplicación sencilla para implementar, puede crear la que se describe en [Paso 2: Crear una revisión de aplicación de ejemplo](tutorials-on-premises-instance-2-create-sample-revision.md) en el [Tutorial: Implemente una aplicación en una instancia local con CodeDeploy (Windows Server, Ubuntu Server o Red Hat Enterprise Linux)](tutorials-on-premises-instance.md).
**importante**
Si reutilizas un rol de CodeDeploy servicio existente como parte de la creación de un grupo de implementación orientado a instancias locales, debes `Tag:get*` incluirlo en esa `Action` parte de la declaración de política del rol de servicio. Para obtener más información, consulte [Paso 2: Crear un rol de servicio para CodeDeploy](getting-started-create-service-role.md).
## Paso 5: Hacer un seguimiento de las implementaciones en la instancia en las instalaciones
Después de implementar una revisión de una aplicación en instancias en las instalaciones registradas y etiquetadas, puede hacer un seguimiento del progreso de la implementación.
El seguimiento de las implementaciones en instancias en las instalaciones es similar al seguimiento de las implementaciones en instancias de Amazon EC2. Para obtener instrucciones, consulte [Ver detalles CodeDeploy de la implementación](deployments-view-details.md).
Para obtener más opciones, consulte [Administrar las operaciones de instancias locales en CodeDeploy](on-premises-instances-operations.md).
# Usa el register-on-premises-instance comando (ARN del usuario de IAM) para registrar una instancia local
**importante**
No se recomienda registrar una instancia con un usuario de IAM porque utiliza credenciales estáticas (permanentes) para la autenticación. Para mejorar la seguridad, recomendamos registrar una instancia con credenciales temporales para la autenticación. Para obtener más información, consulte [Usa el register-on-premises-instance comando (ARN de sesión de IAM) para registrar una instancia local](register-on-premises-instance-iam-session-arn.md).
**importante**
Asegúrese de tener un plan para rotar las claves de acceso del usuario de IAM (credenciales permanentes). Para obtener más información, consulte [Rotación de las claves de acceso](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_credentials_access-keys.html#Using_RotateAccessKey).
Siga estas instrucciones para configurar una instancia on-premises y registrarla y etiquetarla con CodeDeploy por su cuenta, utilizando las credenciales estáticas de un usuario de IAM para la autenticación.
**Topics**
+ [Paso 1: Crear un usuario de IAM para la instancia en las instalaciones](#register-on-premises-instance-iam-user-arn-1)
+ [Paso 2: Asignar permisos al usuario de IAM](#register-on-premises-instance-iam-user-arn-2)
+ [Paso 3: Obtener las credenciales del usuario de IAM](#register-on-premises-instance-iam-user-arn-3)
+ [Paso 4: Añadir un archivo de configuración a la instancia en las instalaciones](#register-on-premises-instance-iam-user-arn-4)
+ [Paso 5: Instalar y configurar el AWS CLI](#register-on-premises-instance-iam-user-arn-5)
+ [Paso 6: Defina la variable de AWS\$1REGION entorno (solo en Ubuntu Server y RHEL)](#register-on-premises-instance-iam-user-arn-6)
+ [Paso 7: Instalar el CodeDeploy agente](#register-on-premises-instance-iam-user-arn-7)
+ [Paso 8: registre la instancia local con CodeDeploy](#register-on-premises-instance-iam-user-arn-8)
+ [Paso 9: Etiquetar la instancia en las instalaciones](#register-on-premises-instance-iam-user-arn-9)
+ [Paso 10: Implementar revisiones de aplicaciones en la instancia en las instalaciones](#register-on-premises-instance-iam-user-arn-10)
+ [Paso 11: Hacer un seguimiento de las implementaciones en la instancia en las instalaciones](#register-on-premises-instance-iam-user-arn-11)
## Paso 1: Crear un usuario de IAM para la instancia en las instalaciones
Cree un usuario de IAM que la instancia local utilice para autenticarse e interactuar con él. CodeDeploy
**importante**
Debe crear un usuario de IAM diferente para cada instancia en las instalaciones que emplee. Si intentas reutilizar un usuario de IAM individual para varias instancias locales, es posible que no puedas registrar o etiquetar correctamente esas instancias locales. CodeDeploy Las implementaciones en esas instancias on-premises pueden quedarse bloqueadas en un estado pendiente perpetuo o producir errores.
Le recomendamos que asigne al usuario de IAM un nombre que identifique su propósito, como -. CodeDeployUser OnPrem
Puede utilizar la consola de IAM AWS CLI o la consola de IAM para crear un usuario de IAM. Para obtener información, consulte [Creación de un usuario de IAM en su cuenta de AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html).
**importante**
Ya sea que utilice la consola de IAM AWS CLI o la consola de IAM para crear un nuevo usuario de IAM, anote el ARN de usuario proporcionado al usuario. Necesitará esta información más tarde en [Paso 4: Añadir un archivo de configuración a la instancia en las instalaciones](#register-on-premises-instance-iam-user-arn-4) y [Paso 8: registre la instancia local con CodeDeploy](#register-on-premises-instance-iam-user-arn-8).
## Paso 2: Asignar permisos al usuario de IAM
Si su instancia en las instalaciones va a implementar revisiones de aplicaciones desde buckets de Amazon S3, debe asignar al usuario de IAM los permisos necesarios para interactuar con esos buckets. Puede utilizar la consola de IAM AWS CLI o la consola de IAM para asignar permisos.
**nota**
Si va a implementar las revisiones de las aplicaciones únicamente desde GitHub los repositorios, omita este paso y vaya directamente a. [Paso 3: Obtener las credenciales del usuario de IAM](#register-on-premises-instance-iam-user-arn-3) (Todavía necesitará información acerca del usuario de IAM que creó en [Paso 1: Crear un usuario de IAM para la instancia en las instalaciones](#register-on-premises-instance-iam-user-arn-1). Se utilizará en pasos posteriores.)
**Para asignar permisos (CLI)**
1. Cree un archivo con el siguiente contenido de política en la instancia de Amazon EC2 o en el dispositivo que va a utilizar para llamar a la AWS CLI. Asigne al archivo un nombre como **CodeDeploy-OnPrem-Permissions.json** y, a continuación, guárdelo.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Action": [
"s3:Get*",
"s3:List*"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
**nota**
Le recomendamos que restrinja esta política únicamente a los buckets de Amazon S3 a los que su instancia en las instalaciones necesite tener acceso. Si restringe esta política, asegúrese de dar acceso también a los buckets de Amazon S3 que contienen el AWS CodeDeploy agente. De lo contrario, podría producirse un error cada vez que el CodeDeploy agente se instale o actualice en la instancia local asociada.
Por ejemplo:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:Get*",
"s3:List*"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:s3:::aws-codedeploy-us-east-2/*",
"arn:aws:s3:::aws-codedeploy-us-east-1/*",
"arn:aws:s3:::aws-codedeploy-us-west-1/*",
"arn:aws:s3:::aws-codedeploy-us-west-2/*",
"arn:aws:s3:::aws-codedeploy-ca-central-1/*",
"arn:aws:s3:::aws-codedeploy-eu-west-1/*",
"arn:aws:s3:::aws-codedeploy-eu-west-2/*",
"arn:aws:s3:::aws-codedeploy-eu-west-3/*",
"arn:aws:s3:::aws-codedeploy-eu-central-1/*",
"arn:aws:s3:::aws-codedeploy-eu-central-2/*",
"arn:aws:s3:::aws-codedeploy-eu-north-1/*",
"arn:aws:s3:::aws-codedeploy-eu-south-1/*",
"arn:aws:s3:::aws-codedeploy-eu-south-2/*",
"arn:aws:s3:::aws-codedeploy-il-central-1/*",
"arn:aws:s3:::aws-codedeploy-ap-east-1/*",
"arn:aws:s3:::aws-codedeploy-ap-northeast-1/*",
"arn:aws:s3:::aws-codedeploy-ap-northeast-2/*",
"arn:aws:s3:::aws-codedeploy-ap-northeast-3/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-1/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-2/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-3/*",
"arn:aws:s3:::aws-codedeploy-ap-southeast-4/*",
"arn:aws:s3:::aws-codedeploy-ap-south-1/*",
"arn:aws:s3:::aws-codedeploy-ap-south-2/*",
"arn:aws:s3:::aws-codedeploy-me-central-1/*",
"arn:aws:s3:::aws-codedeploy-me-south-1/*",
"arn:aws:s3:::aws-codedeploy-sa-east-1/*"
]
}
]
}
```
1. Ejecute el [put-user-policy](https://docs.aws.amazon.com/cli/latest/reference/iam/put-user-policy.html)comando y especifique el nombre del usuario de IAM (con la `--user-name` opción), un nombre para la política (con la `--policy-name` opción) y la ruta al documento de política recién creado (con la `--policy-document` opción). Por ejemplo, suponiendo que el archivo **CodeDeploy-OnPrem-Permissions.json** está en el mismo directorio (carpeta) desde el que llama a este comando:
**importante**
Asegúrese de incluir `file://` antes del nombre de archivo. Es obligatorio en este comando.
```
aws iam put-user-policy --user-name CodeDeployUser-OnPrem --policy-name CodeDeploy-OnPrem-Permissions --policy-document file://CodeDeploy-OnPrem-Permissions.json
```
**Para asignar permisos (consola)**
1. Abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. En el panel de navegación, seleccione **Policies** y, a continuación, seleccione **Create Policy**. Si aparece el botón **Empezar**, selecciónelo y, a continuación, seleccione **Crear política**.
1. Junto a **Create Your Own Policy**, seleccione **Select**.
1. En el cuadro **Policy Name (Nombre de la política)**, escriba un nombre para esta política (por ejemplo, **CodeDeploy-OnPrem-Permissions**).
1. En el cuadro **Documento de política**, escriba o pegue la siguiente expresión de permisos, que AWS CodeDeploy permite implementar revisiones de aplicaciones desde cualquier bucket de Amazon S3 especificado en la política en la instancia local en nombre del usuario de IAM:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Action": [
"s3:Get*",
"s3:List*"
],
"Effect": "Allow",
"Resource": "*"
}
]
}
```
1. Seleccione **Crear política**.
1. En el panel de navegación, seleccione **Usuarios**.
1. En la lista de usuarios, busque y elija el nombre del usuario de IAM que creó en [Paso 1: Crear un usuario de IAM para la instancia en las instalaciones](#register-on-premises-instance-iam-user-arn-1).
1. En la pestaña **Permissions**, en **Managed Policies**, seleccione **Attach Policy**.
1. Seleccione la política denominada **CodeDeploy-OnPrem-Permissions** y, a continuación, elija **Attach Policy (Asociar política)**.
## Paso 3: Obtener las credenciales del usuario de IAM
Obtenga el ID de la clave secreta y la clave de acceso secreta para el usuario de IAM. Los necesitará para [Paso 4: Añadir un archivo de configuración a la instancia en las instalaciones](#register-on-premises-instance-iam-user-arn-4). Puede utilizar la consola de IAM AWS CLI o la consola de IAM para obtener el ID de la clave secreta y la clave de acceso secreta.
**nota**
Si ya tiene el ID de la clave secreta y la clave de acceso secreta, omita este paso y vaya directamente a [Paso 4: Añadir un archivo de configuración a la instancia en las instalaciones](#register-on-premises-instance-iam-user-arn-4).
Los usuarios necesitan acceso programático si quieren interactuar con personas AWS ajenas a. Consola de administración de AWS La forma de conceder el acceso programático depende del tipo de usuario que acceda. AWS
Para conceder acceso programático a los usuarios, elija una de las siguientes opciones.
****
| ¿Qué usuario necesita acceso programático? | Para | Mediante |
| --- | --- | --- |
| IAM | (Recomendado) Utilice las credenciales de la consola como credenciales temporales para firmar las solicitudes programáticas dirigidas al AWS CLI AWS SDKs, o. AWS APIs | Siga las instrucciones de la interfaz que desea utilizar: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/register-on-premises-instance-iam-user-arn.html) |
| Identidad del personal (Usuarios administrados en el IAM Identity Center) | Utilice credenciales temporales para firmar las solicitudes programáticas dirigidas al AWS CLI, AWS SDKs, o AWS APIs. | Siga las instrucciones de la interfaz que desea utilizar: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/register-on-premises-instance-iam-user-arn.html) |
| IAM | Utilice credenciales temporales para firmar las solicitudes programáticas dirigidas al AWS CLI AWS SDKs, o. AWS APIs | Siga las instrucciones de [Uso de credenciales temporales con AWS recursos](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_use-resources.html) de la Guía del usuario de IAM. |
| IAM | (No recomendado)Utilice credenciales de larga duración para firmar las solicitudes programáticas dirigidas al AWS CLI AWS SDKs, o. AWS APIs | Siga las instrucciones de la interfaz que desea utilizar: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/register-on-premises-instance-iam-user-arn.html) |
**Para obtener las credenciales (CLI)**
1. Ejecute el [list-access-keys](https://docs.aws.amazon.com/cli/latest/reference/iam/list-access-keys.html)comando, especifique el nombre del usuario de IAM (con la `--user-name` opción) y solicite únicamente la clave de acceso IDs (con las opciones `--query` y`--output`). Por ejemplo:
```
aws iam list-access-keys --user-name CodeDeployUser-OnPrem --query "AccessKeyMetadata[*].AccessKeyId" --output text
```
1. Si no aparece ninguna tecla en el resultado o solo aparece información sobre una tecla en el resultado, [create-access-key](https://docs.aws.amazon.com/cli/latest/reference/iam/create-access-key.html)ejecute el comando y especifique el nombre del usuario de IAM (con la `--user-name` opción):
```
aws iam create-access-key --user-name CodeDeployUser-OnPrem
```
En la salida de la llamada al comando **create-access-key**, anote el valor de los campos `AccessKeyId` y `SecretAccessKey`. Necesitará esta información en [Paso 4: Añadir un archivo de configuración a la instancia en las instalaciones](#register-on-premises-instance-iam-user-arn-4).
**importante**
Esta será la única vez que tendrá acceso a la clave de acceso secreta. Si olvida o pierde el acceso a esta clave de acceso secreta, tendrá que generar una nueva siguiendo los pasos de [Paso 3: Obtener las credenciales del usuario de IAM](#register-on-premises-instance-iam-user-arn-3).
1. Si ya hay dos claves de acceso en la lista, debe eliminar una de ellas. Para ello, [delete-access-key](https://docs.aws.amazon.com/cli/latest/reference/iam/delete-access-key.html)ejecute el comando y especifique el nombre del usuario de IAM (con la `--user-name` opción) y el ID de la clave de acceso que desee eliminar (con la `--access-key-id` opción). A continuación, llame al comando **create-access-key**, como se ha descrito anteriormente en este paso. A continuación se muestra un ejemplo de cómo llamar al comando **delete-access-key**:
```
aws iam delete-access-key --user-name CodeDeployUser-OnPrem --access-key-id access-key-ID
```
**importante**
Si llama al comando **delete-access-key** para eliminar una de estas claves de acceso, y una instancia en las instalaciones ya está utilizando esta clave de acceso como se describe en [Paso 4: Añadir un archivo de configuración a la instancia en las instalaciones](#register-on-premises-instance-iam-user-arn-4), tendrá que volver a seguir las instrucciones de [Paso 4: Añadir un archivo de configuración a la instancia en las instalaciones](#register-on-premises-instance-iam-user-arn-4) para especificar otro ID de clave de acceso y otra clave de acceso secreta asociada a este usuario de IAM. De lo contrario, todas las implementaciones de esa instancia on-premises pueden quedarse bloqueadas en un estado pendiente perpetuo o producir errores.
**Para obtener las credenciales (consola)**
1.
1. Abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Si la lista de usuarios no se muestra, en el panel de navegación, elija **Users**.
1. En la lista de usuarios, busque y elija el nombre del usuario de IAM que creó en [Paso 1: Crear un usuario de IAM para la instancia en las instalaciones](#register-on-premises-instance-iam-user-arn-1).
1. En la pestaña **Security credentials**, si en la lista no figura ninguna clave o si figura una sola una clave, seleccione **Create access key**.
Si se muestran dos claves de acceso, debe eliminar una de ellas. Elija **Delete** junto a una de las claves de acceso y luego seleccione **Create access key**.
**importante**
Si elige **Eliminar** junto a una de estas claves de acceso, y una instancia en las instalaciones ya está utilizando esta clave de acceso como se describe en [Paso 4: Añadir un archivo de configuración a la instancia en las instalaciones](#register-on-premises-instance-iam-user-arn-4), tendrá que volver a seguir las instrucciones de [Paso 4: Añadir un archivo de configuración a la instancia en las instalaciones](#register-on-premises-instance-iam-user-arn-4) para especificar otro ID de clave de acceso y otra clave de acceso secreta asociada a este usuario de IAM. De lo contrario, las implementaciones de esa instancia on-premises pueden quedarse bloqueadas en un estado pendiente perpetuo o producir errores.
1. Elija **Show** y anote el ID de la clave de acceso y la clave de acceso secreta. Necesitará esta información para el siguiente paso. Como alternativa, puede elegir **Download .csv file** para guardar una copia del ID de la clave de acceso y la clave de acceso secreta.
**importante**
A menos que anote o descargue las credenciales, esta será la única vez que tendrá acceso a la clave de acceso secreta. Si olvida o pierde el acceso a esta clave de acceso secreta, tendrá que generar una nueva siguiendo los pasos de [Paso 3: Obtener las credenciales del usuario de IAM](#register-on-premises-instance-iam-user-arn-3).
1. Seleccione **Cerrar** para volver a la *IAM User Name* página **Usuarios >**.
## Paso 4: Añadir un archivo de configuración a la instancia en las instalaciones
Añada un archivo de configuración a la instancia on-premises, utilizando los permisos raíz o de administrador. Este archivo de configuración se utilizará para declarar las credenciales de usuario de IAM y la AWS región de destino para la que se utilizará. CodeDeploy El archivo debe añadirse a una ubicación específica de la instancia on-premises. El archivo debe incluir el ARN del usuario de IAM, el ID de clave secreta, la clave de acceso secreta y la AWS región de destino. Este archivo debe seguir un formato específico.
1. Cree un archivo denominado `codedeploy.onpremises.yml` (si se trata de una instancia en las instalaciones de Ubuntu Server o RHEL) o `conf.onpremises.yml` (en el caso de una instancia en las instalaciones de Windows) en la siguiente ubicación de la instancia en las instalaciones:
+ Para Ubuntu Server: `/etc/codedeploy-agent/conf`
+ Para Windows Server: `C:\ProgramData\Amazon\CodeDeploy`
1. Utilice un editor de texto para añadir la siguiente información al archivo `codedeploy.onpremises.yml` o `conf.onpremises.yml` recién creado:
```
---
aws_access_key_id: secret-key-id
aws_secret_access_key: secret-access-key
iam_user_arn: iam-user-arn
region: supported-region
```
Donde:
+ *secret-key-id*es la ID de clave secreta del usuario de IAM correspondiente que anotó en o. [Paso 1: Crear un usuario de IAM para la instancia en las instalaciones](#register-on-premises-instance-iam-user-arn-1) [Paso 3: Obtener las credenciales del usuario de IAM](#register-on-premises-instance-iam-user-arn-3)
+ *secret-access-key*es la clave de acceso secreta del usuario de IAM correspondiente que anotó en [Paso 1: Crear un usuario de IAM para la instancia en las instalaciones](#register-on-premises-instance-iam-user-arn-1) o. [Paso 3: Obtener las credenciales del usuario de IAM](#register-on-premises-instance-iam-user-arn-3)
+ *iam-user-arn*es el ARN del usuario de IAM que indicó anteriormente. [Paso 1: Crear un usuario de IAM para la instancia en las instalaciones](#register-on-premises-instance-iam-user-arn-1)
+ *supported-region*es el identificador de una región compatible con la ubicación de CodeDeploy CodeDeploy las aplicaciones, los grupos de implementación y las revisiones de las aplicaciones (por ejemplo,`us-west-2`). Para obtener una lista de regiones, consulte [Regiones y puntos de conexión](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) en la *Referencia general de AWS*.
**importante**
Si eligió **Delete** junto a una de las claves de acceso en [Paso 3: Obtener las credenciales del usuario de IAM](#register-on-premises-instance-iam-user-arn-3), y su instancia en las instalaciones ya está utilizando el ID de la clave de acceso y la clave de acceso secreta asociados, tendrá que seguir las instrucciones de [Paso 4: Añadir un archivo de configuración a la instancia en las instalaciones](#register-on-premises-instance-iam-user-arn-4) para especificar otro ID de clave de acceso y otra clave de acceso secreta asociados a este usuario de IAM. De lo contrario, todas las implementaciones de su instancia on-premises pueden quedarse bloqueadas en un estado pendiente perpetuo o producir errores.
## Paso 5: Instalar y configurar el AWS CLI
Instale y configure AWS CLI la instancia local. (Se AWS CLI usará [Paso 7: Instalar el CodeDeploy agente](#register-on-premises-instance-iam-user-arn-7) para descargar e instalar el CodeDeploy agente en la instancia local).
1. Para instalarlo AWS CLI en la instancia local, siga las instrucciones de la [Guía del AWS CLI*AWS Command Line Interface usuario* sobre cómo configurarlo](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-set-up.html).
**nota**
CodeDeploy los comandos para trabajar con instancias locales estuvieron disponibles en la versión 1.7.19 de. AWS CLI Si AWS CLI ya tienes una versión de la instalada, puedes comprobar su versión llamando. **aws --version**
1. Para configurar AWS CLI la instancia local, sigue las instrucciones de [Configuración de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html) *Guía del AWS Command Line Interface usuario*.
**importante**
Al configurar AWS CLI (por ejemplo, mediante una llamada al **aws configure** comando), asegúrese de especificar el ID de clave secreta y la clave de acceso secreta de un usuario de IAM que tenga, como mínimo, los siguientes permisos de AWS acceso además de los permisos de acceso especificados en la. [Requisitos previos para configurar una instancia en las instalaciones](instances-on-premises-prerequisites.md) Esto le permite descargar e instalar el CodeDeploy agente en la instancia local:
****
```
{
"Version":"2012-10-17",
"Statement" : [
{
"Effect" : "Allow",
"Action" : [
"codedeploy:*"
],
"Resource" : "*"
},
{
"Effect" : "Allow",
"Action" : [
"s3:Get*",
"s3:List*"
],
"Resource" : [
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:s3:::amzn-s3-demo-bucket1/*"
]
}
]
}
```
****
```
{
"Version":"2012-10-17",
"Statement" : [
{
"Effect" : "Allow",
"Action" : [
"codedeploy:*"
],
"Resource" : "*"
},
{
"Effect" : "Allow",
"Action" : [
"s3:Get*",
"s3:List*"
],
"Resource" : [
"*"
]
}
]
}
```
Estos permisos de acceso se pueden asignar al usuario de IAM que creó en [Paso 1: Crear un usuario de IAM para la instancia en las instalaciones](#register-on-premises-instance-iam-user-arn-1) o a otro usuario de IAM. Para asignar estos permisos a un usuario de IAM, siga las instrucciones de [Paso 1: Crear un usuario de IAM para la instancia en las instalaciones](#register-on-premises-instance-iam-user-arn-1), utilizando estos permisos de acceso en lugar de los indicados en ese paso.
## Paso 6: Defina la variable de AWS\$1REGION entorno (solo en Ubuntu Server y RHEL)
Si no ejecuta Ubuntu Server o RHEL en su instancia en las instalaciones, omita este paso y vaya directamente a [Paso 7: Instalar el CodeDeploy agente](#register-on-premises-instance-iam-user-arn-7).
Instale el CodeDeploy agente en una instancia local de Ubuntu Server o RHEL y habilite la instancia para que actualice el CodeDeploy agente cada vez que haya una nueva versión disponible. Para ello, tiene que establecer en la instancia la variable de entorno `AWS_REGION` en el identificador de una de las regiones admitidas por CodeDeploy. Le recomendamos que establezca el valor en la región en la que se encuentran CodeDeploy las aplicaciones, los grupos de implementación y las revisiones de las aplicaciones (por ejemplo,`us-west-2`). Para obtener una lista de regiones, consulte [Regiones y puntos de conexión](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) en la *Referencia general de AWS*.
Para establecer la variable de entorno, llame al siguiente comando desde el terminal:
```
export AWS_REGION=supported-region
```
Dónde *supported-region* está el identificador de la región (por ejemplo,`us-west-2`).
## Paso 7: Instalar el CodeDeploy agente
Instale el CodeDeploy agente en la instancia local:
+ Si se trata de una instancia en las instalaciones de Ubuntu Server, siga las instrucciones de [Instale el CodeDeploy agente para Ubuntu Server](codedeploy-agent-operations-install-ubuntu.md) y después vuelva a esta página.
+ Si se trata de una instancia en las instalaciones de RHEL, siga las instrucciones de [Instalar el CodeDeploy agente para Amazon Linux o RHEL](codedeploy-agent-operations-install-linux.md) y después vuelva a esta página.
+ Si se trata de una instancia en las instalaciones de Windows Server, siga las instrucciones de [Instale el CodeDeploy agente para Windows Server](codedeploy-agent-operations-install-windows.md) y después vuelva a esta página.
## Paso 8: registre la instancia local con CodeDeploy
En las instrucciones de este paso se da por supuesto que va a registrar la instancia on-premises desde la propia instancia on-premises. Puede registrar una instancia local desde un dispositivo o instancia independiente que la tenga AWS CLI instalada y configurada, tal y como se describe en. [Paso 5: Instalar y configurar el AWS CLI](#register-on-premises-instance-iam-user-arn-5)
AWS CLI Utilícela para registrar la instancia local con el CodeDeploy fin de utilizarla en las implementaciones.
1. Para poder usar el AWS CLI, necesitará el ARN de usuario del usuario de IAM en el que lo creó. [Paso 1: Crear un usuario de IAM para la instancia en las instalaciones](#register-on-premises-instance-iam-user-arn-1) Si aún no tiene el ARN de usuario, llame al comando [get-user](https://docs.aws.amazon.com/cli/latest/reference/iam/get-user.html), especificando el nombre del usuario de IAM (con la opción `--user-name`) y consultando únicamente el ARN de usuario (con las opciones `--query` y `--output`):
```
aws iam get-user --user-name CodeDeployUser-OnPrem --query "User.Arn" --output text
```
1. Ejecute el comando [register-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/register-on-premises-instance.html) especificando lo siguiente:
+ Un nombre que identifique de manera única la instancia en las instalaciones (con la opción `--instance-name`).
**importante**
Para ayudarle a identificar la instancia on-premises, especialmente a efectos de depuración, recomendamos encarecidamente que especifique un nombre que se asigne a algunas características exclusivas de la instancia on-premises (por ejemplo, el número de serie o un identificador de recurso interno, si procede). Si especifica una dirección MAC como nombre, tenga en cuenta que las direcciones MAC contienen caracteres CodeDeploy no permitidos, como dos puntos (`:`). Para obtener una lista de los caracteres permitidos, consulte [CodeDeploy cuotas](limits.md).
+ El ARN del usuario de IAM que creó en [Paso 1: Crear un usuario de IAM para la instancia en las instalaciones](#register-on-premises-instance-iam-user-arn-1) (con la opción `--iam-user-arn`).
Por ejemplo:
```
aws deploy register-on-premises-instance --instance-name AssetTag12010298EX --iam-user-arn arn:aws:iam::444455556666:user/CodeDeployUser-OnPrem
```
## Paso 9: Etiquetar la instancia en las instalaciones
Puede usar la consola AWS CLI o la CodeDeploy consola para etiquetar la instancia local. (CodeDeployusa etiquetas de instancias locales para identificar los objetivos de implementación durante una implementación).
**Para etiquetar la instancia en las instalaciones (CLI)**
+ Llama al comando [add-tags-to-on-premises-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/add-tags-to-on-premises-instances.html) y especifica:
+ El nombre que identifica de manera única la instancia on-premises (con la opción `--instance-names`).
+ El nombre de la clave de etiqueta y el valor de etiqueta de la instancia on-premises que desea utilizar (con la opción `--tags`). Debe especificar un nombre y un valor. CodeDeploy no permite etiquetas de instancias locales que solo tengan valores.
Por ejemplo:
```
aws deploy add-tags-to-on-premises-instances --instance-names AssetTag12010298EX --tags Key=Name,Value=CodeDeployDemo-OnPrem
```
**Para etiquetar la instancia on-premises (consola)**
1. Inicia sesión Consola de administración de AWS y abre 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 CodeDeploy menú, selecciona Instancias locales**.**
1. En la lista de instancias on-premises, elija la flecha situada junto a la instancia on-premises que desea etiquetar.
1. En la lista de etiquetas, seleccione o introduzca la clave y el valor que desee para la etiqueta. Cuando introduzca la clave y el valor de la etiqueta, aparecerá otra fila. Puede repetir esta acción para un máximo de 10 etiquetas. Para quitar una etiqueta, elija el icono de eliminación (![\[The delete icon.\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/images/delete-triggers-x.png)).
1. Después de añadir las etiquetas, seleccione **Update Tags**.
## Paso 10: Implementar revisiones de aplicaciones en la instancia en las instalaciones
Ahora está listo para implementar revisiones de aplicaciones en la instancia on-premises registrada y etiquetada.
La implementación de revisiones de aplicaciones en instancias en las instalaciones es similar a la implementación de revisiones de aplicaciones en instancias de Amazon EC2. Para obtener instrucciones, consulte [Cree una implementación con CodeDeploy](deployments-create.md). Estas instrucciones incluyen un enlace a los requisitos previos, incluida la creación de una aplicación, la creación de un grupo de implementaciones y la preparación de la revisión de una aplicación. Si necesita una revisión de una aplicación sencilla para implementar, puede crear la que se describe en [Paso 2: Crear una revisión de aplicación de ejemplo](tutorials-on-premises-instance-2-create-sample-revision.md) en el [Tutorial: Implemente una aplicación en una instancia local con CodeDeploy (Windows Server, Ubuntu Server o Red Hat Enterprise Linux)](tutorials-on-premises-instance.md).
**importante**
Si reutilizas un rol de CodeDeploy servicio como parte de la creación de un grupo de implementación dirigido a instancias locales, debes `Tag:get*` incluirlo en la `Action` parte de la declaración de política del rol de servicio. Para obtener más información, consulte [Paso 2: Crear un rol de servicio para CodeDeploy](getting-started-create-service-role.md).
## Paso 11: Hacer un seguimiento de las implementaciones en la instancia en las instalaciones
Después de implementar una revisión de una aplicación en instancias en las instalaciones registradas y etiquetadas, puede hacer un seguimiento del progreso de la implementación.
El seguimiento de las implementaciones en instancias en las instalaciones es similar al seguimiento de las implementaciones en instancias de Amazon EC2. Para obtener instrucciones, consulte [Ver detalles CodeDeploy de la implementación](deployments-view-details.md).
# Administrar las operaciones de instancias locales en CodeDeploy
Siga las instrucciones de esta sección para administrar las operaciones en las instancias locales después de haberlas registrado, por ejemplo CodeDeploy, para obtener más información sobre las instancias locales, quitarles etiquetas y desinstalarlas y anular su registro.
**Topics**
+ [Obtiene información acerca de una instancia en las instalaciones individual.](on-premises-instances-operations-view-details-single.md)
+ [Obtener información acerca de varias instancias en las instalaciones](on-premises-instances-operations-view-details-multiple.md)
+ [Eliminar manualmente las etiquetas de instancias en las instalaciones de una instancia](on-premises-instances-operations-remove-tags.md)
+ [Desinstale automáticamente el CodeDeploy agente y elimine el archivo de configuración de una instancia local](on-premises-instances-operations-uninstall-agent.md)
+ [Anulación automática del registro de una instancia en las instalaciones](on-premises-instances-operations-deregister-automatically.md)
+ [Anulación manual del registro de una instancia en las instalaciones](on-premises-instances-operations-deregister-manually.md)
# Obtiene información acerca de una instancia en las instalaciones individual.
En las instrucciones de [Ver detalles CodeDeploy de la implementación](deployments-view-details.md) se describe cómo obtener información acerca de una instancia en las instalaciones individual. Puedes usar la consola AWS CLI o la CodeDeploy consola para obtener más información sobre una única instancia local.
**Para obtener información acerca de una instancia en las instalaciones individual (CLI)**
+ Realice una llamada al comando [get-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/get-on-premises-instance.html) especificando el nombre que identifica la instancia on-premises de forma exclusiva, con la opción `--instance-name`:
```
aws deploy get-on-premises-instance --instance-name AssetTag12010298EX
```
**Para obtener información acerca de una instancia en las instalaciones individual (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. En el panel de navegación, expanda **Implementar** y elija **Instancias en las instalaciones**.
1. En la lista de instancias en las instalaciones, elija el nombre de una instancia en las instalaciones para ver sus detalles.
# Obtener información acerca de varias instancias en las instalaciones
En las instrucciones de [Ver detalles CodeDeploy de la implementación](deployments-view-details.md) se describe cómo obtener información acerca de instancias en las instalaciones. Puedes usar la consola AWS CLI o la CodeDeploy consola para obtener más información sobre las instancias locales.
**Para obtener información acerca de varias instancias en las instalaciones (CLI)**
1. Para obtener una lista de nombres de instancias on-premises, realice una llamada al comando [list-on-premises-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-on-premises-instances.html) en la que se especifique:
+ Si obtener información acerca de todas instancias on-premises registradas o cuyos registros se hayan anulado, con las opciones `--registration-status` y `Registered` o `Deregistered`, respectivamente. Si omite este paso, se devolverán tanto los nombres de instancias on-premises registrados como aquellos cuyos registros se hayan anulado.
+ Si obtener solo información acerca de las instancias on-premises con etiquetas específicas de instancia on-premises, con la opción `--tag-filters`. Especifique `Key`, `Value`y `Type`, que deberá ser `KEY_AND_VALUE`, para cada etiqueta de instancia on-premises. Separe las etiquetas de las instancias on-premises con espacios entre cada conjunto de `Key`, `Value`y `Type`.
Por ejemplo:
```
aws deploy list-on-premises-instances --registration-status Registered --tag-filters Key=Name,Value=CodeDeployDemo-OnPrem,Type=KEY_AND_VALUE Key=Name,Value=CodeDeployDemo-OnPrem-Beta,Type=KEY_AND_VALUE
```
1. Para obtener información más detallada, ejecuta el comando [batch-get-on-premises-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/batch-get-on-premises-instances.html), con los nombres de las instancias locales (con la `--instance-names` opción):
```
aws deploy batch-get-on-premises-instances --instance-names AssetTag12010298EX AssetTag09920444EX
```
**Para obtener información acerca de varias instancias en las instalaciones (consola)**
1. [Inicia sesión en la CodeDeploy consola Consola de administración de AWS y ábrela 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 elija **Instancias en las instalaciones**.
Se mostrará Información acerca de las instancias on-premises.
# Eliminar manualmente las etiquetas de instancias en las instalaciones de una instancia
Por lo general, una etiqueta de instancia en las instalaciones se elimina de dicha instancia cuando deja de usarse o en caso de querer eliminar la instancia en las instalaciones del grupo de implementación que la utiliza. Puedes usar la consola AWS CLI o la AWS CodeDeploy consola para eliminar etiquetas de instancias locales de las instancias locales.
No necesita eliminar las etiquetas de instancias on-premises desde una instancia on-premises antes anular su registro.
Eliminar las etiquetas de instancias on-premises de una instancia on-premises no anula su registro. No desinstala el CodeDeploy agente de la instancia. No elimina el archivo de configuración de la instancia, ni desinstala el usuario de IAM asociado a la instancia.
Para anular el registro de una instancia on-premises automáticamente, consulte [Anulación automática del registro de una instancia en las instalaciones](on-premises-instances-operations-deregister-automatically.md).
Para anular el registro de una instancia on-premises manualmente, consulte [Anulación manual del registro de una instancia en las instalaciones](on-premises-instances-operations-deregister-manually.md).
Para desinstalar automáticamente el CodeDeploy agente y eliminar el archivo de configuración de la instancia local, consulte[Desinstale automáticamente el CodeDeploy agente y elimine el archivo de configuración de una instancia local](on-premises-instances-operations-uninstall-agent.md).
Para desinstalar manualmente solo el CodeDeploy agente de la instancia local, consulte. [Gestión de las operaciones CodeDeploy de los agentes](codedeploy-agent-operations.md)
Para eliminar manualmente el usuario de IAM asociado, consulte [Eliminación de un usuario de IAM de su cuenta de AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_DeletingUserFromAccount.html).
**Para eliminar etiquetas de instancias on-premises de una instancia on-premises (CLI)**
+ Llame a las instancias [remove-tags-from-on-premises-instances y especifique:](https://docs.aws.amazon.com/cli/latest/reference/deploy/remove-tags-from-on-premises-instances.html)
+ Los nombres que identifican de manera única las instancias on-premises, con la opción `--instance-names`.
+ Los nombres y valores de las etiquetas que desea quitar, con la opción `--tags`.
Por ejemplo:
```
aws deploy remove-tags-from-on-premises-instances --instance-names AssetTag12010298EX --tags Key=Name,Value=CodeDeployDemo-OnPrem
```
**Para eliminar etiquetas de instancias en las instalaciones de una instancia en las instalaciones (consola)**
1. [Inicie sesión en /codedeploy Consola de administración de AWS y abra la CodeDeploy consola. https://console.aws.amazon.com](https://console.aws.amazon.com/codedeploy)
**nota**
Inicie sesión con el mismo usuario que configuró en [Empezar con CodeDeploy](getting-started-codedeploy.md).
1. En el panel de navegación, expanda **Implementar** y elija **Instancias en las instalaciones**.
1. En la lista de instancias en las instalaciones, elija el nombre de la instancia en las instalaciones cuyas etiquetas desea eliminar.
1. En la sección **Tags (Etiquetas)**, elija **Remove (Quitar)** junto a cada etiqueta que desee quitar.
1. Después de eliminar las etiquetas, seleccione **Update tags**.
# Desinstale automáticamente el CodeDeploy agente y elimine el archivo de configuración de una instancia local
Por lo general, se desinstala el CodeDeploy agente y se elimina el archivo de configuración de una instancia local cuando ya no se planea realizar la implementación en ella.
**nota**
La desinstalación automática del CodeDeploy agente y la eliminación del archivo de configuración de una instancia local no anulan el registro de una instancia local. Tampoco desvincula ninguna etiqueta de instancia on-premises asociada a la instancia on-premises, ni elimina el usuario de IAM asociado a la instancia en las instalaciones.
Para anular el registro de una instancia on-premises automáticamente, consulte [Anulación automática del registro de una instancia en las instalaciones](on-premises-instances-operations-deregister-automatically.md).
Para anular el registro de una instancia on-premises manualmente, consulte [Anulación manual del registro de una instancia en las instalaciones](on-premises-instances-operations-deregister-manually.md).
Para desvincular etiquetas asociadas a una instancia on-premises manualmente, consulte [Eliminar manualmente las etiquetas de instancias en las instalaciones de una instancia](on-premises-instances-operations-remove-tags.md).
Para desinstalar manualmente el CodeDeploy agente de la instancia local, consulte. [Gestión de las operaciones CodeDeploy de los agentes](codedeploy-agent-operations.md)
Para eliminar manualmente el usuario de IAM asociado, consulte [Eliminación de un usuario de IAM de su cuenta de AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_DeletingUserFromAccount.html).
Desde la instancia local, utilice el AWS CLI para llamar al comando de [desinstalación](https://docs.aws.amazon.com/cli/latest/reference/deploy/uninstall.html).
Por ejemplo:
```
aws deploy uninstall
```
El comando **uninstall** hace lo siguiente:
1. Detiene el CodeDeploy agente en ejecución en la instancia local.
1. Desinstala el CodeDeploy agente de la instancia local.
1. Elimina el archivo de configuración de la instancia en las instalaciones. (Para Ubuntu Server y RHEL, es `/etc/codedeploy-agent/conf`/`codedeploy.onpremises.yml`. Para Windows Server, es `C:\ProgramData\Amazon\CodeDeploy`\$1`conf.onpremises.yml`.)
# Anulación automática del registro de una instancia en las instalaciones
Por lo general, si ya no tiene pensado implementar la instancia on-premises, debe anular su registro. Al anular el registro de una instancia on-premises, dicha instancia deja de incluirse en cualquier implementación, incluso si forma parte de las etiquetas de instancias on-premises de un grupo de implementaciones. Puede utilizarla para anular el registro de AWS CLI las instancias locales.
**nota**
No puedes usar la CodeDeploy consola para anular el registro de una instancia local. Además, la anulación del registro de una instancia en las instalaciones elimina aquellas etiquetas que estén asociadas a la instancia en las instalaciones. No desinstala el CodeDeploy agente de la instancia local. ni elimina el archivo de configuración de instancia on-premises de dicha instancia.
Para usar la CodeDeploy consola para realizar algunas (pero no todas) de las actividades de esta sección, consulte la sección de CodeDeploy consolas de[Anulación manual del registro de una instancia en las instalaciones](on-premises-instances-operations-deregister-manually.md).
Para desvincular etiquetas asociadas a una instancia on-premises manualmente, consulte [Eliminar manualmente las etiquetas de instancias en las instalaciones de una instancia](on-premises-instances-operations-remove-tags.md).
Para desinstalar automáticamente el CodeDeploy agente y eliminar el archivo de configuración de la instancia local, consulte[Desinstale automáticamente el CodeDeploy agente y elimine el archivo de configuración de una instancia local](on-premises-instances-operations-uninstall-agent.md).
Para desinstalar manualmente solo el CodeDeploy agente de la instancia local, consulte. [Gestión de las operaciones CodeDeploy de los agentes](codedeploy-agent-operations.md)
Use el comando deregister AWS CLI para llamar al comando [deregister](https://docs.aws.amazon.com/cli/latest/reference/deploy/deregister.html) y especifique:
+ El nombre que identifica de forma exclusiva a la instancia local CodeDeploy (con la `--instance-name` opción).
+ De manera opcional, si desea eliminar el usuario de IAM asociado a la instancia en las instalaciones. El comportamiento predeterminado es eliminar al usuario de IAM. Si no desea eliminar el usuario de IAM asociado a la instancia on-premises, especifique la opción `--no-delete-iam-user` en el comando.
+ De forma opcional, la AWS región en la que se registró la instancia local CodeDeploy (con la `--region` opción). Debe ser una de las regiones admitidas que se encuentran en la lista de [Regiones y puntos de enlace](https://docs.aws.amazon.com/general/latest/gr/rande.html#codedeploy_region) de la *Referencia general de AWS* (como, por ejemplo, `us-west-2`). Si no se especifica esta opción, se utilizará la AWS región predeterminada asociada al usuario de IAM que realiza la llamada.
Ejemplo que anula el registro de una instancia y elimina al usuario:
```
aws deploy deregister --instance-name AssetTag12010298EX --region us-west-2
```
Ejemplo que anula el registro de una instancia y no elimina al usuario:
```
aws deploy deregister --instance-name AssetTag12010298EX --no-delete-iam-user --region us-west-2
```
El comando **deregister** hace lo siguiente:
1. Anula el registro de la instancia local con. CodeDeploy
1. Si se especifica, elimina el usuario de IAM asociado a la instancia en las instalaciones.
Después de cancelar el registro de una instancia en las instalaciones:
+ Deja de aparecer en la consola inmediatamente.
+ Puede crear otra instancia con el mismo nombre inmediatamente.
Si este comando encuentra algún error, aparece un mensaje en el que se describe cómo realizar manualmente los pasos faltantes. En caso contrario, aparece un mensaje de confirmación en el que se describe cómo realizar una llamada al comando **uninstall**.
# Anulación manual del registro de una instancia en las instalaciones
Por lo general, si ya no tiene pensado implementar la instancia on-premises, debe anular su registro. Se usa para anular el registro manual AWS CLI de las instancias locales.
Al anular manualmente el registro de una instancia local, no se desinstala el agente. CodeDeploy No elimina el archivo de configuración de la instancia, ni desinstala el usuario de IAM asociado a la instancia. ni elimina etiquetas asociadas a la instancia.
Para desinstalar automáticamente el CodeDeploy agente y eliminar el archivo de configuración de la instancia local, consulte. [Desinstale automáticamente el CodeDeploy agente y elimine el archivo de configuración de una instancia local](on-premises-instances-operations-uninstall-agent.md)
Para desinstalar manualmente solo el CodeDeploy agente, consulte[Gestión de las operaciones CodeDeploy de los agentes](codedeploy-agent-operations.md).
Para eliminar manualmente el usuario de IAM asociado, consulte [Eliminación de un usuario de IAM de su cuenta de AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/Using_DeletingUserFromAccount.html).
Para eliminar manualmente solo las etiquetas de instancias en las instalaciones asociadas, consulte [Eliminar manualmente las etiquetas de instancias en las instalaciones de una instancia](on-premises-instances-operations-remove-tags.md).
+ Realice una llamada al comando [deregister-on-premises-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/deregister-on-premises-instance.html) especificando el nombre que identifica la instancia on-premises de forma exclusiva, con la opción `--instance-name`:
```
aws deploy deregister-on-premises-instance --instance-name AssetTag12010298EX
```
Después de cancelar el registro de una instancia en las instalaciones:
+ Deja de aparecer en la consola inmediatamente.
+ Puede crear otra instancia con el mismo nombre inmediatamente.
# Visualización de los detalles de la instancia con CodeDeploy
Puede utilizar la consola de CodeDeploy, la AWS CLI o las API de CodeDeploy para ver detalles sobre las instancias que se utilizan en una implementación.
Para obtener más información sobre el uso de las acciones de la API de CodeDeploy para ver instancias, consulte [GetDeploymentInstance](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_GetDeploymentInstance.html), [ListDeploymentInstances](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_ListDeploymentInstances.html) y [ListOnPremisesInstances](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_ListOnPremisesInstances.html).
**Topics**
+ [Visualización de los detalles de la instancia (consola)](#instances-view-details-console)
+ [Visualización de los detalles de la instancia (CLI)](#instances-view-details-cli)
## Visualización de los detalles de la instancia (consola)
Para ver los detalles de la instancia:
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. Para ver los detalles de la implementación, elija el ID de implementación para la instancia.
1. Puede ver todas las instancias en la sección **Instance activity (Actividad de instancia)** de la página de la implementación.
1. Para ver información acerca de los eventos del ciclo de vida de la implementación individual de una instancia, en la página de detalles de la implementación, en la columna **Events**, elija **View events**.
**nota**
Si se muestra **Failed** en cualquiera de los eventos del ciclo de vida, en la página de detalles de la instancia, elija **View logs**, **View in EC2** o ambas opciones. Puede encontrar consejos de solución de problemas en [Solución de problemas de instancias](troubleshooting-ec2-instances.md).
1. Si desea ver más información sobre una instancia de Amazon EC2, elija el ID de la instancia en la columna **ID de instancia**.
## Visualización de los detalles de la instancia (CLI)
Si desea utilizar la AWS CLI para ver los detalles de la instancia, ejecute el comando `get-deployment-instance` o al comando `list-deployment-instances`.
Para ver los detalles de una sola instancia, llame al comando [get-deployment-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/get-deployment-instance.html), especificando:
+ El ID de implementación único. Para obtener el ID de implementación, llame al comando [list-deployments](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployments.html).
+ El ID de instancia único. Para obtener el ID de instancia, llame al comando [list-deployment-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployment-instances.html).
Para ver una lista de los ID de instancias que se utilizan en una implementación, llame al comando [list-deployment-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployment-instances.html), especificando:
+ El ID de implementación único. Para obtener el ID de implementación, llame al comando [list-deployments](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployments.html).
+ Si lo prefiere, puede incluir únicamente los ID de instancia específicos por su estado de implementación. (Si no se especifican, se enumerarán todos los ID de instancia coincidentes, independientemente de su estado de implementación).
# CodeDeploy estado de la instancia
CodeDeploy supervisa el estado de las instancias de un grupo de implementación. Produce un error en las implementaciones si el número de instancias en buen estado es inferior al número de instancias en buen estado que se han especificado para el grupo de implementaciones durante una implementación. Por ejemplo, si el 85% de las instancias deben estar en buen estado durante una implementación y el grupo de implementación contiene 10 instancias, toda la implementación dará un error aunque solo una única instancia produzca un error. Esto se debe a que cuando se desconecta una instancia para que se pueda instalar la última revisión de la aplicación, el número de instancias en buen estado ya está al 90%. Al haber una instancia con error y otra instancia desconectada, solo el 80% de las instancias se encuentran en buen estado y disponibles. CodeDeploy producirá un error en toda la implementación.
Es importante recordar que debe cumplirse lo siguiente para que la implementación global tenga éxito:
+ CodeDeploy puede realizar la implementación en cada instancia de la implementación.
+ La implementación debe tener éxito en una instancia como mínimo. Esto significa que, aunque el valor mínimo de hosts en buen estado sea 0, la implementación debe realizarse correctamente en una instancia como mínimo (es decir, al menos una instancia debe estar en buen estado) para que la implementación global se realice correctamente.
**Topics**
+ [Estado](#instances-health-status)
+ [Acerca del número mínimo de instancias en buen estado](#minimum-healthy-hosts)
+ [Acerca del número mínimo de instancias en buen estado por zona de disponibilidad](#minimum-healthy-hosts-az)
## Estado
CodeDeploy asigna dos valores de estado a cada instancia: el estado de *revisión y el estado de la* *instancia*.
Estado de revisión
El estado de revisión se basa en la revisión de aplicación instalada actualmente en la instancia. Tiene los siguientes valores de estado:
+ Current: la revisión instalada en la instancia coincide con la revisión de la última implementación correcta del grupo de implementación.
+ Old: la revisión instalada en la instancia coincide con una versión anterior de la aplicación.
+ Unknown: la revisión de la aplicación no se ha instalado correctamente en la instancia.
Estado de la instancia
El estado de la instancia se basa en si las implementaciones en una instancia se han realizado correctamente. Tiene los siguientes valores:
+ Healthy: la última implementación en la instancia se realizó correctamente.
+ Unhealthy: el intento de implementar una revisión en la instancia dio un error o aún no se ha implementado una revisión en la instancia.
CodeDeploy utiliza el estado de las revisiones y el estado de las instancias para programar el despliegue en las instancias del grupo de implementación en el siguiente orden:
1. Estado de la instancia Unhealthy.
1. Estado de revisión Unknown.
1. Estado de revisión Old.
1. Estado de revisión Current.
Si toda la implementación se realiza correctamente, la revisión se actualiza y los valores de estado del grupo de implementaciones se actualizan para reflejar la última implementación.
+ Todas las instancias actuales que tenían una implementación satisfactoria siguen vigentes. De lo contrario, pasan a tener el estado Unknown.
+ Todas las instancias Old o Unknown que tenían una implementación satisfactoria siguen vigentes. De lo contrario, pasan a tener el estado Old o Unknown.
+ Todas las instancias Healthy que tenían una implementación satisfactoria siguen en buen estado. De lo contrario, pasan a tener el estado Unhealthy.
+ Todas las instancias Unhealthy que tenían una implementación satisfactoria pasan a tener el estado Healthy. De lo contrario, permanecen con el estado Unhealthy.
Si se produce un error en toda la implementación o si se detiene la implementación:
+ Cada instancia en la que se CodeDeploy intentó implementar la revisión de la aplicación tiene el estado de la instancia establecido en buen estado o en mal estado, dependiendo de si el intento de implementación de esa instancia se realizó correctamente o no.
+ Cada instancia en la que CodeDeploy no se intentó implementar la revisión de la aplicación conserva su valor de estado actual.
+ La revisión del grupo de implementación sigue siendo la misma.
## Acerca del número mínimo de instancias en buen estado
El número mínimo de instancias en buen estado necesarias se define como parte de la configuración de una implementación.
**importante**
Durante una blue/green implementación, la configuración de la implementación y el valor mínimo de hosts en buen estado se aplican a las instancias del entorno de reemplazo, no a las del entorno original. Sin embargo, cuando se cancela el registro de las instancias del entorno original en el balanceador de carga, toda la implementación se marca como errónea aunque solo haya una instancia original cuyo registro no se haya podido cancelar correctamente.
CodeDeploy proporciona tres configuraciones de implementación predeterminadas que suelen utilizar valores mínimos de host en buen estado:
| Nombre de configuración de la implementación predeterminada | Valor mínimo de hosts en buen estado predefinido |
| --- | --- |
| CodeDeployDefault.OneAtATime | 1 |
| CodeDeployDefault.HalfAtATime | 50% |
| CodeDeployDefault.AllAtOnce | 0 |
Encontrará más información acerca de las configuraciones de implementación predeterminadas en [Trabajar con configuraciones de implementación en CodeDeploy](deployment-configurations.md).
Puede crear configuraciones de implementación personalizadas CodeDeploy para definir sus propios valores de host mínimos en buen estado. Puede definir estos valores como números enteros o como porcentajes mediante las siguientes operaciones:
+ Como `minimum-healthy-hosts` cuando usa el [create-deployment-config](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment-config.html)comando en AWS CLI.
+ Como `Value` en el tipo de [MinimumHealthyHosts](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_MinimumHealthyHosts.html)datos de la CodeDeploy API.
+ Como `MinimumHealthyHosts` cuando se usa [AWS::CodeDeploy::DeploymentConfig](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codedeploy-deploymentconfig.html)en una CloudFormation plantilla.
CodeDeploy permite especificar un número mínimo de instancias en buen estado para la implementación con dos finalidades principales:
+ Para determinar si la implementación global se realizó correctamente o dio un error. La implementación se realiza correctamente si la revisión de la aplicación se implementó satisfactoriamente en al menos el número mínimo de instancias en buen estado.
+ Para determinar el número de instancias que deben estar en buen estado durante una implementación para que la implementación se pueda realizar correctamente.
Puede especificar el número mínimo de instancias en buen estado para su grupo de implementaciones como un número de instancias o como un porcentaje del total de instancias. Si especificas un porcentaje, al inicio de la implementación, CodeDeploy convierte el porcentaje en el número equivalente de instancias y redondea las instancias fraccionarias.
CodeDeploy realiza un seguimiento del estado de las instancias del grupo de implementación durante el proceso de implementación y utiliza el número mínimo especificado de instancias en buen estado para la implementación para determinar si se debe continuar con la implementación. El principio básico es que una implementación no debe provocar nunca que el número de instancias en buen estado sea inferior al número mínimo especificado. La única excepción a esta regla es cuando un grupo de implementaciones tiene inicialmente menos instancias en buen estado que el número mínimo especificado. En ese caso, el proceso de implementación no reduce el número de instancias en buen estado.
**nota**
CodeDeploy intentará implementarse en todas las instancias de un grupo de implementación, incluso en las que se encuentran actualmente en estado de parada. En el cálculo de hosts mínimos en buen estado, una instancia detenida tiene el mismo efecto que una instancia errónea. Para resolver los errores de implementación debido a demasiadas instancias detenidas, reinicie las instancias o cambie sus etiquetas para excluirlas del grupo de implementaciones.
CodeDeploy inicia el proceso de despliegue intentando implementar la revisión de la aplicación en las instancias en mal estado del grupo de despliegue. Por cada implementación correcta, CodeDeploy cambia el estado de la instancia a correcto y la agrega a las instancias en buen estado del grupo de implementación. CodeDeploy a continuación, compara el número actual de instancias en buen estado con el número mínimo especificado de instancias en buen estado.
+ Si la cantidad de instancias en buen estado es inferior o igual a la cantidad mínima especificada de instancias en buen estado, CodeDeploy cancela la implementación para garantizar que la cantidad de instancias en buen estado no disminuya con más implementaciones.
+ Si el número de instancias en buen estado es superior en al menos una al número mínimo especificado de instancias en buen estado, CodeDeploy implementa la revisión de la aplicación en el conjunto original de instancias en buen estado.
Si se produce un error en la implementación de una instancia en buen estado, CodeDeploy cambia el estado de la instancia a en mal estado. A medida que avanza la implementación, CodeDeploy actualiza el número actual de instancias en buen estado y lo compara con el número mínimo especificado de instancias en buen estado. Si el número de instancias en buen estado cae hasta el número mínimo especificado en algún momento del proceso de implementación, CodeDeploy se detiene la implementación. De este modo, se impide la posibilidad de que la próxima implementación produzca un error, haciendo que el número de instancias en buen estado sea inferior al número mínimo especificado.
**nota**
Asegúrese de que el número mínimo de instancias en buen estado que especifique sea inferior al número total de instancias del grupo de implementaciones. Si especifica un valor de porcentaje, recuerde que se redondeará. De lo contrario, cuando comience la implementación, el número de instancias en buen estado ya será inferior o igual que el número mínimo especificado de instancias en buen estado y CodeDeploy marcará toda la implementación como errónea.
CodeDeploy también utiliza el número mínimo especificado de instancias en buen estado y el número real de instancias en buen estado para determinar si se debe implementar la revisión de la aplicación en varias instancias y cómo hacerlo. De forma predeterminada, CodeDeploy implementa la revisión de la aplicación en tantas instancias como sea posible sin riesgo de que el número de instancias en buen estado caiga por debajo del número mínimo especificado de instancias en buen estado.
Para determinar el número de instancias que se deben implementar a la vez, CodeDeploy utilice el siguiente cálculo:
```
[total-hosts] - [minimum-healthy-hosts] =
[number-of-hosts-to-deploy-to-at-once]
```
Por ejemplo:
+ Si su grupo de implementación tiene 10 instancias y ha establecido el número mínimo de instancias en buen estado en 9, se CodeDeploy implementa una instancia a la vez.
+ Si su grupo de implementación tiene 10 instancias y ha establecido el número mínimo de instancias en buen estado en 3, se CodeDeploy despliega en 7 instancias al mismo tiempo en el primer lote y, después, en las 3 restantes en el segundo lote.
+ Si su grupo de implementación tiene 10 instancias y establece el número mínimo de instancias en buen estado en 0, se CodeDeploy despliega en 10 instancias al mismo tiempo.
**Ejemplos**
En los siguientes ejemplos se presupone que existe un grupo de implementaciones con 10 instancias.
Mínimo de instancias en buen estado: 95%
CodeDeploy redondea el número mínimo de instancias en buen estado hasta 10 instancias, lo que equivale al número de instancias en buen estado. Toda la implementación produce inmediatamente un error sin que se implemente la revisión en ninguna de las instancias.
Mínimo de instancias en buen estado: 9
CodeDeploy implementa la revisión en una instancia a la vez. Si la implementación en alguna de las instancias falla, se interrumpe CodeDeploy inmediatamente la implementación general, ya que el número de instancias en buen estado es igual al número mínimo de instancias en buen estado. La excepción a esta regla es que si se produce un error en la última instancia, la implementación se realiza correctamente.
CodeDeploy continúa la implementación, instancia por vez, hasta que alguna implementación falle o se complete la implementación general. Si las 10 implementaciones se realizan correctamente, el grupo de implementación tendrá ahora 10 instancias en buen estado.
Mínimo de instancias en buen estado: 8
CodeDeploy implementa la revisión en dos instancias a la vez. Si dos de estas implementaciones fallan, la implementación general fracasa CodeDeploy inmediatamente. La excepción a esta regla es que si la última instancia es la segunda instancia que da error, la implementación se realiza correctamente.
Mínimo de instancias en buen estado: 0
CodeDeploy implementa la revisión en todo el grupo de implementaciones a la vez. La implementación debe realizarse correctamente al menos en una instancia para que la implementación global se realice correctamente. Si hay 0 instancias en buen estado, la implementación no se realiza correctamente. Esto se debe al requisito de que, para considerar que una implementación global se ha realizado correctamente, al menos una instancia debe estar en buen estado cuando finalice la implementación global, incluso si el valor mínimo de instancias en buen estado es 0.
## Acerca del número mínimo de instancias en buen estado por zona de disponibilidad
**nota**
En esta sección se utilizan los términos *instancia* y *host* indistintamente para hacer referencia a las instancias de Amazon EC2.
Si va a realizar la implementación en instancias de varias [zonas de disponibilidad](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-regions-availability-zones.html#concepts-availability-zones), de forma opcional, puede habilitar la [zonal configuration](deployment-configurations-create.md#zonal-config) función, que CodeDeploy permite la implementación en una zona de disponibilidad a la vez.
Cuando esta función esté habilitada, se CodeDeploy asegurará de que la cantidad de hosts en buen estado se mantenga por encima de los valores de «hosts en buen estado mínimos por zona» *y* «hosts en buen estado». Si el número de hosts en buen estado cae por debajo de cualquiera de estos valores, CodeDeploy no se podrá realizar la implementación en todas las zonas de disponibilidad.
Para calcular la cantidad de hosts en los que realizar la implementación a la vez, CodeDeploy utiliza los valores de «número mínimo de hosts en buen estado por zona» y «número mínimo de hosts en buen estado». CodeDeploy utilizará el *menor* de los cálculos `[A]` y`[B]`, donde y dónde están: `[A]` `[B]`
```
[A] = [total-hosts] - [min-healthy-hosts] =
[number-of-hosts-to-deploy-to-at-once]
```
```
[B] = [total-hosts-per-AZ] - [min-healthy-hosts-per-AZ] =
[number-of-hosts-to-deploy-to-at-once-per-AZ]
```
Tras determinar el número de hosts en los que realizar el despliegue a la vez, se CodeDeploy despliega en los hosts en lotes de ese número, una zona de disponibilidad a la vez, con una pausa opcional (o «hora de cocción») entre las zonas.
**Ejemplo**
Si su implementación está configurada de la siguiente manera:
+ `[total-hosts]` es `200`
+ `[minimum-healthy-hosts]` es `160`
+ `[total-hosts-per-AZ]` es `100`
+ `[minimum-healthy-hosts-per-AZ]` es `50`
Entonces...
+ `[A]` = `200 - 160 = 40`
+ `[B]` = `100 - 50 = 50`
+ `40` es menor que `50`
Por lo tanto, CodeDeploy se implementará en los hosts a la vez. `40`
En este caso, la implementación se desglosa de la siguiente manera:
1. CodeDeploy se despliega en la primera zona de disponibilidad:
1. CodeDeploy se despliega en los primeros `40` hosts.
1. CodeDeploy se despliega en los siguientes `40` hosts.
1. CodeDeploy se despliega en los hosts restantes`20`.
La implementación en la primera zona de disponibilidad ya está completa.
1. (Opcional) CodeDeploy espera mientras se «hornea» el despliegue en la primera zona, según se define en la configuración de **duración del monitor** o **Añadir una duración del monitor para la primera** zona. Si no hay problemas, CodeDeploy continúa.
1. CodeDeploy se despliega en la segunda zona de disponibilidad:
1. CodeDeploy se despliega en los primeros `40` hosts.
1. CodeDeploy se despliega en los siguientes `40` hosts.
1. CodeDeploy se despliega en los hosts restantes`20`.
La implementación en la segunda y final zona de disponibilidad ya está completa.
Para obtener información sobre la característica de configuración de zonas y cómo especificar el número mínimo de instancias en buen estado por zona de disponibilidad, consulte [zonal configuration](deployment-configurations-create.md#zonal-config).