Creación de un RFC mediante la CLI Cree un paquete de WordPress aplicaciones para CodeDeploy Implemente el paquete de WordPress aplicaciones con CodeDeploy Valide la implementación de la aplicación Destruya el despliegue de la aplicación

Tutorial de CLI: Implementación de un WordPress sitio web Tier and Tie

En esta sección se describe cómo implementar un WordPress sitio de alta disponibilidad (HA) en un entorno AMS mediante la CLI de AMS. Este conjunto de instrucciones incluye un ejemplo de cómo crear el archivo WordPress CodeDeploy de paquete compatible necesario (por ejemplo, zip).

nota

Este tutorial de implementación está diseñado para usarse en un entorno Linux de AMZN.

Los parámetros de las variables esenciales están anotados comoreplaceable; sin embargo, es posible que desee modificar otros parámetros para adaptarlos a su situación.

Resumen de las tareas y requisitos: RFCs

Cree la infraestructura:
1. Crear una pila de RDS (CLI)
2. Cree un equilibrador de carga
3. Cree un grupo de escalado automático y vincúlelo al balanceador de cargas
4. Cree un bucket de S3 para las aplicaciones CodeDeploy
Cree un paquete de WordPress aplicaciones (no requiere un RFC)
Implemente el paquete WordPress de aplicaciones con CodeDeploy:
1. Cree una CodeDeploy aplicación
2. Cree un grupo CodeDeploy de despliegue
3. Cargue el paquete de WordPress aplicaciones en el bucket de S3 (no requiere un RFC)
4. Implemente la aplicación CodeDeploy
Valide el despliegue
Destruya el despliegue

Siga todos los pasos de la línea de comandos desde su cuenta autenticada.

Creación de un RFC mediante la CLI

Para obtener información detallada sobre la creación RFCs, consulte Creación RFCs; para obtener una explicación de los parámetros de RFC comunes, consulte Parámetros comunes de RFC.

Cree un paquete de WordPress aplicaciones para CodeDeploy

En esta sección se proporciona un ejemplo de cómo crear un paquete de despliegue de aplicaciones.

Descargue WordPress, extraiga los archivos y cree un. directorio /scripts.

Comando de Linux:
```
wget https://github.com/WordPress/WordPress/archive/master.zip
```
Windows: pégalo https://github.com/WordPress/WordPress/archive/master.zip en una ventana del navegador y descarga el archivo zip.

Cree un directorio temporal en el que ensamblar el paquete.

Linux:
```
mkdir /tmp/WordPress
```
Windows: cree un directorio WordPress «», utilizará la ruta del directorio más adelante.
Extraiga la WordPress fuente al directorio WordPress «» y cree un. directorio /scripts.

Linux:
```
unzip master.zip -d /tmp/WordPress_Temp
cp -paf /tmp/WordPress_Temp/WordPress-master/* /tmp/WordPress
rm -rf /tmp/WordPress_Temp
rm -f master
cd /tmp/WordPress
mkdir scripts
```
Windows: vaya al directorio «WordPress» que creó y cree allí un directorio de «scripts».

Si se encuentra en un entorno Windows, asegúrese de establecer el tipo de interrupción de los archivos de script en Unix (LF). En Notepad ++, esta opción se encuentra en la parte inferior derecha de la ventana.
Cree el archivo CodeDeploy appspec.yml en el WordPress directorio (si va a copiar el ejemplo, compruebe la hendidura, cada espacio cuenta). IMPORTANTE: Asegúrese de que la ruta «fuente» sea correcta para copiar los WordPress archivos (en este caso, en su WordPress directorio) al destino esperado (/). var/www/html/WordPress En el ejemplo, el archivo appspec.yml está en el directorio con los WordPress archivos, por lo que solo se necesita «/». Además, aunque haya utilizado una AMI de RHEL para su grupo de Auto Scaling, deje la línea «os: linux» tal como está. Ejemplo de archivo appspec.yml:
```
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/config_wordpress.sh
      timeout: 300
      runas: root
  ApplicationStart:
    - location: scripts/start_server.sh
      timeout: 300
      runas: root
  ApplicationStop:
    - location: scripts/stop_server.sh
      timeout: 300
      runas: root
```
Cree scripts de archivos bash en. WordPress directorio /scripts.

En primer lugar, cree config_wordpress.sh con el siguiente contenido (si lo prefiere, puede editar el archivo wp-config.php directamente).

nota
DBNameSustitúyalo por el valor indicado en el RFC de HA Stack (por ejemplo,wordpress).
DB_MasterUsernameSustitúyalo por el MasterUsername valor indicado en el RFC de HA Stack (por ejemplo,admin).
DB_MasterUserPasswordSustitúyalo por el MasterUserPassword valor indicado en el RFC de HA Stack (por ejemplo,p4ssw0rd).
DB_ENDPOINTSustitúyalo por el nombre DNS del punto final en los resultados de ejecución del RFC de la pila HA (por ejemplo,srt1cz23n45sfg.clgvd67uvydk.us-east-1.rds.amazonaws.com). Puede encontrarlo en la GetRfcoperación (CLI: get-rfc --rfc-id RFC_ID) o en la página de detalles del RFC de la consola AMS para el RFC de la pila de alta disponibilidad que envió anteriormente.
```
#!/bin/bash
chmod -R 755 /var/www/html/WordPress
cp /var/www/html/WordPress/wp-config-sample.php /var/www/html/WordPress/wp-config.php
cd /var/www/html/WordPress
sed -i "s/database_name_here/DBName/g" wp-config.php
sed -i "s/username_here/DB_MasterUsername/g" wp-config.php
sed -i "s/password_here/DB_MasterUserPassword/g" wp-config.php
sed -i "s/localhost/DB_ENDPOINT/g" wp-config.php
```
En install_dependencies.sh el mismo directorio, cree con el siguiente contenido:
```
#!/bin/bash
yum install -y php
yum install -y php-mysql
yum install -y mysql
service httpd restart
```
nota
HTTPS se instala como parte de los datos del usuario en el momento del lanzamiento para permitir que las comprobaciones de estado funcionen desde el principio.
En el mismo directorio, cree start_server.sh con el siguiente contenido:
- Para las instancias de Amazon Linux, usa lo siguiente:
```
#!/bin/bash
service httpd start
```
- Para las instancias de RHEL, usa esto (los comandos adicionales son políticas que permiten que SELINUX las acepte): WordPress
```
#!/bin/bash
setsebool -P  httpd_can_network_connect_db 1
setsebool -P  httpd_can_network_connect 1
chcon -t httpd_sys_rw_content_t /var/www/html/WordPress/wp-content -R
restorecon -Rv /var/www/html
service httpd start
```
En el mismo directorio, cree stop_server.sh con el siguiente contenido:
```
#!/bin/bash
service httpd stop
```
Cree el paquete zip.

Linux:
```
$ cd /tmp/WordPress
$ zip -r wordpress.zip .
```
Windows: Ve a tu directorio WordPress «», selecciona todos los archivos y crea un archivo zip, asegúrate de llamarlo wordpress.zip.

Implemente el paquete de WordPress aplicaciones con CodeDeploy

CodeDeploy Es un servicio de implementación de AWS que automatiza las implementaciones de aplicaciones en las instancias de Amazon EC2 . Esta parte del proceso implica la creación de una CodeDeploy aplicación, la creación de un grupo de CodeDeploy implementación y, a continuación, la implementación de la aplicación mediante. CodeDeploy

Cree una CodeDeploy aplicación

La CodeDeploy aplicación es simplemente un nombre o contenedor que AWS utiliza CodeDeploy para garantizar que se haga referencia a la revisión, la configuración de implementación y el grupo de implementación correctos durante una implementación. La configuración de despliegue, en este caso, es el WordPress paquete que creó anteriormente.

DATOS NECESARIOS:

VpcId: La VPC que está utilizando debe ser la misma que la VPC utilizada anteriormente.
CodeDeployApplicationName: Debe ser única en la cuenta. Consulte la CodeDeploy consola para comprobar los nombres de las aplicaciones existentes.
ChangeTypeIdyChangeTypeVersion: El identificador de tipo de cambio para este tutorial esct-0ah3gwb9seqk2: para encontrar la última versión, ejecute este comando:
```
aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=ct-0ah3gwb9seqk2
```

Envía el esquema JSON de los parámetros de ejecución de la CodeDeploy aplicación CT a un archivo de tu carpeta actual; en el ejemplo, se llama Create CDApp Params.json.
```
aws amscm get-change-type-version --change-type-id "ct-0ah3gwb9seqk2" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > CreateCDAppParams.json
```

Modifique y guarde el archivo JSON de la siguiente manera; puede eliminar y reemplazar el contenido.


{
"Description":                      "Create WordPress CodeDeploy App",
"VpcId":                            "VPC_ID",
"StackTemplateId":                  "stm-sft6rv00000000000",
"Name":                             "WordPressCDApp",
"TimeoutInMinutes":                 60,
"Parameters":   {
    "CodeDeployApplicationName":    "WordPressCDApp"
    }
}

Envía la plantilla JSON CreateRfc a un archivo de tu carpeta actual; en el ejemplo, se llama Create CDApp RFC.json.
```
aws amscm create-rfc --generate-cli-skeleton > CreateCDAppRfc.json
```
Modifica y guarda el archivo JSON de la siguiente manera; puedes eliminar y reemplazar el contenido. Tenga en cuenta que RequestedStartTime ahora RequestedEndTime son opcionales; si se excluyen, el RFC se ejecuta tan pronto como se aprueba (lo que normalmente ocurre automáticamente). Para enviar una RFC «programada», añada esos valores.
```
{
"ChangeTypeVersion":    "1.0",
"ChangeTypeId":         "ct-0ah3gwb9seqk2",
"Title":                "CD-App-For-WP-Stack-RFC"
}
```
Cree el RFC especificando el archivo de creación de CDApp RFC y el archivo de parámetros de ejecución:
```
aws amscm create-rfc --cli-input-json file://CreateCDAppRfc.json --execution-parameters file://CreateCDAppParams.json
```
Recibirá el ID de RFC de la nueva RFC en la respuesta. Guarde el ID para los pasos siguientes.
Envíe el RFC:
```
aws amscm submit-rfc --rfc-id RFC_ID
```
Si la RFC se realiza correctamente, no recibirá ningún resultado.
Envíe el RFC:
```
aws amscm get-rfc --rfc-id RFC_ID
```

Cree un grupo de CodeDeploy implementación

Cree el grupo CodeDeploy de despliegue.

Un grupo de CodeDeploy implementación define un conjunto de instancias individuales destinadas a una implementación.

DATOS NECESARIOS:

VpcId: La VPC que está utilizando debe ser la misma que la VPC utilizada anteriormente.
CodeDeployApplicationName: Utilice el valor que creó anteriormente.
CodeDeployAutoScalingGroups: Use el nombre del grupo de Auto Scaling que creó anteriormente.
CodeDeployDeploymentGroupName: un nombre para el grupo de implementación. Este nombre debe ser único para cada aplicación asociada al grupo de implementaciones.
CodeDeployServiceRoleArn: Utilice la fórmula que se proporciona en el ejemplo.
ChangeTypeIdyChangeTypeVersion: El identificador de tipo de cambio para este tutorial esct-2gd0u847qd9d2, para encontrar la última versión, ejecute este comando:
```
aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=ct-2gd0u847qd9d2
```

Envía el esquema JSON de los parámetros de ejecución a un archivo de tu carpeta actual; en el ejemplo, se llama Create CDDep GroupParams .json.


aws amscm get-change-type-version --change-type-id "ct-2gd0u847qd9d2" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > CreateCDDepGroupParams.json

Modifique y guarde el archivo JSON de la siguiente manera; puede eliminar y reemplazar el contenido.


{
"Description":                      "CreateWPCDDeploymentGroup",
"VpcId":                            "VPC_ID",
"StackTemplateId":                  "stm-sp9lrk00000000000",
"Name":                             "WordPressCDAppGroup",
"TimeoutInMinutes":                 60,
"Parameters":   {
    "CodeDeployApplicationName":        "WordPressCDApp",
    "CodeDeployAutoScalingGroups":      ["ASG_NAME"],
    "CodeDeployDeploymentConfigName":   "CodeDeployDefault.HalfAtATime",
    "CodeDeployDeploymentGroupName":    "UNIQUE_CDDepGroupNAME",
    "CodeDeployServiceRoleArn":         "arn:aws:iam::ACCOUNT_ID:role/aws-codedeploy-role"
    }
}

Envía la plantilla JSON CreateRfc a un archivo de tu carpeta actual; en el ejemplo, se llama Create CDDep GroupRfc .json.
```
aws amscm create-rfc --generate-cli-skeleton > CreateCDDepGroupRfc.json
```
Modifica y guarda el archivo JSON de la siguiente manera; puedes eliminar y reemplazar el contenido. Tenga en cuenta que RequestedStartTime ahora RequestedEndTime son opcionales; si se excluyen, el RFC se ejecuta tan pronto como se aprueba (lo que normalmente ocurre automáticamente). Para enviar una RFC «programada», añada esos valores.
```
{
"ChangeTypeVersion":    "1.0",
"ChangeTypeId":         "ct-2gd0u847qd9d2",
"Title":                "CD-Dep-Group-For-WP-Stack-RFC"
}
```
Cree el RFC especificando el archivo de creación y el CDDep GroupRfc archivo de parámetros de ejecución:
```
aws amscm create-rfc --cli-input-json file://CreateCDDepGroupRfc.json --execution-parameters file://CreateCDDepGroupParams.json
```
Recibirá el ID de RFC de la nueva RFC en la respuesta. Guarde el ID para los pasos siguientes.
Envíe el RFC:
```
aws amscm submit-rfc --rfc-id RFC_ID
```
Si la RFC se realiza correctamente, no recibirá ningún resultado.
Compruebe el estado del RFC:
```
aws amscm get-rfc --rfc-id RFC_ID
```

Cargue la solicitud WordPress

Tendrá acceso automáticamente a cualquier instancia de bucket de S3 que cree. Puede acceder a él a través de sus Bastions (consulte Acceso a las instancias) o a través de la consola S3 y cargar el CodeDeploy paquete. El paquete debe estar en su lugar para poder seguir desplegando la pila. En el ejemplo, se usa el nombre del bucket creado anteriormente.


aws s3 cp wordpress/wordpress.zip s3://ACCOUNT_ID-codedeploy-bundles/

Implemente la WordPress aplicación con CodeDeploy

Implemente la CodeDeploy aplicación.

Una vez que tenga el paquete de CodeDeploy aplicaciones y el grupo de implementación, utilice esta RFC para implementar la aplicación.

DATOS NECESARIOS:

VPC-ID: La VPC que está utilizando debe ser la misma que la VPC utilizada anteriormente.
CodeDeployApplicationName: Use el nombre de la CodeDeploy aplicación que creó anteriormente.
CodeDeployDeploymentGroupName: utilice el nombre del grupo de CodeDeploy despliegue que creó anteriormente.
S3Location(donde cargó el paquete de aplicaciones)S3Bucket:: El BucketName que creó anteriormente S3BundleType yS3Key: el tipo y el nombre del paquete que colocó en su tienda de S3.
ChangeTypeIdyChangeTypeVersion: El identificador de tipo de cambio de este tutorial esct-2edc3sd1sqmrb: Para encontrar la versión más reciente, ejecute este comando:
```
aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=ct-2edc3sd1sqmrb
```

Envía el esquema JSON de los parámetros de ejecución para el CT de despliegue de la CodeDeploy aplicación a un archivo de tu carpeta actual; en el ejemplo, se llama Deploy CDApp Params.json.
```
aws amscm get-change-type-version --change-type-id "ct-2edc3sd1sqmrb" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > DeployCDAppParams.json
```

Modifique el archivo JSON de la siguiente manera; puede eliminar y reemplazar el contenido. Para S3Bucket ello, usa el BucketName que creaste anteriormente.


{
"Description":                      "Deploy WordPress CodeDeploy Application",
"VpcId":                            "VPC_ID",
"Name":                             "WP CodeDeploy Deployment Group",
"TimeoutInMinutes":                 60,
"Parameters":   {
    "CodeDeployApplicationName":        "WordPressCDApp",
    "CodeDeployDeploymentGroupName":    "WordPressCDDepGroup",
    "CodeDeployIgnoreApplicationStopFailures": false,
    "CodeDeployRevision": {
      "RevisionType": "S3",
      "S3Location": {
        "S3Bucket": "ACCOUNT_ID.BUCKET_NAME",
        "S3BundleType": "zip",
        "S3Key": "wordpress.zip" }
        }
    }
}

Envía la plantilla JSON CreateRfc a un archivo de tu carpeta actual; en el ejemplo, se llama Deploy CDApp RFC.json:
```
aws amscm create-rfc --generate-cli-skeleton > DeployCDAppRfc.json
```

Modifica y guarda el archivo Deploy CDApp rfc.json; puedes eliminar y reemplazar el contenido.


{
"ChangeTypeVersion":    "1.0",
"ChangeTypeId":         "ct-2edc3sd1sqmrb",
"Title":                "CD-Deploy-For-WP-Stack-RFC",
"RequestedStartTime":   "2017-04-28T22:45:00Z",
"RequestedEndTime":     "2017-04-28T22:45:00Z"
}

Cree el RFC especificando el archivo de parámetros de ejecución y el archivo RFC de despliegueCDApp:
```
aws amscm create-rfc --cli-input-json file://DeployCDAppRfc.json  --execution-parameters file://DeployCDAppParams.json
```
Recibirá el RfcId nuevo RFC en la respuesta. Guarde el ID para los pasos siguientes.
Envíe el RFC:
```
aws amscm submit-rfc --rfc-id RFC_ID
```
Si la RFC se realiza correctamente, no recibirá ningún resultado.

Valide la implementación de la aplicación

Navegue hasta el punto final (ELB CName) del balanceador de cargas creado anteriormente, con la ruta WordPress implementada:/. WordPress Por ejemplo:


http://stack-ID-FOR-ELB.us-east-1.elb.amazonaws.com/WordPress

Destruya el despliegue de la aplicación

Para desglosar la implementación, debe enviar el Delete Stack CT a la pila de bases de datos de RDS, el balanceador de carga de aplicaciones, el grupo Auto Scaling, el bucket S3 y la aplicación y el grupo Code Deploy (seis en total). RFCs Además, puede enviar una solicitud de servicio para eliminar las instantáneas de RDS (se eliminan automáticamente al cabo de diez días, pero su permanencia en ellas cuesta un pequeño importe). Reúna la pila IDs para todas y, a continuación, siga estos pasos.

Este tutorial proporciona un ejemplo del uso de la consola AMS para eliminar una pila S3; este procedimiento se aplica a la eliminación de cualquier pila mediante la consola AMS.

nota

Si borras un depósito de S3, primero debes vaciarlo de objetos.

DATOS NECESARIOS:

StackId: La pila que se va a utilizar. Puedes encontrarlo consultando la página de pilas de consolas de AMS, disponible a través de un enlace en la barra de navegación izquierda. Con la API/CLI de AMS SKMS, ejecute la operación Para la referencia de la API de AMS SKMS, consulte la pestaña Informes de la AWS Artifact Console. (en la CLI). list-stack-summaries
El identificador de tipo de cambio para este tutorial es que la versión es ct-0q0bic0ywqk6c «1.0". Para averiguar cuál es la versión más reciente, ejecute este comando:
```
aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=ct-0q0bic0ywqk6c
```

CREACIÓN EN LÍNEA:

Ejecute el comando create RFC con los parámetros de ejecución proporcionados en línea (comillas de escape cuando se proporcionan los parámetros de ejecución en línea). E
```
aws amscm create-rfc --change-type-id "ct-0q0bic0ywqk6c" --change-type-version "1.0" --title "Delete My Stack" --execution-parameters "{\"StackId\":\"STACK_ID\"}"
```
Envíe la RFC mediante el ID de RFC devuelto en la operación de creación de la RFC. Hasta que se envíe, la RFC permanece en ese Editing estado y no se toman medidas al respecto.
```
aws amscm submit-rfc --rfc-id RFC_ID
```
Supervise el estado de la RFC y vea el resultado de la ejecución:
```
aws amscm get-rfc --rfc-id RFC_ID
```

CREACIÓN DE PLANTILLA:

Envía la plantilla RFC a un archivo de tu carpeta actual; el ejemplo la nombra DeleteStackRfc .json:
```
aws amscm create-rfc --generate-cli-skeleton > DeleteStackRfc.json
```
Modifique y guarde el DeleteStackRfc archivo.json. Como la eliminación de una pila solo tiene un parámetro de ejecución, los parámetros de ejecución pueden estar en el propio DeleteStackRfc archivo.json (no es necesario crear un archivo JSON independiente con los parámetros de ejecución).

Las comillas internas de la extensión ExecutionParameters JSON deben ir precedidas de una barra invertida (\). Ejemplo sin hora de inicio y finalización:
```
{
"ChangeTypeVersion":    "1.0",
"ChangeTypeId":         "ct-0q0bic0ywqk6c",
"Title":                "Delete-My-Stack-RFC"
"ExecutionParameters":  "{
        \"StackId\":\"STACK_ID\"}"
}
```

Cree el RFC:


aws amscm create-rfc --cli-input-json file://DeleteStackRfc.json

Recibirá el RfcId nuevo RFC en la respuesta. Por ejemplo:


{
"RfcId": "daaa1867-ffc5-1473-192a-842f6b326102"
}

Guarde el ID para los pasos siguientes.

Envíe el RFC:
```
aws amscm submit-rfc --rfc-id RFC_ID
```
Si la RFC se realiza correctamente, no recibirá ninguna confirmación en la línea de comandos.

Para supervisar el estado de la solicitud y ver el resultado de la ejecución:


aws amscm get-rfc --rfc-id RFC_ID --query "Rfc.{Status:Status.Name,Exec:ExecutionOutput}" --output table

Aviso JavaScript está desactivado o no está disponible en su navegador.

Para utilizar la documentación de AWS, debe estar habilitado JavaScript. Para obtener más información, consulte las páginas de ayuda de su navegador.

Convenciones del documento

Destruya la implementación de aplicaciones

Cree la infraestructura