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 WordPress en una instancia de Amazon EC2 (Amazon Linux o Red Hat Enterprise Linux y Linux, macOS o Unix)
En este tutorial WordPress, implementará una herramienta de blogueo de código abierto y un sistema de administración de contenido basado en PHP y MySQL en una sola instancia de Amazon EC2 que ejecute Amazon Linux o Red Hat Enterprise Linux (RHEL).
¿No es lo que está buscando?
+ Para practicar la implementación en su lugar en una instancia de Amazon EC2 con Windows Server, consulte [Tutorial: Implementación de una aplicación "Hello, World\$1" aplicación con CodeDeploy (Windows Server)](tutorials-windows.md).
+ Para practicar la implementación en una instancia en las instalaciones en lugar de en una instancia de Amazon EC2, 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 la perspectiva de un equipo de desarrollo local con Linux, macOS o Unix. Aunque puede completar la mayoría de los pasos en un equipo local con Windows, debe adaptar los pasos que utilizan comandos como **chmod** y **wget**, las aplicaciones, como sed, y las rutas de directorio, como `/tmp`.
Antes de empezar este tutorial, debe completar los requisitos previos indicados en [Empezar con CodeDeploy](getting-started-codedeploy.md). Estas incluyen configurar un usuario, instalarlo o actualizarlo y crear un perfil de instancia de IAM y un rol de servicio. AWS CLI
**Topics**
+ [Paso 1: Lanzar y configurar una instancia de Amazon EC2 de Amazon Linux o Red Hat Enterprise Linux](tutorials-wordpress-launch-instance.md)
+ [Paso 2: Configurar el contenido fuente para implementarlo en la instancia de Amazon EC2 de Amazon Linux o Red Hat Enterprise Linux](tutorials-wordpress-configure-content.md)
+ [Paso 3: Cargue WordPress la aplicación en Amazon S3](tutorials-wordpress-upload-application.md)
+ [Paso 4: Implemente su WordPress aplicación](tutorials-wordpress-deploy-application.md)
+ [Paso 5: Actualizar y volver a implementar la aplicación WordPress](tutorials-wordpress-update-and-redeploy-application.md)
+ [Paso 6: Limpiar WordPress la aplicación y los recursos relacionados](tutorials-wordpress-clean-up.md)
# Paso 1: Lanzar y configurar una instancia de Amazon EC2 de Amazon Linux o Red Hat Enterprise Linux
Para implementar la WordPress aplicación CodeDeploy, necesitará una instancia de Amazon EC2 que ejecute Amazon Linux o Red Hat Enterprise Linux (RHEL). La instancia de Amazon EC2 requiere una nueva regla de seguridad de entrada que permita las conexiones HTTP. Esta regla es necesaria para poder ver la WordPress página en un navegador una vez que se haya implementado correctamente.
Siga las instrucciones en [Cree una instancia de Amazon EC2 para CodeDeploy](instances-ec2-create.md). Al llegar a las instrucciones sobre la asignación de una etiqueta de instancia de Amazon EC2 a la instancia, asegúrese de especificar la clave de etiqueta de **Name** y el valor de etiqueta de **CodeDeployDemo**. (Si especifica otra clave u otro valor de etiqueta, las instrucciones de [Paso 4: Implemente su WordPress aplicación](tutorials-wordpress-deploy-application.md) pueden producir resultados inesperados).
Una vez completadas las instrucciones para lanzar 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 a una instancia de Amazon EC2 de Amazon Linux o RHEL
Una vez lanzada la nueva instancia de Amazon EC2, siga estas instrucciones para practicar la conexión a la instancia.
1. Utilice el comando **ssh** (o un emulador de terminal con la función SSH, como [PuTTY](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/putty.html)) para conectar con la instancia de Amazon EC2 en Amazon Linux o RHEL. Necesitará la dirección DNS pública de la instancia y la clave privada del par de claves que utilizó al iniciar la instancia de Amazon EC2. Para obtener más información, consulte [Conectar con la instancia](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-connect-to-instance-linux.html).
Por ejemplo, si la dirección DNS pública es **ec2-01-234-567-890.compute-1.amazonaws.com** y el par de claves de instancia de Amazon EC2 para el acceso SSH es **codedeploydemo.pem**, escriba lo siguiente:
```
ssh -i /path/to/codedeploydemo.pem ec2-user@ec2-01-234-567-890.compute-1.amazonaws.com
```
Sustituya `/path/to/codedeploydemo.pem` por la ruta del archivo `.pem` y la dirección DNS de ejemplo por la dirección de la instancia de Amazon EC2 en Amazon Linux o RHEL.
**nota**
Si aparece un mensaje de error indicando que los permisos del archivo de clave son demasiado abiertos, deberá restringirlos de modo que solo tenga acceso el usuario actual (usted). Por ejemplo, con el comando **chmod** en Linux, macOS o Unix, escriba:
```
chmod 400 /path/to/codedeploydemo.pem
```
1. Una vez que haya iniciado sesión, verá el rótulo de AMI para la instancia de Amazon EC2. Para Amazon Linux, debería tener el siguiente aspecto:
```
__| __|_ )
_| ( / Amazon Linux AMI
___|\___|___|
```
1. Ahora ya puede cerrar la sesión en la instancia de Amazon EC2 en ejecución.
**aviso**
No interrumpa ni termine la instancia de Amazon EC2. De lo contrario, CodeDeploy no podrá implementarla en ella.
## Adición de una regla de entrada que permite el tráfico HTTP hacia la instancia de Amazon EC2 de Amazon Linux o RHEL
El siguiente paso confirma que la instancia de Amazon EC2 tiene un puerto HTTP abierto para que pueda ver la página de inicio de la WordPress aplicación desplegada 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 fuente para implementarlo en la instancia de Amazon EC2 de Amazon Linux o Red Hat Enterprise Linux
Ha llegado el momento de configurar el contenido de origen de su aplicación para tener algo que implementar en la instancia.
**Topics**
+ [Obtener el código fuente](#tutorials-wordpress-configure-content-download-code)
+ [Crear scripts para ejecutar la aplicación](#tutorials-wordpress-configure-content-create-scripts)
+ [Añadir un archivo de especificación de la aplicación](#tutorials-wordpress-configure-content-add-appspec-file)
## Obtener el código fuente
Para este tutorial, debe implementar la plataforma de publicación de WordPress contenido desde su máquina de desarrollo en la instancia Amazon EC2 de destino. Para obtener el código WordPress fuente, puede utilizar las llamadas de línea de comandos integradas. O bien, si tiene instalado Git en su equipo de desarrollo, puede utilizarlo en su lugar.
Para estos pasos, suponemos que has descargado una copia del código WordPress fuente en el `/tmp` directorio de tu máquina de desarrollo. (Puede elegir cualquier directorio que desee, pero no olvide sustituir la ubicación por `/tmp` siempre que se especifique en estos pasos).
Elige una de las dos opciones siguientes para copiar los archivos WordPress fuente a tu máquina de desarrollo. La primera opción utiliza llamadas a línea de comandos integradas. La segunda opción utiliza Git.
**Topics**
+ [Para obtener una copia del código WordPress fuente (llamadas de línea de comandos integradas)](#tutorials-wordpress-configure-content-download-code-command-line)
+ [Para obtener una copia del código WordPress fuente (Git)](#tutorials-wordpress-configure-content-download-code-git)
### Para obtener una copia del código WordPress fuente (llamadas de línea de comandos integradas)
1. Ejecute el **wget** comando para descargar una copia del código WordPress fuente, en forma de archivo.zip, en el directorio actual:
```
wget https://github.com/WordPress/WordPress/archive/master.zip
```
1. Ejecute los comandos **unzip**, **mkdir**, **cp** y **rm** para:
+ Descomprimir el archivo .zip `master` en el directorio (carpeta) `/tmp/WordPress_Temp`.
+ Copiar el contenido descomprimido en la carpeta de destino `/tmp/WordPress`.
+ Eliminar la carpeta temporal `/tmp/WordPress_Temp` y el archivo `master`.
Ejecute los comandos de uno en uno:
```
unzip master -d /tmp/WordPress_Temp
```
```
mkdir -p /tmp/WordPress
```
```
cp -paf /tmp/WordPress_Temp/WordPress-master/* /tmp/WordPress
```
```
rm -rf /tmp/WordPress_Temp
```
```
rm -f master
```
Esto deja un conjunto limpio de archivos de código WordPress fuente en la `/tmp/WordPress` carpeta.
### Para obtener una copia del código WordPress fuente (Git)
1. Descargue e instale [Git](http://git-scm.com) en el equipo de desarrollo.
1. En la carpeta `/tmp/WordPress`, ejecute el comando **git init**.
1. Ejecuta el **git clone** comando para clonar el WordPress repositorio público y haz tu propia copia del mismo en la carpeta de `/tmp/WordPress` destino:
```
git clone https://github.com/WordPress/WordPress.git /tmp/WordPress
```
Esto deja un conjunto limpio de archivos de código WordPress fuente en la `/tmp/WordPress` carpeta.
## Crear scripts para ejecutar la aplicación
A continuación, cree una carpeta y scripts en el directorio. CodeDeploy utiliza estos scripts para configurar e implementar la revisión de la aplicación en la instancia Amazon EC2 de destino. Puede utilizar cualquier editor de texto para crear los scripts.
1. Cree un directorio de scripts en su copia del código WordPress fuente:
```
mkdir -p /tmp/WordPress/scripts
```
1. Cree un archivo `install_dependencies.sh` en `/tmp/WordPress/scripts`. Añada las líneas siguientes al archivo. Este script `install_dependencies.sh` instala Apache, MySQL y PHP. También añade compatibilidad con MySQL a PHP.
```
#!/bin/bash
sudo amazon-linux-extras install php7.4
sudo yum install -y httpd mariadb-server php
```
1. Cree un archivo `start_server.sh` en `/tmp/WordPress/scripts`. Añada las líneas siguientes al archivo. Este script `start_server.sh` inicia Apache y MySQL.
```
#!/bin/bash
systemctl start mariadb.service
systemctl start httpd.service
systemctl start php-fpm.service
```
1. Cree un archivo `stop_server.sh` en `/tmp/WordPress/scripts`. Añada las líneas siguientes al archivo. Este script `stop_server.sh` detiene Apache y MySQL.
```
#!/bin/bash
isExistApp="pgrep httpd"
if [[ -n $isExistApp ]]; then
systemctl stop httpd.service
fi
isExistApp=pgrep mysqld
if [[ -n $isExistApp ]]; then
systemctl stop mariadb.service
fi
isExistApp=pgrep php-fpm
if [[ -n $isExistApp ]]; then
systemctl stop php-fpm.service
fi
```
1. Cree un archivo `create_test_db.sh` en `/tmp/WordPress/scripts`. Añada las líneas siguientes al archivo. Este `create_test_db.sh` script usa MySQL para crear una **test** base de datos WordPress para su uso.
```
#!/bin/bash
mysql -uroot <
A continuación, añada un archivo de especificaciones de la aplicación (AppSpec archivo), 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 de Amazon EC2 de destino.
+ Especificar permisos personalizados para los archivos implementados.
+ Especificar los scripts que se van a ejecutar en la instancia de Amazon EC2 de destino durante la implementación.
El AppSpec archivo debe tener un nombre. `appspec.yml` Debe colocarse en el directorio raíz del código fuente de la aplicación. En este tutorial, el directorio raíz es `/tmp/WordPress`.
Mediante su editor de texto, cree un archivo denominado `appspec.yml`. Añada las líneas siguientes al archivo:
```
version: 0.0
os: linux
files:
- source: /
destination: /var/www/html/WordPress
hooks:
BeforeInstall:
- location: scripts/install_dependencies.sh
timeout: 300
runas: root
AfterInstall:
- location: scripts/change_permissions.sh
timeout: 300
runas: root
ApplicationStart:
- location: scripts/start_server.sh
- location: scripts/create_test_db.sh
timeout: 300
runas: root
ApplicationStop:
- location: scripts/stop_server.sh
timeout: 300
runas: root
```
CodeDeploy utiliza este AppSpec archivo para copiar todos los archivos de la `/tmp/WordPress` carpeta de la máquina de desarrollo a la `/var/www/html/WordPress` carpeta de la instancia Amazon EC2 de destino. Durante la implementación, CodeDeploy ejecuta los scripts especificados como `root` en la `/var/www/html/WordPress/scripts` carpeta de la instancia Amazon EC2 de destino en eventos específicos durante el ciclo de vida de la implementación, como **BeforeInstall** y. **AfterInstall** Si alguno de estos scripts tarda más de 300 segundos (5 minutos) en ejecutarse, CodeDeploy detiene la implementación y marca la implementación 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 produce CodeDeploy 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: Cargue WordPress la aplicación en Amazon S3
Ahora preparará y cargará el contenido de origen 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-wordpress-upload-application-create-s3-bucket)
+ [Preparación de los archivos de la aplicación para el bucket](#tutorials-wordpress-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-wordpress-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 cuenta de AWS .
**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 lanzan 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-wordpress-upload-application-create-s3-bucket-cli)
+ [Para crear un bucket de Amazon S3 (consola)](#tutorials-wordpress-upload-application-create-s3-bucket-console)
+ [Otorgue permisos al bucket y a la AWS cuenta de Amazon S3](#tutorials-wordpress-upload-application-create-s3-bucket-grant-permissions)
### 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)**.
### Otorgue permisos al bucket y a la AWS cuenta de Amazon S3
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).
Para obtener información acerca de cómo crear y adjuntar una política de IAM, consulte [Trabajo con políticas](https://docs.aws.amazon.com/IAM/latest/UserGuide/ManagingPolicies.html#AddingPermissions_Console).
## Preparación de los archivos de la aplicación para el bucket
Asegúrese de que los archivos de la WordPress aplicación, el AppSpec archivo y los scripts estén organizados en su máquina de desarrollo de forma similar a la siguiente:
```
/tmp/
|--WordPress/
|-- appspec.yml
|-- scripts/
| |-- change_permissions.sh
| |-- create_test_db.sh
| |-- install_dependencies.sh
| |-- start_server.sh
| |-- stop_server.sh
|-- wp-admin/
| |-- (various files...)
|-- wp-content/
| |-- (various files...)
|-- wp-includes/
| |-- (various files...)
|-- index.php
|-- license.txt
|-- readme.html
|-- (various files ending with .php...)
```
## 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 de la WordPress aplicación y el AppSpec archivo en un archivo de almacenamiento (conocido como *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 /tmp/WordPress
```
**nota**
Si no cambia a esta carpeta, la agrupación del archivo comenzará en su carpeta actual. Por ejemplo, si la carpeta actual es `/tmp` en lugar de `/tmp/WordPress`, la agrupación comenzará con los archivos y subcarpetas de la carpeta `tmp`, lo que puede incluir algo más que la subcarpeta `WordPress`.
1. Llame al comando **create-application** para registrar una aplicación nueva denominada **WordPress\$1App**.
```
aws deploy create-application --application-name WordPress_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 WordPress_App \
--s3-location s3://amzn-s3-demo-bucket/WordPressApp.zip \
--ignore-hidden-files
```
Este comando agrupa los archivos del directorio actual (excluyendo los archivos ocultos) en un único archivo denominado**WordPressApp.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: Implemente su WordPress aplicación
Ahora implementa la revisión de la WordPress aplicación de muestra que cargó en Amazon S3. Puede utilizar 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-wordpress-deploy-application-create-deployment)
+ [Monitorización y solución de problemas de la implementación](#tutorials-wordpress-deploy-application-monitor)
+ [Comprobación de la implementación](#tutorials-wordpress-deploy-application-verify-deployment)
## Implemente la revisión de su aplicación con CodeDeploy
Utilice la consola AWS CLI o la consola para implementar la revisión de la aplicación.
**Topics**
+ [Para implementar la revisión de la aplicación (CLI)](#tutorials-wordpress-deploy-application-create-deployment-cli)
+ [Para implementar la revisión de la aplicación (consola)](#tutorials-wordpress-deploy-application-create-deployment-console)
### Para implementar la revisión de la aplicación (CLI)
1. 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 del rol de servicio, llame al comando **create-deployment-group** para crear un grupo de implementación denominado **WordPress\$1DepGroup** asociado a la aplicación **WordPress\$1App**, utilizando la etiqueta de Amazon EC2 denominada **CodeDeployDemo** y la configuración de implementación **CodeDeployDefault.OneAtATime**:
```
aws deploy create-deployment-group \
--application-name WordPress_App \
--deployment-group-name WordPress_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 **WordPress\$1App**, la configuración de implementación **CodeDeployDefault.OneAtATime** y el grupo de implementaciones **WordPress\$1DepGroup** utilizando la revisión de la aplicación **WordPressApp.zip** del bucket **amzn-s3-demo-bucket**:
```
aws deploy create-deployment \
--application-name WordPress_App \
--deployment-config-name CodeDeployDefault.OneAtATime \
--deployment-group-name WordPress_DepGroup \
--s3-location bucket=amzn-s3-demo-bucket,bundleType=zip,key=WordPressApp.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, utilice la CodeDeploy consola para implementar la revisión de la aplicación:
Inicie sesión Consola de administración de AWS y abra la CodeDeploy consola en [https://console.aws.amazon.com/codedeploy.](https://console.aws.amazon.com/codedeploy)
**nota**
Inicie sesión con el mismo usuario que configuró en [Empezar con CodeDeploy](getting-started-codedeploy.md).
1. En el panel de navegación, expanda **Implementar** y, después, elija **Aplicaciones**.
1. **En la lista de aplicaciones, selecciona WordPress \$1App.**
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 **WordPress\$1DepGroup**.
1. En **Tipo de implementación**, elija **Implementación local**.
1. En **Configuración de entorno**, elija la pestaña **Instancias de Amazon EC2**.
1. En **Configuración del agente con AWS Systems Manager**, mantenga los valores predeterminados.
1. En **Clave**, introduzca **Name**.
1. En **Valor**, escriba **CodeDeployDemo**.
**nota**
Después de escribir**CodeDeployDemo**, aparecerá un **1** en **Instancias coincidentes** para confirmar que CodeDeploy se ha encontrado una instancia de Amazon EC2 coincidente.
1. **En **Configuración de implementación**, elijaCodeDeployDefault. OneAtATime**.
1. En **ARN de rol de servicio**, elija el ARN del rol de servicio y seleccione **Crear grupo de implementación**.
1. Elija **Crear implementación**.
1. En **Grupo de implementación**, elija **WordPress\$1DepGroup**.
1. Junto a **Tipo de repositorio**, elija **Mi aplicación está almacenada en Amazon S3**. En **Ubicación de revisión**, introduzca la ubicación de la revisión de la WordPress aplicación de muestra que cargó anteriormente 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 **WordPressApp.zip.**
1. En la pestaña **Overview** (Información general), copie el valor del campo **Link** (Enlace) en el portapapeles.
Debe ser similar al siguiente:
**https://s3.amazonaws.com/amzn-s3-demo-bucket/WordPressApp.zip**
1. Vuelva a la CodeDeploy consola y, en la **ubicación de revisión**, pegue el valor del campo **Enlace**.
1. Si en la lista **File type** (Tipo de archivo) aparece un mensaje en el que se indica que no se ha podido detectar el tipo de archivo, seleccione **.zip**.
1. (Opcional) Escriba un comentario en el cuadro **Deployment description**.
1. **Expanda **Anulaciones de grupos de despliegues** y, en **Configuración de despliegue**, seleccioneCodeDeployDefault. OneAtATime**.
1. Elija **Iniciar la 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-wordpress-deploy-application-monitor-cli)
+ [Para monitorizar y resolver problemas de la implementación (consola)](#tutorials-wordpress-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 **WordPress\$1App** y el grupo de implementaciones **WordPress\$1DepGroup**:
```
aws deploy list-deployments --application-name WordPress_App --deployment-group-name WordPress_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 nombre de la implementación. Cuando se produce un error en una implementación, aparece un mensaje que describe el motivo del error.
1. En **Actividad de instancia**, aparece más información sobre 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 continuar con la solución de problemas, puede aplicar una técnica como la descrita en [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
Una vez que la implementación se haya realizado correctamente, compruebe que WordPress la instalación funciona. Utilice la dirección DNS pública de la instancia de Amazon EC2 seguida de `/WordPress`, para ver el sitio 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/WordPress
```
Al ver el sitio en el navegador, debería ver una página de WordPress bienvenida similar a la siguiente:
![\[WordPress página de bienvenida\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/images/WordPress-Welcome-Page-013118.png)
Si su instancia de Amazon EC2 no tiene una regla de entrada HTTP agregada a su grupo de seguridad, la página de WordPress bienvenida no aparecerá. Si aparece un mensaje que indica que el servidor remoto no responde, asegúrese de que el grupo de seguridad de la instancia de Amazon EC2 tiene la regla de entrada. Para obtener más información, consulte [Adición de una regla de entrada que permite el tráfico HTTP hacia la instancia de Amazon EC2 de Amazon Linux o RHELAdición de una regla de entrada que permite el tráfico HTTP a la instancia de Amazon EC2 de Windows Server](tutorials-wordpress-launch-instance.md#tutorials-wordpress-launch-instance-add-inbound-rule).
# Paso 5: Actualizar y volver a implementar la aplicación WordPress
Ahora que has implementado correctamente la revisión de la aplicación, actualiza el WordPress código en la máquina de desarrollo y úsalo CodeDeploy para volver a implementar el sitio. Posteriormente, debería poder ver los cambios en el código en la instancia de Amazon EC2.
**Topics**
+ [Configura el sitio WordPress](#tutorials-wordpress-update-and-redeploy-application-configure-and-install)
+ [Modificación del sitio](#tutorials-wordpress-update-and-redeploy-application-modify-code)
+ [Nueva implementación del sitio](#tutorials-wordpress-update-and-redeploy-application-deploy-updates)
## Configura el sitio WordPress
Para ver los efectos del cambio de código, termine de configurar el WordPress sitio para que tenga una instalación completamente funcional.
1. Escriba la URL del sitio web en el navegador web. La URL es la dirección DNS pública de la instancia de Amazon EC2 con una extensión `/WordPress`. Para este WordPress sitio de ejemplo (y ejemplo de la dirección DNS pública de la instancia Amazon EC2), la URL es. **http://ec2-01-234-567-890.compute-1.amazonaws.com/WordPress**
1. Si aún no ha configurado el sitio, aparecerá la página de bienvenida WordPress predeterminada. Elija **¡Vamos\$1**.
1. En la página de configuración de la base de datos, escriba los siguientes valores para utilizar la base de datos MySQL predeterminada:
+ **Database Name (Nombre de la base de datos)**: **test**
+ **User Name (Nombre del usuario)**: **root**
+ **Contraseña**: déjela en blanco.
+ **Database Host (Host de base de datos)**: **localhost**
+ **Table Prefix (Prefijo de tabla)**: **wp\$1**
Elija **Submit** para configurar la base de datos.
1. Continúe con la configuración del sitio. En la página de **bienvenida**, rellena los valores que desees y selecciona **Instalar WordPress**. Cuando se haya completado la instalación, puede iniciar sesión en el panel.
**importante**
Durante el despliegue de la WordPress aplicación, el **change\$1permissions.sh** script actualizó los permisos de la `/tmp/WordPress` carpeta para que cualquiera pudiera escribir en ella. Este es un buen momento para ejecutar el siguiente comando para restringir los permisos, de forma que solo usted, el propietario, pueda escribir en ella:
```
chmod -R 755 /var/www/html/WordPress
```
## Modificación del sitio
Para modificar el WordPress sitio, vaya a la carpeta de la aplicación en su máquina de desarrollo:
```
cd /tmp/WordPress
```
Para modificar algunos colores del sitio, en el archivo `wp-content/themes/twentyfifteen/style.css`, utilice un editor de texto o **sed** para cambiar `#fff` a `#768331`.
En Linux u otros sistemas con **sed** GNU, utilice:
```
sed -i 's/#fff/#768331/g' wp-content/themes/twentyfifteen/style.css
```
En macOS, Unix u otros sistemas con **sed** BSD, utilice:
```
sed -i '' 's/#fff/#768331/g' wp-content/themes/twentyfifteen/style.css
```
## Nueva implementación del sitio
Ahora que ha modificado el código del sitio, utilice Amazon S3 CodeDeploy para volver a implementar el sitio.
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-wordpress-upload-application.md#tutorials-wordpress-upload-application-bundle-and-push-archive). (Cuando siga esas instrucciones, recuerde que no tiene que crear una aplicación). Asigne a la nueva revisión la misma clave que antes (**WordPressApp.zip**). Cárguela en el mismo bucket de Amazon S3 que creó anteriormente (por ejemplo, **amzn-s3-demo-bucket**).
Utilice la AWS CLI CodeDeploy consola o la CodeDeploy APIs para volver a implementar el sitio.
**Topics**
+ [Para volver implementar el sitio (CLI)](#tutorials-wordpress-update-and-redeploy-application-deploy-updates-cli)
+ [Para volver a implementar el sitio (consola)](#tutorials-wordpress-update-and-redeploy-application-deploy-updates-console)
### Para volver implementar el sitio (CLI)
Llame al comando **create-deployment** para crear una implementación basada en la revisión recién cargada. Utilice la aplicación **WordPress\$1App**, la configuración de implementación **CodeDeployDefault.OneAtATime**, el grupo de implementaciones **WordPress\$1DepGroup** y la revisión **WordPressApp.zip** del bucket **amzn-s3-demo-bucket**:
```
aws deploy create-deployment \
--application-name WordPress_App \
--deployment-config-name CodeDeployDefault.OneAtATime \
--deployment-group-name WordPress_DepGroup \
--s3-location bucket=amzn-s3-demo-bucket,bundleType=zip,key=WordPressApp.zip
```
Puede comprobar el estado de la implementación como se describe en [Monitorización y solución de problemas de la implementación](tutorials-wordpress-deploy-application.md#tutorials-wordpress-deploy-application-monitor).
Una vez CodeDeploy que haya redistribuido el sitio, vuelva a visitarlo en su navegador web para comprobar que se han cambiado los colores. (Puede que tenga que actualizar el navegador). Si los colores han cambiado, ¡enhorabuena\$1 Ha modificado y vuelto a implementar correctamente su sitio.
### Para volver a implementar el sitio (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, después, elija **Aplicaciones**.
1. **En la lista de aplicaciones, selecciona WordPress \$1App.**
1. En la pestaña **Deployment groups (Grupos de implementaciones)**, elija **WordPress\$1DepGroup**.
1. Elija **Crear implementación**.
1. En la página **Create deployment**:
1. En **Deployment group (Grupo de implementación)**, elija **WordPress\$1DepGroup**.
1. En el área **Tipo de repositorio**, seleccione **Mi aplicación está almacenada en Amazon S3** y luego copie el enlace de Amazon S3 de la revisión en el cuadro **Ubicación de la revisión**. Para encontrar el valor del enlace:
1. En una pestaña diferente del navegador:
Inicie sesión en la consola de Amazon S3 Consola de administración de AWS y ábrala en [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
Vaya al archivo **amzn-s3-demo-bucket**, ábralo y elija la re visión **WordPressApp.zip**.
1. Si el panel **Propiedades** no se muestra en la consola de Amazon S3, elija el botón **Propiedades**.
1. En el panel de **propiedades**, copie el valor del campo **Enlace** en el cuadro **Ubicación de la revisión** de la CodeDeploy consola.
1. Si aparece un mensaje que indica que el tipo de archivo no se pudo detectar, elija **.zip**.
1. Deje el cuadro **Deployment description** en blanco.
1. **Expanda **Anulaciones de grupos** de despliegues y, en **Configuración de despliegue**, seleccioneCodeDeployDefault. OneAtATime**.
1. Elija **Iniciar la implementación**. En la página **Deployments** se mostrará información sobre la implementación que acaba de crear.
1. Puede comprobar el estado de la implementación como se describe en [Monitorización y solución de problemas de la implementación](tutorials-wordpress-deploy-application.md#tutorials-wordpress-deploy-application-monitor).
Una vez CodeDeploy que haya redistribuido el sitio, vuelva a visitarlo en su navegador web para comprobar que se han cambiado los colores. (Puede que tenga que actualizar el navegador). Si los colores han cambiado, ¡enhorabuena\$1 Ha modificado y vuelto a implementar correctamente su sitio.
# Paso 6: Limpiar WordPress la aplicación y los recursos relacionados
Ahora has realizado correctamente una actualización del WordPress código y has vuelto a implementar el sitio. Para evitar cargos recurrentes por los recursos que ha creado para 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 `WordPress_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-wordpress-clean-up-cli)
+ [Para limpiar los recursos (consola)](#tutorials-wordpress-clean-up-console)
+ [Siguientes pasos](#tutorials-wordpress-clean-up-whats-next)
## Para limpiar los recursos (CLI)
1. Si usó nuestra CloudFormation plantilla para este tutorial, **delete-stack** ejecute el comando contra la pila nombrada. **CodeDeployDemoStack** Así terminará todas las instancias Amazon EC2 asociadas y eliminará todos los roles de IAM que haya creado 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í eliminará el bucket y todos los objetos que contiene:
```
aws s3 rm s3://amzn-s3-demo-bucket --recursive --region region
```
1. Para eliminar la aplicación `WordPress_App`, realice una llamada al comando **delete-application**. Esto eliminará también todos los registros de grupo de implementaciones asociados y los registros de implementación de la aplicación:
```
aws deploy delete-application --application-name WordPress_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
```
Puedes obtenerla *association-id* llamando al **describe-association** comando.
```
aws ssm describe-association --name AWS-ConfigureAWSPackage --targets Key=tag:Name,Values=CodeDeployDemo
```
Si no usó la CloudFormation pila para este tutorial, **terminate-instances** ejecute el comando para terminar cualquier instancia de Amazon EC2 que haya creado 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 **Filtro**, escribe el nombre de la CloudFormation pila que creaste anteriormente (por ejemplo,**CodeDeployDemoStack**).
1. Seleccione la casilla junto al nombre de la pila. En el menú **Actions (Acciones)**, elija **Delete Stack (Eliminar pila)**.
CloudFormation elimina la pila, cierra todas las instancias de Amazon EC2 adjuntas y elimina todas las funciones de IAM correspondientes.
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 la lista **INSTANCES**, elija **Instances**.
1. En el campo de búsqueda, escriba el nombre de la instancia de Amazon EC2 que desee finalizar (por ejemplo, **CodeDeployDemo**) y, a continuación, pulse Intro.
1. Seleccione el nombre de la instancia de Amazon EC2.
1. En el menú **Actions**, seleccione **Instance State** y elija **Terminate**. Cuando se le pregunte, elija **Yes, Terminate**.
Repita estos pasos para cada instancia.
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 que creó anteriormente (por ejemplo, **amzn-s3-demo-bucket**).
1. Para eliminar un bucket, primero debe eliminar su contenido. Seleccione todos los archivos del bucket, como **WordPressApp.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 `WordPress_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. **En la lista de aplicaciones, selecciona WordPress \$1App.**
1. En la página **Application details (Detalles de la aplicación)**, elija **Delete application (Eliminar aplicación)**.
1. Cuando se le solicite, introduzca el nombre de la aplicación para confirmar que desea eliminarla y seleccione **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 hasta aquí, ¡enhorabuena\$1 Ha completado correctamente una implementación de CodeDeploy, ha actualizado el código del sitio y lo ha vuelto a implementar.