Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Tutorial: Implementación de una aplicación "Hello, World\$1" aplicación con CodeDeploy (Windows Server)
En este tutorial, implementa una única página web en una sola instancia Amazon EC2 de Windows Server que ejecuta Internet Information Services (IIS) como servidor web. Esta página web muestra un mensaje "Hello, World\$1".
¿No es lo que está buscando?
+ Para practicar la implementación en una instancia de Amazon EC2 de Amazon Linux o Red Hat Enterprise Linux (RHEL) en su lugar, consulte [Tutorial: Implementación WordPress en una instancia de Amazon EC2 (Amazon Linux o Red Hat Enterprise Linux y Linux, macOS o Unix)](tutorials-wordpress.md).
+ Para practicar la implementación en una instancia on-premises, consulte [Tutorial: Implemente una aplicación en una instancia local con CodeDeploy (Windows Server, Ubuntu Server o Red Hat Enterprise Linux)](tutorials-on-premises-instance.md).
Los pasos de este tutorial se presentan desde una perspectiva de Windows. Aunque puede completar la mayoría de estos pasos en un equipo local que ejecuta Linux, macOS o Unix, debe adaptar los pasos en los que se usan rutas de directorio basadas en Windows, como `c:\temp`. Además, si desea conectarse a la instancia de Amazon EC2, necesita una aplicación cliente que pueda conectarse mediante el Protocolo de escritorio remoto (RDP) a la instancia de Amazon EC2 que ejecuta Windows Server. (Windows incluye una aplicación cliente de conexión RDP de forma predeterminada).
Antes de empezar este tutorial, debe cumplir los requisitos previos, como configurar el usuario[Empezar con CodeDeploy](getting-started-codedeploy.md), instalar o actualizar el perfil de instancia de IAM y crear un perfil de instancia de IAM y un rol de servicio. AWS CLI
**Topics**
+ [Paso 1: Lanzar una instancia de Amazon EC2 de Windows Server](tutorials-windows-launch-instance.md)
+ [Paso 2: Configurar el contenido de origen para implementarlo en la instancia de Amazon EC2 de Windows Server](tutorials-windows-configure-content.md)
+ [Paso 3: Cargar la aplicación "Hello, World\$1" en Amazon S3](tutorials-windows-upload-application.md)
+ [Paso 4: Implementar la aplicación Hello World.](tutorials-windows-deploy-application.md)
+ [Paso 5: Actualizar y volver a implementar su aplicación "Hello, World\$1"](tutorials-windows-update-and-redeploy-application.md)
+ [Paso 6: Limpiar la aplicación de "Hello, World\$1" y sus recursos relacionados](tutorials-windows-clean-up.md)
# Paso 1: Lanzar una instancia de Amazon EC2 de Windows Server
Para implementar la aplicación Hello World CodeDeploy, necesita una instancia de Amazon EC2 que ejecute Windows Server.
Siga las instrucciones en [Cree una instancia de Amazon EC2 para CodeDeploy](instances-ec2-create.md). Cuando esté listo para asignar una etiqueta de instancia de Amazon EC2 a la instancia, asegúrese de especificar la clave de etiqueta **Name** y el valor de etiqueta **CodeDeployDemo**. (Si especifica otra clave u otro valor de etiqueta, las instrucciones de [Paso 4: Implementar la aplicación Hello World.](tutorials-windows-deploy-application.md) pueden producir resultados inesperados).
Una vez que haya lanzado la instancia de Amazon EC2, vuelva a esta página y continúe con la sección siguiente. No continúe en [Cree una aplicación con CodeDeploy](applications-create.md) como paso siguiente.
## Conexión con la instancia de Amazon EC2
Una vez lanzada la instancia de Amazon EC2, siga estas instrucciones para practicar la conexión a la instancia.
**nota**
En estas instrucciones se supone que está trabajando con Windows y con la aplicación cliente de conexión a escritorio de Windows. Para obtener más información, consulte [Conexión con la instancia de Windows mediante RDP](https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/connecting_to_windows_instance.html). Es posible que necesite adaptar estas instrucciones para otros sistemas operativos u otras aplicaciones cliente de conexión RDP.
1. Inicie sesión en la consola Amazon EC2 Consola de administración de AWS y ábrala en. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. En el panel de navegación, bajo **Instances**, elija **Instances**.
1. Busque su instancia de Windows Server en la lista y selecciónela.
1. Elija **Conectar**.
1. Elija **Obtener contraseña** y, a continuación, elija **Seleccionar archivo**.
1. Busque y seleccione el archivo de par de claves de la instancia de Amazon EC2 asociado a la instancia Amazon EC2 de Windows Server y, a continuación, elija **Abrir**.
1. Elija **Descifrar contraseña**. Apunte la contraseña que se muestra. La necesitará en el paso 10.
1. Elija **Download Remote Desktop File (Descargar archivo de escritorio remoto)** y abra el archivo.
1. Si se le pide conectarse a pesar de que el editor de la conexión remota no pueda identificarse, hágalo.
1. Escriba la contraseña que ha anotado en el paso 7 y continúe. (Si la aplicación cliente de conexión RDP solicita un nombre de usuario, escriba **Administrator**).
1. Si se le pide que se conecte a pesar de que la identidad del equipo remoto no pueda verificarse, hágalo.
1. Después de haberse conectado, se muestra el escritorio de la instancia de Amazon EC2 que ejecuta Windows Server.
1. Ahora puede desconectar de la instancia de Amazon EC2.
**aviso**
No interrumpa ni termine la instancia. De lo contrario, no CodeDeploy podrá realizar la implementación en ella.
## Adición de una regla de entrada que permite el tráfico HTTP a la instancia de Amazon EC2 de Windows Server
El siguiente paso confirma que la instancia de Amazon EC2 tiene un puerto HTTP abierto para que se pueda ver la página web implementada en la instancia de Amazon EC2 de Windows Server en un navegador.
1. Inicie sesión en la consola Amazon EC2 Consola de administración de AWS y ábrala en. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. Elija **Instancias** y, luego, elija su instancia.
1. En la pestaña **Descripción**, en **Grupos de seguridad**, elija **ver reglas de entrada**.
Debe aparecer una lista de reglas en el grupo de seguridad con un aspecto similar al siguiente:
```
Security Groups associated with i-1234567890abcdef0
Ports Protocol Source launch-wizard-N
22 tcp 0.0.0.0/0 ✔
```
1. En **Grupos de seguridad**, elija el grupo de seguridad de la instancia de Amazon EC2. Podría llamarse **launch-wizard-*N***. La ***N*** del nombre es un número asignado al grupo de seguridad cuando se creó la instancia.
Elija la pestaña **Inbound** (Reglas entrantes). El grupo de seguridad de la instancia está configurado correctamente si se ve una regla con los siguientes valores:
+ **Tipo**: HTTP
+ **Protocolo**: TCP
+ **Rango de puertos**: 80
+ **Fuente**: 0.0.0.0/0
1. Si no ve ninguna regla con estos valores, utilice los procedimientos de [Agregar reglas a un grupo de seguridad](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html#adding-security-group-rule) para agregarlas a una nueva regla de seguridad.
# Paso 2: Configurar el contenido de origen para implementarlo en la instancia de Amazon EC2 de Windows Server
Ha llegado el momento de configurar el contenido de origen de la aplicación para tener algo que implementar en la instancia de Amazon EC2. En este tutorial, implementará una única página web en la instancia de Amazon EC2 que ejecuta Windows Server, que a su vez ejecutará Internet Information Services (IIS) como su servidor web. Esta página web mostrará un mensaje "Hello, World\$1" simple.
**Topics**
+ [Crear la página web](#tutorials-windows-configure-content-download-code)
+ [Crear un script para ejecutar la aplicación](#tutorials-windows-configure-content-create-scripts)
+ [Añadir un archivo de especificación de la aplicación](#tutorials-windows-configure-content-add-appspec-file)
## Crear la página web
1. Cree un subdirectorio (subcarpeta) denominado `HelloWorldApp` en su carpeta `c:\temp` y, a continuación, pase a esa carpeta.
```
mkdir c:\temp\HelloWorldApp
cd c:\temp\HelloWorldApp
```
**nota**
La ubicación de la carpeta no tiene por qué ser `c:\temp` ni el nombre de la subcarpeta, `HelloWorldApp`. Si utiliza otra ubicación u otro nombre de subcarpeta, asegúrese de utilizarlos en este tutorial.
1. Utilice un editor de texto para crear un archivo dentro de la carpeta. Nombre el archivo `index.html`.
```
notepad index.html
```
1. Añada el siguiente código HTML al archivo y guárdelo.
```
Hello, World!
Hello, World!
You have successfully deployed an application using CodeDeploy
```
## Crear un script para ejecutar la aplicación
A continuación, creará un script que CodeDeploy se utilizará para configurar el servidor web en la instancia Amazon EC2 de destino.
1. En la misma subcarpeta donde se guarda el archivo `index.html`, utilice un editor de texto para crear otro archivo. Nombre el archivo `before-install.bat`.
```
notepad before-install.bat
```
1. Añada el siguiente código de script de procesamiento por lotes al archivo y, a continuación, guárdelo.
```
REM Install Internet Information Server (IIS).
c:\Windows\Sysnative\WindowsPowerShell\v1.0\powershell.exe -Command Import-Module -Name ServerManager
c:\Windows\Sysnative\WindowsPowerShell\v1.0\powershell.exe -Command Install-WindowsFeature Web-Server
```
## Añadir un archivo de especificación de la aplicación
A continuación, añadirá un archivo de especificaciones de la aplicación (AppSpec archivo) además de la página web y el archivo de script por lotes. El AppSpec archivo es un archivo con formato [YAML](http://www.yaml.org) que se utiliza para: CodeDeploy
+ Asignar los archivos de origen de la revisión de la aplicación a sus destinos en la instancia.
+ Especificar los scripts que deben ejecutarse en la instancia durante la implementación.
El AppSpec archivo debe tener un nombre. `appspec.yml` Debe ir en la carpeta raíz de código fuente de la aplicación.
1. Utilice un editor de texto para crear otro archivo en la misma carpeta en la que se encuentran `index.html` y `before-install.bat`. Nombre el archivo `appspec.yml`.
```
notepad appspec.yml
```
1. Añada el siguiente código YAML al archivo y guárdelo.
```
version: 0.0
os: windows
files:
- source: \index.html
destination: c:\inetpub\wwwroot
hooks:
BeforeInstall:
- location: \before-install.bat
timeout: 900
```
CodeDeploy utilizará este AppSpec archivo para copiar el `index.html` archivo de la carpeta raíz del código fuente de la aplicación a la `c:\inetpub\wwwroot` carpeta de la instancia Amazon EC2 de destino. Durante la implementación, CodeDeploy ejecutará el script `before-install.bat` por lotes en la instancia Amazon EC2 de destino durante el evento del ciclo de vida de la **BeforeInstall** implementación. Si este script tarda más de 900 segundos (15 minutos) en ejecutarse, CodeDeploy detendrá la implementación y marcará la implementación en la instancia de Amazon EC2 como fallida.
Para obtener más información sobre la configuración, consulte [CodeDeploy AppSpec referencia de archivo](reference-appspec-file.md).
**importante**
Las ubicaciones y el número de espacios entre cada uno de los elementos de este archivo son importantes. Si el espaciado es incorrecto, se CodeDeploy generará un error que puede ser difícil de depurar. Para obtener más información, consulte [AppSpec Espaciado de archivos](reference-appspec-file.md#reference-appspec-file-spacing).
# Paso 3: Cargar la aplicación "Hello, World\$1" en Amazon S3
Ahora preparará y cargará su contenido fuente en una ubicación desde la que CodeDeploy pueda desplegarlo. Las siguientes instrucciones explican cómo aprovisionar un bucket de Amazon S3, preparar los archivos de la revisión de la aplicación para el bucket, agrupar los archivos de la revisión y, a continuación, enviar la revisión al bucket.
**nota**
Aunque no se trata en este tutorial, puede utilizarla CodeDeploy para implementar aplicaciones desde GitHub los repositorios hasta las instancias. Para obtener más información, consulte [Integración CodeDeploy con GitHub](integrations-partners-github.md).
**Topics**
+ [Aprovisionar un bucket de Amazon S3](#tutorials-windows-upload-application-create-s3-bucket)
+ [Preparación de los archivos de la aplicación para el bucket](#tutorials-windows-upload-application-prepare-application-files)
+ [Agrupación de los archivos de la aplicación en un único archivo de almacenamiento y envío del archivo de almacenamiento](#tutorials-windows-upload-application-bundle-and-push-archive)
## Aprovisionar un bucket de Amazon S3
Cree un contenedor de almacenamiento o *bucket* en Amazon S3 o utilice un bucket existente. Asegúrese de que puede cargar la revisión en el bucket y que las instancias Amazon EC2 utilizadas en las implementaciones pueden descargar la revisión del bucket.
Puede usar la AWS CLI consola Amazon S3 o Amazon S3 APIs para crear un bucket de Amazon S3. Después de crear el bucket, asegúrese de que concede permisos de acceso al bucket y a su usuario de CodeDeploy.
**nota**
Los nombres de los buckets deben ser únicos en Amazon S3 para todas AWS las cuentas. Si no puede utilizar **amzn-s3-demo-bucket**, pruebe otro nombre de bucket, por ejemplo, **amzn-s3-demo-bucket** seguido de un guion y sus iniciales o algún otro identificador único. A continuación, cuando aparezca **amzn-s3-demo-bucket** en este tutorial, asegúrese de sustituirlo por el nombre de su bucket.
El bucket de Amazon S3 debe crearse en la misma AWS región en la que se lanzaron las instancias de Amazon EC2 de destino. Por ejemplo, si crea el bucket en la región Este de EE. UU. (Norte de Virginia), sus instancias de Amazon EC2 de destino deben lanzarse en la región Este de EE. UU. (Norte de Virginia).
**Topics**
+ [Para crear un bucket de Amazon S3 (CLI)](#tutorials-windows-upload-application-create-s3-bucket-cli)
+ [Para crear un bucket de Amazon S3 (consola)](#tutorials-windows-upload-application-create-s3-bucket-console)
+ [Conceda permisos al bucket de Amazon S3 y a su AWS cuenta](#tutorials-windows-upload-application-create-s3-bucket-grant-permission)
### Para crear un bucket de Amazon S3 (CLI)
Llame al comando **mb** para crear un bucket de Amazon S3 denominado **amzn-s3-demo-bucket**:
```
aws s3 mb s3://amzn-s3-demo-bucket --region region
```
### Para crear un bucket de Amazon S3 (consola)
1. Abra la consola de Amazon S3 en [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. En la consola de Amazon S3, elija **Crear bucket**.
1. En el cuadro **Bucket name (Nombre del bucket)**, escriba un nombre para el bucket.
1. En la lista **Region (Región)**, elija la región de destino y, a continuación, seleccione **Create (Crear)**.
### Conceda permisos al bucket de Amazon S3 y a su AWS cuenta
Debe tener permisos para cargar en el bucket de Amazon S3. Puede especificar estos permisos mediante una política de bucket de Amazon S3. Por ejemplo, en la siguiente política de bucket de Amazon S3, el uso del carácter comodín (\$1) permite `111122223333` a la AWS cuenta cargar archivos en cualquier directorio del bucket de Amazon S3 denominado`amzn-s3-demo-bucket`:
```
{
"Statement": [
{
"Action": [
"s3:PutObject"
],
"Effect": "Allow",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*",
"Principal": {
"AWS": [
"111122223333"
]
}
}
]
}
```
Para ver el ID de su AWS cuenta, consulte [Cómo encontrar el ID de su AWS cuenta](https://docs.aws.amazon.com/IAM/latest/UserGuide/console_account-alias.html#FindingYourAWSId).
Ahora es un buen momento para comprobar que el bucket de Amazon S3 permite las solicitudes de descarga de cada instancia de Amazon EC2 participante. Puede especificarlos mediante una política de bucket de Amazon S3. Por ejemplo, en la siguiente política de bucket de Amazon S3, el carácter comodín (\$1) permite a cualquier instancia de Amazon EC2 asociada a un perfil de instancia de IAM que contenga el ARN `arn:aws:iam::444455556666:role/CodeDeployDemo` descargar desde cualquier directorio al bucket de Amazon S3 llamado `amzn-s3-demo-bucket`:
```
{
"Statement": [
{
"Action": [
"s3:Get*",
"s3:List*"
],
"Effect": "Allow",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*",
"Principal": {
"AWS": [
"arn:aws:iam::444455556666:role/CodeDeployDemo"
]
}
}
]
}
```
Para obtener información acerca de cómo generar y adjuntar una política de bucket de Amazon S3, consulte [Ejemplos de política de bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-bucket-policies.html).
El usuario CodeDeploy administrativo en el que creó también [Paso 1: Configurar](getting-started-setting-up.md) debe tener permiso para cargar la revisión en el bucket de Amazon S3. Una forma de especificarlo es mediante una política de IAM, que se añade al conjunto de permisos del usuario o a un rol de IAM (que se deja que el usuario asuma). La siguiente política de IAM permite que el usuario cargue revisiones en cualquier lugar del bucket de Amazon S3 denominado `amzn-s3-demo-bucket`:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":["s3:PutObject"],
"Resource":"arn:aws:s3:::amzn-s3-demo-bucket/*"
}
]
}
```
------
Para obtener información sobre cómo crear una política de IAM, consulte [Creación de políticas de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) en la *Guía del usuario de IAM*. Para obtener información sobre cómo añadir una política a un conjunto de permisos, consulte [Crear un conjunto de permisos](https://docs.aws.amazon.com/singlesignon/latest/userguide/howtocreatepermissionset.html) en la *Guía del usuario de AWS IAM Identity Center *.
## Preparación de los archivos de la aplicación para el bucket
Asegúrese de que la página web, el AppSpec archivo y el script estén organizados en su máquina de desarrollo de la siguiente manera:
```
c:\
|-- temp\
|--HelloWorldApp\
|-- appspec.yml
|-- before-install.bat
|-- index.html
```
## Agrupación de los archivos de la aplicación en un único archivo de almacenamiento y envío del archivo de almacenamiento
Agrupe los archivos en un archivo de almacenamiento (se denomina una *revisión* de la aplicación).
**nota**
Es posible que se cobre por almacenar objetos en un bucket y por transferir revisiones de la aplicación dentro y fuera de un bucket. Para obtener más información, consulte [Precios de Amazon S3](https://aws.amazon.com/s3/pricing/).
1. En el equipo de desarrollo, cambie a la carpeta en la que se almacenan los archivos:
```
cd c:\temp\HelloWorldApp
```
**nota**
Si no cambia a esta carpeta, la agrupación del archivo comenzará en su carpeta actual. Por ejemplo, si la carpeta actual es `c:\temp` en lugar de `c:\temp\HelloWorldApp`, la agrupación comenzará con los archivos y subcarpetas de la carpeta `c:\temp`, lo que puede incluir algo más que la subcarpeta `HelloWorldApp`.
1. Ejecute el **create-application** comando para registrar una nueva aplicación cuyo nombre **HelloWorld\$1App** sea CodeDeploy:
```
aws deploy create-application --application-name HelloWorld_App
```
1. Ejecute el comando CodeDeploy [push](https://docs.aws.amazon.com/cli/latest/reference/deploy/push.html) para agrupar los archivos, cargar las revisiones en Amazon S3 y registrar la información CodeDeploy sobre la revisión cargada, todo en una sola acción.
```
aws deploy push --application-name HelloWorld_App --s3-location s3://amzn-s3-demo-bucket/HelloWorld_App.zip --ignore-hidden-files
```
Este comando agrupa los archivos del directorio actual (excluyendo los archivos ocultos) en un único archivo denominado`HelloWorld_App.zip`, carga la revisión en el **amzn-s3-demo-bucket** depósito y registra la información CodeDeploy sobre la revisión cargada.
# Paso 4: Implementar la aplicación Hello World.
Ahora implementa la revisión de la aplicación Hello, World\$1 de ejemplo que ha cargado en Amazon S3. Utilice la consola AWS CLI o la CodeDeploy consola para implementar la revisión y supervisar el progreso de la implementación. Una vez implementada correctamente la revisión de la aplicación, comprobará los resultados.
**Topics**
+ [Implemente la revisión de su aplicación con CodeDeploy](#tutorials-windows-deploy-application-create-deployment)
+ [Monitorización y solución de problemas de la implementación](#tutorials-windows-deploy-application-monitor)
+ [Comprobación de la implementación](#tutorials-windows-deploy-application-verify)
## Implemente la revisión de su aplicación con CodeDeploy
Puede implementar su aplicación con la CLI o la consola.
**Topics**
+ [Para implementar la revisión de la aplicación (CLI)](#tutorials-windows-deploy-application-create-deployment-cli)
+ [Para implementar la revisión de la aplicación (consola)](#tutorials-windows-deploy-application-create-deployment-console)
### Para implementar la revisión de la aplicación (CLI)
1. En primer lugar, la implementación necesita un grupo de implementaciones. Sin embargo, para crear el grupo de implementaciones, primero necesita un ARN de rol de servicio. Un rol de servicio es un rol de IAM que concede a un servicio permiso para actuar en su nombre. En este caso, el rol de servicio otorga CodeDeploy permiso para acceder a sus instancias de Amazon EC2 para expandir (leer) sus etiquetas de instancia de Amazon EC2.
Ya debe haber seguido las instrucciones de [Creación de un rol de servicio (CLI)](getting-started-create-service-role.md#getting-started-create-service-role-cli) para crear un rol de servicio. Para obtener el ARN del rol de servicio, consulte [Obtención del ARN del rol de servicio (CLI)](getting-started-create-service-role.md#getting-started-get-service-role-cli).
1. Ahora que tiene el ARN, llame al comando **create-deployment-group** para crear un grupo de implementación denominado **HelloWorld\$1DepGroup** asociado a la aplicación **HelloWorld\$1App**, utilizando la etiqueta de instancia de Amazon EC2 denominada **CodeDeployDemo** y la configuración de implementación denominada **CodeDeployDefault.OneAtATime** con el ARN del rol de servicio:
```
aws deploy create-deployment-group --application-name HelloWorld_App --deployment-group-name HelloWorld_DepGroup --deployment-config-name CodeDeployDefault.OneAtATime --ec2-tag-filters Key=Name,Value=CodeDeployDemo,Type=KEY_AND_VALUE --service-role-arn serviceRoleARN
```
**nota**
El [create-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment-group.html)comando permite crear activadores que provoquen el envío de notificaciones de Amazon SNS a los suscriptores del tema sobre eventos específicos en implementaciones e instancias. El comando también admite opciones para revertir automáticamente las implementaciones y configurar alarmas para detener las implementaciones cuando se cumplen los umbrales de monitoreo de CloudWatch las alarmas de Amazon. Los comandos para estas acciones no se incluyen en este tutorial.
1. Antes de crear una implementación, las instancias de su grupo de implementación deben tener el CodeDeploy agente instalado. Puede instalar el agente desde la línea de comandos con AWS Systems Manager mediante el comando siguiente:
```
aws ssm create-association --name AWS-ConfigureAWSPackage --targets Key=tag:Name,Values=CodeDeployDemo --parameters action=Install,name=AWSCodeDeployAgent --schedule-expression "cron(0 2 ? * SUN *)"
```
Este comando crea una asociación en Systems Manager State Manager que instalará el CodeDeploy agente e intentará actualizarlo todos los domingos a las 2:00 de la mañana. Para obtener más información sobre el CodeDeploy agente, consulte [Trabajar con el CodeDeploy agente](https://docs.aws.amazon.com/codedeploy/latest/userguide/codedeploy-agent.html). Para obtener más información acerca de Systems Manager, consulte [¿Qué es AWS Systems Manager?](https://docs.aws.amazon.com/systems-manager/latest/userguide/what-is-systems-manager.html).
1. Ejecute ahora el comando **create-deployment** para crear una implementación asociada a la aplicación **HelloWorld\$1App**, la configuración de implementación **CodeDeployDefault.OneAtATime** y el grupo de implementaciones **HelloWorld\$1DepGroup** utilizando la revisión de la aplicación **HelloWorld\$1App.zip** del bucket **amzn-s3-demo-bucket**:
```
aws deploy create-deployment --application-name HelloWorld_App --deployment-config-name CodeDeployDefault.OneAtATime --deployment-group-name HelloWorld_DepGroup --s3-location bucket=amzn-s3-demo-bucket,bundleType=zip,key=HelloWorld_App.zip
```
### Para implementar la revisión de la aplicación (consola)
1. Antes de usar la CodeDeploy consola para implementar la revisión de la aplicación, necesita un ARN de rol de servicio. Un rol de servicio es un rol de IAM que concede a un servicio permiso para actuar en su nombre. En este caso, el rol de servicio otorga CodeDeploy permiso para acceder a sus instancias de Amazon EC2 para expandir (leer) sus etiquetas de instancia de Amazon EC2.
Ya debe haber seguido las instrucciones de [Creación de un rol de servicio (consola)](getting-started-create-service-role.md#getting-started-create-service-role-console) para crear un rol de servicio. Para obtener el ARN del rol de servicio, consulte [Obtención del ARN del rol de servicio (consola)](getting-started-create-service-role.md#getting-started-get-service-role-console).
1. Ahora que tiene el ARN, puede usar la CodeDeploy consola para implementar la revisión de la aplicación.
Inicie sesión en la CodeDeploy consola Consola de administración de AWS y ábrala en [https://console.aws.amazon.com/codedeploy](https://console.aws.amazon.com/codedeploy).
**nota**
Inicie sesión con el mismo usuario que configuró en [Empezar con CodeDeploy](getting-started-codedeploy.md).
1. En el panel de navegación, expanda **Implementar** y, después, elija **Aplicaciones**.
1. **Elige \$1AppHelloWorld.**
1. En la pestaña **Deployment groups (Grupos de implementaciones)**, elija **Create deployment group (Crear grupo de implementaciones)**.
1. En **Nombre de grupo de implementación**, escriba **HelloWorld\$1DepGroup**.
1. En **Service Role (Rol de servicio)**, elija el nombre del rol de servicio.
1. En **Tipo de implementación**, elija **Local**.
1. En **Configuración de entorno**, elija la pestaña **Instancias de Amazon EC2**.
1. En la **configuración del agente con AWS Systems Manager**, mantenga los valores predeterminados.
1. En **Clave**, introduzca **Name**.
1. En **Valor**, escriba **CodeDeployDemo**.
1. **En **Configuración de despliegue**, elijaCodeDeployDefault. OneAtATime**.
1. En **Equilibrador de carga**, anule la selección de **Habilitar equilibración de carga**.
1. Elija **Crear grupo de implementación**.
1. Elija **Crear implementación**.
1. En el **grupo de implementación**, elija **HelloWorld\$1 DepGroup**
1. En **Tipo de revisión**, elija **Mi aplicación está almacenada en Amazon S3** y, a continuación, en **Ubicación de la revisión**, escriba la ubicación de la revisión de la aplicación de ejemplo Hello, World\$1 que cargó previamente en Amazon S3. Para obtener la ubicación:
1. Abra la consola de Amazon S3 en [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. En la lista de buckets, elija **amzn-s3-demo-bucket** (o el nombre del bucket en el que cargó la revisión de la aplicación).
1. En la lista de objetos, elija **HelloWorld\$1App.zip**.
1. En la pestaña **Overview (Información general)**, elija **Copy path (Ruta de copia)**.
1. Vuelva a la CodeDeploy consola y, en **Ubicación de revisión**, pegue el valor del campo **Enlace**.
1. En **Revision file type (Tipo de archivo de revisión)**, elija **.zip**.
1. (Opcional) Escriba un comentario en **Deployment description (Descripción de implementación)**.
1. Elija **Crear implementación**. En la página **Deployments** se mostrará información sobre la implementación que acaba de crear.
## Monitorización y solución de problemas de la implementación
Utilice la consola AWS CLI o la consola para supervisar y solucionar los problemas de la implementación.
**Topics**
+ [Para monitorizar y solucionar problemas en la implementación (CLI)](#tutorials-windows-deploy-application-monitor-cli)
+ [Para monitorizar y resolver problemas de la implementación (consola)](#tutorials-windows-deploy-application-monitor-console)
### Para monitorizar y solucionar problemas en la implementación (CLI)
1. Obtenga el ID de la implementación; para ello, ejecute el comando **list-deployments** para la aplicación **HelloWorld\$1App** y el grupo de implementaciones **HelloWorld\$1DepGroup**:
```
aws deploy list-deployments --application-name HelloWorld_App --deployment-group-name HelloWorld_DepGroup --query "deployments" --output text
```
1. Llame al comando **get-deployment** con el ID de la implementación:
```
aws deploy get-deployment --deployment-id deploymentID --query "deploymentInfo.status" --output text
```
1. El comando devuelve el estado general de la implementación. Si todo sale bien, el valor es `Succeeded`.
Si el estado general es `Failed`, puede ejecutar comandos como [list-deployment-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployment-instances.html) y [get-deployment-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/get-deployment-instance.html) para solucionar los problemas. Si desea conocer más opciones de solución de problemas, consulte [Análisis de archivos de registro para investigar los errores de implementación en instancias](troubleshooting-ec2-instances.md#troubleshooting-deploy-failures).
### Para monitorizar y resolver problemas de la implementación (consola)
En la página **Implementaciones** de la CodeDeploy consola, puede supervisar el estado de la implementación en la columna **Estado**.
Para obtener más información acerca de la implementación, sobre todo si el valor de la columna **Status** tiene un valor distinto de **Succeeded**:
1. En la tabla **Deployments (Implementaciones)**, elija el ID de implementación. Cuando se produce un error en una implementación, aparece un mensaje que describe el motivo del error en la página de detalles de la implementación.
1. Aparece más información sobre las instancias de la implementación. Cuando se una implementación falla, es posible que pueda determinar las instancias de Amazon EC2 afectadas y el paso del proceso en el que se ha producido el error.
1. Si desea realizar más resolución de problemas, puede utilizar una técnica como [Visualización de los detalles de la instancia con CodeDeploy](instances-view-details.md). También puede analizar los archivos de registro de la implementación en una instancia de Amazon EC2. Para obtener más información, consulte [Análisis de archivos de registro para investigar los errores de implementación en instancias](troubleshooting-ec2-instances.md#troubleshooting-deploy-failures).
## Comprobación de la implementación
Después que la implementación se realiza correctamente, verifique que funciona la instalación. Utilice la dirección de DNS público de la instancia de Amazon EC2 para ver la página web en un navegador web. (Para obtener el valor de DNS público, en la consola de Amazon EC2, seleccione la instancia de Amazon EC2 y, en la pestaña **Descripción**, busque el valor **Public DNS**).
Por ejemplo, si la dirección DNS pública de la instancia de Amazon EC2 es **ec2-01-234-567-890.compute-1.amazonaws.com**, se usará la siguiente dirección URL:
```
http://ec2-01-234-567-890.compute-1.amazonaws.com
```
Si la operación se realiza correctamente, debería ver una página web Hello, World\$1.
# Paso 5: Actualizar y volver a implementar su aplicación "Hello, World\$1"
Una vez que hayas implementado correctamente la revisión de la aplicación, actualiza el código de la página web en la máquina de desarrollo y úsala CodeDeploy para volver a implementar el sitio. Una vez implementada nuevamente la revisión, debe poder ver los cambios en el código en la instancia de Amazon EC2.
**Topics**
+ [Modificar la página web](#tutorials-windows-update-and-redeploy-application-modify-code)
+ [Nueva implementación del sitio](#tutorials-windows-update-and-redeploy-application-deploy-updates)
## Modificar la página web
1. Vaya a la subcarpeta `c:\temp\HelloWorldApp` y use un editor de texto para modificar el archivo `index.html`:
```
cd c:\temp\HelloWorldApp
notepad index.html
```
1. Revise el contenido del archivo `index.html` para cambiar el color de fondo y parte del texto de la página web y, a continuación, guarde el archivo:
```
Hello Again, World!
Hello Again, World!
You have successfully deployed a revision of an application using CodeDeploy
```
## Nueva implementación del sitio
Ahora que ha modificado el código, utilice Amazon S3 CodeDeploy para volver a implementar la página web.
Agrupe y cargue los cambios en Amazon S3, como se describe en [Agrupación de los archivos de la aplicación en un único archivo de almacenamiento y envío del archivo de almacenamiento](tutorials-windows-upload-application.md#tutorials-windows-upload-application-bundle-and-push-archive). (Cuando siga esas instrucciones, recuerde que no tiene que crear una nueva aplicación). Asigne a la nueva revisión la misma clave que antes (**HelloWorld\$1App.zip**). Cárguela en el mismo bucket de Amazon S3 que creó anteriormente (por ejemplo, **amzn-s3-demo-bucket**).
Utilice la consola AWS CLI o la CodeDeploy consola para volver a implementar el sitio.
**Topics**
+ [Para volver implementar el sitio (CLI)](#tutorials-windows-update-and-redeploy-application-deploy-updates-cli)
+ [Para volver a implementar el sitio (consola)](#tutorials-windows-update-and-redeploy-application-deploy-updates-console)
### Para volver implementar el sitio (CLI)
Ejecute el comando **create-deployment** para crear una implementación basada en la revisión que ha cargado, utilizando también la aplicación **HelloWorld\$1App**, la configuración de implementación **CodeDeployDefault.OneAtATime**, el grupo de implementaciones **HelloWorld\$1DepGroup** y la revisión de la aplicación **HelloWorld\$1App.zip** del bucket **amzn-s3-demo-bucket**:
```
aws deploy create-deployment --application-name HelloWorld_App --deployment-config-name CodeDeployDefault.OneAtATime --deployment-group-name HelloWorld_DepGroup --s3-location bucket=amzn-s3-demo-bucket,bundleType=zip,key=HelloWorld_App.zip
```
Puede comprobar el estado de la nueva implementación como se describe en [Monitorización y solución de problemas de la implementación](tutorials-windows-deploy-application.md#tutorials-windows-deploy-application-monitor).
Cuando CodeDeploy haya redistribuido el sitio, vuelva a visitarlo en su navegador web para comprobar que se han cambiado el color de fondo y el texto de la página web. (Puede que tenga que actualizar el navegador). Si el color de fondo y el texto se han modificado, ¡enhorabuena\$1 Ha modificado y ha vuelto a implementar su sitio.
### Para volver a implementar el sitio (consola)
1. [Inicie sesión en Consola de administración de AWS y abra la CodeDeploy consola en /codedeploy. https://console.aws.amazon.com](https://console.aws.amazon.com/codedeploy)
**nota**
Inicie sesión con el mismo usuario que configuró en [Empezar con CodeDeploy](getting-started-codedeploy.md).
1. En el panel de navegación, elija **Applications (Aplicaciones)**.
1. **En la lista de **aplicaciones**, elija HelloWorld \$1App.**
1. En la pestaña **Deployments (Implementaciones)**, elija **Create deployment (Crear implementación)**.
1. En la lista **de grupos de despliegues**, elija **HelloWorld\$1 DepGroup**.
1. En **Ubicación de la revisión**, introduzca el enlace de Amazon S3 de la revisión.
Para encontrar el valor del enlace:
1. Inicie sesión en la consola de Amazon S3 Consola de administración de AWS y ábrala en [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
Vaya al archivo **amzn-s3-demo-bucket**, ábralo y elija la revisión, **HelloWorld\$1App.zip**, en la consola de Amazon S3.
1. Si el panel **Propiedades** no se muestra en la consola de Amazon S3, elija el botón **Propiedades**.
1. En el panel **Properties (Propiedades)**, copie el valor del campo **Link (Enlace)**.
1. Regrese a la CodeDeploy consola y, a continuación, pegue el enlace en la **ubicación de revisión**.
1. En **Revision file type (Tipo de archivo de revisión)**, si aparece un mensaje en el que se indica que no se ha podido detectar el tipo de archivo, elija **.zip**.
1. Deje **Deployment description (Descripción de implementación)** en blanco.
1. **Expanda las **anulaciones de grupos de despliegues** En la lista **de configuraciones de despliegue**, seleccioneCodeDeployDefault. OneAtATime**y, a continuación, elija **Crear despliegue**.
Puede comprobar el estado de la implementación como se describe en [Monitorización y solución de problemas de la implementación](tutorials-windows-deploy-application.md#tutorials-windows-deploy-application-monitor).
Cuando CodeDeploy haya vuelto a implementar el sitio, vuelva a visitarlo en su navegador web para comprobar que el color de fondo y el texto de la página web han cambiado. (Puede que tenga que actualizar el navegador). Si el color de fondo y el texto se han modificado, ¡enhorabuena\$1 Ha modificado y ha vuelto a implementar su sitio.
# Paso 6: Limpiar la aplicación de "Hello, World\$1" y sus recursos relacionados
Ha actualizado el código de "Hello, World\$1" correctamente e implementado de nuevo el sitio. Para evitar cargos recurrentes por los recursos que ha creado para completar este tutorial, debe eliminar:
+ Cualquier CloudFormation pila (o cierre cualquier instancia de Amazon EC2, si la creó fuera CloudFormation de ella).
+ Todos los buckets de Amazon S3.
+ La aplicación `HelloWorld_App` en CodeDeploy.
+ La asociación de administradores AWS Systems Manager estatales del CodeDeploy agente.
Puede utilizar Amazon S3 CloudFormation, Amazon EC2 y CodeDeploy las consolas, o AWS APIs para realizar la limpieza. AWS CLI
**Topics**
+ [Para limpiar los recursos (CLI)](#tutorials-windows-clean-up-cli)
+ [Para limpiar los recursos (consola)](#tutorials-windows-clean-up-console)
+ [Siguientes pasos](#tutorials-windows-clean-up-whats-next)
## Para limpiar los recursos (CLI)
1. Si usó la CloudFormation pila para este tutorial, elimine la pila ejecutando el **delete-stack** comando correspondiente a la pila nombrada. **CodeDeployDemoStack** Esto termina todas las instancias de Amazon EC2 vinculadas y elimina todos los roles de IAM asociados creados originalmente por la pila.
```
aws cloudformation delete-stack --stack-name CodeDeployDemoStack
```
1. Para eliminar el bucket de Amazon S3, llame al comando **rm** con el modificador **--recursive** para el bucket denominado **amzn-s3-demo-bucket**. Así elimina el bucket y todos los objetos que contiene.
```
aws s3 rm s3://amzn-s3-demo-bucket --recursive --region region
```
1. Para eliminar la `HelloWorld_App` aplicación CodeDeploy, ejecuta el **delete-application** comando. Esto elimina todos los registros de grupo de implementaciones asociados y los registros de implementación de la aplicación.
```
aws deploy delete-application --application-name HelloWorld_App
```
1. Para eliminar la asociación de Systems Manager State Manager, llame al comando **delete-association**.
```
aws ssm delete-association --assocation-id association-id
```
Puede obtenerlo *association-id* llamando al **describe-association** comando.
```
aws ssm describe-association --name AWS-ConfigureAWSPackage --targets Key=tag:Name,Values=CodeDeployDemo
```
1. Si no usó la CloudFormation pila para este tutorial, **terminate-instances** ejecute el comando para terminar las instancias de Amazon EC2 que creó manualmente. Indique el ID de la instancia de Amazon EC2 que desea terminar.
```
aws ec2 terminate-instances --instance-ids instanceId
```
## Para limpiar los recursos (consola)
Si utilizó nuestra CloudFormation plantilla para este tutorial, elimine la CloudFormation pila asociada.
1. Inicia sesión Consola de administración de AWS y abre la CloudFormation consola en [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. En el cuadro de búsqueda, escribe el nombre de la CloudFormation pila (por ejemplo,**CodeDeployDemoStack**).
1. Seleccione la casilla junto al nombre de la pila.
1. En el menú **Actions (Acciones)**, elija **Delete Stack (Eliminar pila)**. Esto elimina la pila, termina todas las instancias de Amazon EC2 asociadas y elimina todos los roles de IAM asociados.
Para finalizar las instancias de Amazon EC2 que creó fuera de una CloudFormation pila:
1. Inicie sesión en la consola Amazon EC2 Consola de administración de AWS y ábrala en. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. En el área **Instances**, elija **Instances**.
1. En el campo de búsqueda, escriba el nombre de la instancia de Amazon EC2 que desee eliminar y, a continuación, pulse **Intro**.
1. Seleccione la instancia de Amazon EC2.
1. Elija **Acciones**, seleccione **Estado de la instancia** y elija **Terminar**. Cuando se le pregunte, elija **Yes, Terminate**. Repita estos pasos para todas las instancias de Amazon EC2.
Para eliminar el bucket de Amazon S3:
1. Inicie sesión en la consola de Amazon S3 Consola de administración de AWS y ábrala en [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. En la lista de buckets, busque y seleccione el nombre del bucket de Amazon S3 (por ejemplo, **amzn-s3-demo-bucket**).
1. Para eliminar un bucket, primero debe eliminar su contenido. Seleccione todos los archivos del bucket, como **HelloWorld\$1App.zip**. En el menú **Actions**, elija **Delete**. Cuando se le pida confirmar la eliminación, elija **OK**.
1. Una vez vacío, puede eliminar el bucket. En la lista de buckets, elija la línea del bucket (pero no su nombre). Elija **Delete bucket** y cuando se le pida que confirme, seleccione **OK**.
Para eliminar la `HelloWorld_App` aplicación de CodeDeploy:
1. Inicie sesión en Consola de administración de AWS y abra la CodeDeploy consola en [https://console.aws.amazon.com/codedeploy.](https://console.aws.amazon.com/codedeploy)
**nota**
Inicie sesión con el mismo usuario que configuró en [Empezar con CodeDeploy](getting-started-codedeploy.md).
1. En el panel de navegación, expanda **Implementar** y, después, elija **Aplicaciones**.
1. Elija **`HelloWorld_App`**.
1. Elija **Eliminar aplicación**.
1. Cuando se le pregunte, escriba **Delete** y, a continuación, elija **Delete (Eliminar)**.
Para eliminar la asociación de Systems Manager State Manager:
1. Abra la AWS Systems Manager consola en /systems-manager. https://console.aws.amazon.com
1. En el panel de navegación, elija **Administrador de estados**.
1. Elija la asociación que ha creado y, después, elija **Eliminar**.
## Siguientes pasos
Si ha llegado aquí, significa que ha completado correctamente una implementación con. CodeDeploy ¡Enhorabuena\$1