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 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 como{{replaceable}}; sin embargo, es posible que desee modificar otros parámetros para adaptarlos a su situación. Resumen de las tareas y requisitos: RFCs 1. Cree la infraestructura: 1. [Crear una pila de RDS (CLI)](ex-WP-stack-rds-create.md) 1. Cree un equilibrador de carga 1. Cree un grupo de escalado automático y vincúlelo al balanceador de cargas 1. Cree un bucket de S3 para las aplicaciones CodeDeploy 1. Cree un paquete de WordPress aplicaciones (no requiere un RFC) 1. Implemente el paquete WordPress de aplicaciones con CodeDeploy: 1. Cree una CodeDeploy aplicación 1. Cree un grupo CodeDeploy de despliegue 1. Cargue el paquete de WordPress aplicaciones en el bucket de S3 (no requiere un RFC) 1. Implemente la aplicación CodeDeploy 1. Valide el despliegue 1. 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](https://docs.aws.amazon.com/managedservices/latest/userguide/create-rfcs.html); para obtener una explicación de los parámetros de RFC comunes, consulte Parámetros comunes de [RFC](https://docs.aws.amazon.com/managedservices/latest/userguide/rfc-common-params.html). ## 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. 1. 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. 1. 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. 1. 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 ``` 1. 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** {{DBName}}Sustitúyalo por el valor indicado en el RFC de HA Stack (por ejemplo,`wordpress`). {{DB\_MasterUsername}}Sustitúyalo por el `MasterUsername` valor indicado en el RFC de HA Stack (por ejemplo,`admin`). {{DB\_MasterUserPassword}}Sustitúyalo por el `MasterUserPassword` valor indicado en el RFC de HA Stack (por ejemplo,`p4ssw0rd`). {{DB\_ENDPOINT}}Sustitú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 [GetRfc](https://docs.aws.amazon.com/managedservices/latest/ApiReference-cm/API_GetRfc.html)operació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 ``` 1. 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. 1. 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 ``` 1. En el mismo directorio, cree `stop_server.sh` con el siguiente contenido: ``` #!/bin/bash service httpd stop ``` 1. 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. + `ChangeTypeId`y`ChangeTypeVersion`: El identificador de tipo de cambio para este tutorial es`ct-0ah3gwb9seqk2`: para encontrar la última versión, ejecute este comando: ``` aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=ct-0ah3gwb9seqk2 ``` 1. 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 ``` 1. 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}}" } } ``` 1. 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 ``` 1. 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}}" } ``` 1. 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. 1. Envíe el RFC: ``` aws amscm submit-rfc --rfc-id {{RFC_ID}} ``` Si la RFC se realiza correctamente, no recibirá ningún resultado. 1. 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. + `ChangeTypeId`y`ChangeTypeVersion`: El identificador de tipo de cambio para este tutorial es`ct-2gd0u847qd9d2`, para encontrar la última versión, ejecute este comando: ``` aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=ct-2gd0u847qd9d2 ``` 1. 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 ``` 1. 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" } } ``` 1. 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 ``` 1. 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}}" } ``` 1. 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. 1. Envíe el RFC: ``` aws amscm submit-rfc --rfc-id {{RFC_ID}} ``` Si la RFC se realiza correctamente, no recibirá ningún resultado. 1. 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](https://docs.aws.amazon.com/managedservices/latest/userguide/using-bastions.html)) 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` y`S3Key`: el tipo y el nombre del paquete que colocó en su tienda de S3. + `ChangeTypeId`y`ChangeTypeVersion`: El identificador de tipo de cambio de este tutorial es`ct-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 ``` 1. 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 ``` 1. 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}}" } } } } ``` 1. 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 ``` 1. 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}}" } ``` 1. 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. 1. 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*: 1. 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 ``` 1. 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}}\"}" } ``` 1. 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. 1. 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. 1. 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 ```