Création d'une RFC à l'aide de la CLI Créez un bundle WordPress d'applications pour CodeDeploy Déployez le bundle WordPress d'applications avec CodeDeploy Valider le déploiement de l'application Démanteler le déploiement de l'application

Tutoriel CLI : Déploiement d'un WordPress site Web Tier and Tie

Cette section décrit comment déployer un WordPress site haute disponibilité (HA) dans un environnement AMS à l'aide de la CLI AMS. Cet ensemble d'instructions inclut un exemple de création du fichier de package WordPress CodeDeploy compatible nécessaire (par exemple, zip).

Note

Cette procédure de déploiement est conçue pour être utilisée avec un environnement Linux AMZN.

Les paramètres variables essentiels sont notés comme suit replaceable ; toutefois, vous souhaiterez peut-être modifier d'autres paramètres en fonction de votre situation.

Résumé des tâches et des exigences RFCs :

Créez l'infrastructure :
1. Création d'une pile RDS (CLI)
2. Créer un équilibreur de charge
3. Créez un groupe Auto Scaling et associez-le à l'équilibreur de charge
4. Création d'un compartiment S3 pour les CodeDeploy applications
Création d'un bundle d' WordPress applications (ne nécessite pas de RFC)
Déployez le bundle WordPress d'applications avec CodeDeploy :
1. Création d'une CodeDeploy application
2. Création d'un groupe CodeDeploy de déploiement
3. Téléchargez votre bundle WordPress d'applications dans le compartiment S3 (aucune RFC n'est requise)
4. Déployez l' CodeDeploy application
Valider le déploiement
Démanteler le déploiement

Suivez toutes les étapes de la ligne de commande depuis votre compte authentifié.

Création d'une RFC à l'aide de la CLI

Pour des informations détaillées sur la création RFCs, voir Création RFCs ; pour une explication des paramètres RFC courants, voir Paramètres communs RFC.

Créez un bundle WordPress d'applications pour CodeDeploy

Cette section fournit un exemple de création d'un bundle de déploiement d'applications.

Téléchargez WordPress, extrayez les fichiers et créez un. répertoire /scripts.

Commande Linux :
```
wget https://github.com/WordPress/WordPress/archive/master.zip
```
Windows : collez https://github.com/WordPress/WordPress/archive/master.zip le fichier dans une fenêtre de navigateur et téléchargez le fichier zip.

Créez un répertoire temporaire dans lequel assembler le package.

Linux :
```
mkdir /tmp/WordPress
```
Windows : Créez un répertoire WordPress « », vous utiliserez le chemin du répertoire ultérieurement.
Extrayez la WordPress source dans le répertoire WordPress « » et créez un fichier. répertoire /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 : Accédez au répertoire « WordPress » que vous avez créé et créez-y un répertoire « scripts ».

Si vous êtes dans un environnement Windows, veillez à définir le type de rupture des fichiers de script sur Unix (LF). Dans Notepad ++, il s'agit d'une option en bas à droite de la fenêtre.
Créez le fichier CodeDeploy appspec.yml dans le WordPress répertoire (si vous copiez l'exemple, vérifiez l'indentation, chaque espace compte). IMPORTANT : Assurez-vous que le chemin « source » est correct pour copier les WordPress fichiers (dans ce cas, dans votre WordPress répertoire) vers la destination prévue (/var/www/html/WordPress). Dans l'exemple, le fichier appspec.yml se trouve dans le répertoire contenant les WordPress fichiers, donc seul «/» est nécessaire. De plus, même si vous avez utilisé une AMI RHEL pour votre groupe Auto Scaling, laissez la ligne « os : linux » telle quelle. Exemple de fichier 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
```
Créez des scripts de fichiers bash dans le WordPress . répertoire /scripts.

Commencez config_wordpress.sh par créer avec le contenu suivant (si vous préférez, vous pouvez modifier directement le fichier wp-config.php).

Note
Remplacez DBName par la valeur indiquée dans la RFC HA Stack (par exemple,wordpress).
Remplacez DB_MasterUsername par la MasterUsername valeur indiquée dans la RFC HA Stack (par exemple,admin).
Remplacez DB_MasterUserPassword par la MasterUserPassword valeur indiquée dans la RFC HA Stack (par exemple,p4ssw0rd).
DB_ENDPOINTRemplacez-le par le nom DNS du point de terminaison dans les sorties d'exécution de la HA Stack RFC (par exemple,srt1cz23n45sfg.clgvd67uvydk.us-east-1.rds.amazonaws.com). Vous pouvez le trouver dans l'GetRfcopération (CLI : get-rfc --rfc-id RFC_ID) ou dans la page de détails de la RFC de la console AMS pour la RFC HA Stack que vous avez précédemment soumise.
```
#!/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
```
Dans le même répertoire, créez install_dependencies.sh avec le contenu suivant :
```
#!/bin/bash
yum install -y php
yum install -y php-mysql
yum install -y mysql
service httpd restart
```
Note
Le protocole HTTPS est installé dans les données utilisateur au lancement afin de permettre aux bilans de santé de fonctionner dès le départ.
Dans le même répertoire, créez start_server.sh avec le contenu suivant :
- Pour les instances Amazon Linux, utilisez ceci :
```
#!/bin/bash
service httpd start
```
- Pour les instances RHEL, utilisez ceci (les commandes supplémentaires sont des politiques qui autorisent SELINUX à accepter) : 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
```
Dans le même répertoire, créez stop_server.sh avec le contenu suivant :
```
#!/bin/bash
service httpd stop
```
Créez le bundle zip.

Linux :
```
$ cd /tmp/WordPress
$ zip -r wordpress.zip .
```
Windows : Accédez à votre répertoire WordPress « », sélectionnez tous les fichiers et créez un fichier zip. N'oubliez pas de le nommer wordpress.zip.

Déployez le bundle WordPress d'applications avec CodeDeploy

CodeDeploy Il s'agit d'un service de déploiement AWS qui automatise les déploiements d'applications sur les instances Amazon EC2 . Cette partie du processus implique la création d'une CodeDeploy application, la création d'un groupe de CodeDeploy déploiement, puis le déploiement de l'application à l'aide de CodeDeploy.

Création d'une CodeDeploy application

L' CodeDeploy application est simplement un nom ou un conteneur utilisé par AWS CodeDeploy pour garantir que la révision, la configuration de déploiement et le groupe de déploiement appropriés sont référencés lors d'un déploiement. La configuration de déploiement, dans ce cas, est le WordPress bundle que vous avez créé précédemment.

DONNÉES REQUISES :

VpcId: Le VPC que vous utilisez doit être le même que le VPC utilisé précédemment.
CodeDeployApplicationName: Doit être unique dans le compte. Consultez la CodeDeploy console pour vérifier les noms d'applications existants.
ChangeTypeIdet ChangeTypeVersion : L'ID de type de modification pour cette procédure pas à pas estct-0ah3gwb9seqk2, pour connaître la dernière version, exécutez cette commande :
```
aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=ct-0ah3gwb9seqk2
```

Exportez le schéma JSON des paramètres d'exécution pour l' CodeDeploy application CT dans un fichier de votre dossier actuel ; l'exemple le nomme Create CDApp Params.json.
```
aws amscm get-change-type-version --change-type-id "ct-0ah3gwb9seqk2" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > CreateCDAppParams.json
```

Modifiez et enregistrez le fichier JSON comme suit ; vous pouvez supprimer et remplacer le contenu.


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

Exportez le modèle JSON CreateRfc pour un fichier de votre dossier actuel ; l'exemple le nomme Create CDApp RFC.json.
```
aws amscm create-rfc --generate-cli-skeleton > CreateCDAppRfc.json
```
Modifiez et enregistrez le fichier JSON comme suit ; vous pouvez supprimer et remplacer le contenu. Notez que RequestedStartTime et RequestedEndTime sont désormais facultatifs ; leur exclusion entraîne l'exécution de la RFC dès qu'elle est approuvée (ce qui se produit généralement automatiquement). Pour soumettre une RFC « planifiée », ajoutez ces valeurs.
```
{
"ChangeTypeVersion":    "1.0",
"ChangeTypeId":         "ct-0ah3gwb9seqk2",
"Title":                "CD-App-For-WP-Stack-RFC"
}
```
Créez le RFC en spécifiant le fichier Create CDApp Rfc et le fichier de paramètres d'exécution :
```
aws amscm create-rfc --cli-input-json file://CreateCDAppRfc.json --execution-parameters file://CreateCDAppParams.json
```
Vous recevez l'ID RFC de la nouvelle RFC dans la réponse. Enregistrez l'identifiant pour les étapes suivantes.
Soumettez le RFC :
```
aws amscm submit-rfc --rfc-id RFC_ID
```
Si la RFC réussit, vous ne recevrez aucune sortie.
Soumettez le RFC :
```
aws amscm get-rfc --rfc-id RFC_ID
```

Création d'un groupe CodeDeploy de déploiement

Créez le groupe CodeDeploy de déploiement.

Un groupe de CodeDeploy déploiement définit un ensemble d'instances individuelles ciblées pour un déploiement.

DONNÉES REQUISES :

VpcId: Le VPC que vous utilisez doit être le même que le VPC utilisé précédemment.
CodeDeployApplicationName: utilisez la valeur que vous avez créée précédemment.
CodeDeployAutoScalingGroups: utilisez le nom du groupe Auto Scaling que vous avez créé précédemment.
CodeDeployDeploymentGroupName: nom du groupe de déploiement. Ce nom doit être unique pour chaque application associée au groupe de déploiement.
CodeDeployServiceRoleArn: Utilisez la formule donnée dans l'exemple.
ChangeTypeIdet ChangeTypeVersion : L'ID de type de modification pour cette procédure pas à pas estct-2gd0u847qd9d2, pour connaître la dernière version, exécutez cette commande :
```
aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=ct-2gd0u847qd9d2
```

Exportez le schéma JSON des paramètres d'exécution dans un fichier de votre dossier actuel ; l'exemple le nomme Create CDDep GroupParams .json.


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

Modifiez et enregistrez le fichier JSON comme suit ; vous pouvez supprimer et remplacer le contenu.


{
"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"
    }
}

Exportez le modèle JSON CreateRfc pour un fichier de votre dossier actuel ; l'exemple le nomme Create CDDep GroupRfc .json.
```
aws amscm create-rfc --generate-cli-skeleton > CreateCDDepGroupRfc.json
```
Modifiez et enregistrez le fichier JSON comme suit ; vous pouvez supprimer et remplacer le contenu. Notez que RequestedStartTime et RequestedEndTime sont désormais facultatifs ; leur exclusion entraîne l'exécution de la RFC dès qu'elle est approuvée (ce qui se produit généralement automatiquement). Pour soumettre une RFC « planifiée », ajoutez ces valeurs.
```
{
"ChangeTypeVersion":    "1.0",
"ChangeTypeId":         "ct-2gd0u847qd9d2",
"Title":                "CD-Dep-Group-For-WP-Stack-RFC"
}
```
Créez la RFC en spécifiant le fichier de création et le CDDep GroupRfc fichier de paramètres d'exécution :
```
aws amscm create-rfc --cli-input-json file://CreateCDDepGroupRfc.json --execution-parameters file://CreateCDDepGroupParams.json
```
Vous recevez l'ID RFC de la nouvelle RFC dans la réponse. Enregistrez l'identifiant pour les étapes suivantes.
Soumettez le RFC :
```
aws amscm submit-rfc --rfc-id RFC_ID
```
Si la RFC réussit, vous ne recevrez aucune sortie.
Vérifiez l'état de la RFC :
```
aws amscm get-rfc --rfc-id RFC_ID
```

Téléchargez l' WordPress application

Vous avez automatiquement accès à toutes les instances de compartiment S3 que vous créez. Vous pouvez y accéder via vos Bastions (voir Accès aux instances) ou via la console S3, et télécharger le CodeDeploy bundle. Le bundle doit être en place pour continuer à déployer la pile. L'exemple utilise le nom du bucket créé précédemment.


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

Déployez WordPress l'application avec CodeDeploy

Déployez CodeDeploy l'application.

Une fois que vous avez votre bundle CodeDeploy d'applications et votre groupe de déploiement, utilisez cette RFC pour déployer l'application.

DONNÉES REQUISES :

VPC-ID: Le VPC que vous utilisez doit être le même que le VPC utilisé précédemment.
CodeDeployApplicationName: utilisez le nom de l' CodeDeploy application que vous avez créée précédemment.
CodeDeployDeploymentGroupName: utilisez le nom du groupe de CodeDeploy déploiement que vous avez créé précédemment.
S3Location(où vous avez téléchargé le bundle d'applications) S3Bucket : le bundle BucketName que vous avez créé précédemment, S3BundleType et S3Key : le type et le nom du bundle que vous avez mis sur votre boutique S3.
ChangeTypeIdet ChangeTypeVersion : L'ID de type de modification pour cette procédure pas à pas estct-2edc3sd1sqmrb, pour connaître la dernière version, exécutez cette commande :
```
aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=ct-2edc3sd1sqmrb
```

Exportez le schéma JSON des paramètres d'exécution pour le déploiement de l' CodeDeploy application CT dans un fichier de votre dossier actuel ; l'exemple le nomme Deploy CDApp Params.json.
```
aws amscm get-change-type-version --change-type-id "ct-2edc3sd1sqmrb" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > DeployCDAppParams.json
```

Modifiez le fichier JSON comme suit ; vous pouvez supprimer et remplacer le contenu. PourS3Bucket, utilisez celui BucketName que vous avez créé précédemment.


{
"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" }
        }
    }
}

Exportez le modèle JSON CreateRfc pour un fichier de votre dossier actuel ; l'exemple le nomme Deploy CDApp RFC.json :
```
aws amscm create-rfc --generate-cli-skeleton > DeployCDAppRfc.json
```

Modifiez et enregistrez le fichier Deploy CDApp RFC.json ; vous pouvez supprimer et remplacer le contenu.


{
"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"
}

Créez la RFC en spécifiant le fichier de paramètres d'exécution et le fichier Deploy CDApp Rfc :
```
aws amscm create-rfc --cli-input-json file://DeployCDAppRfc.json  --execution-parameters file://DeployCDAppParams.json
```
Vous recevez le code RfcId de la nouvelle RFC dans la réponse. Enregistrez l'identifiant pour les étapes suivantes.
Soumettez le RFC :
```
aws amscm submit-rfc --rfc-id RFC_ID
```
Si la RFC réussit, vous ne recevrez aucune sortie.

Valider le déploiement de l'application

Accédez au point de terminaison (ELB CName) de l'équilibreur de charge créé précédemment, avec le chemin WordPress déployé :/. WordPress Exemples :


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

Démanteler le déploiement de l'application

Pour réduire le déploiement, vous soumettez le Delete Stack CT à la pile de base de données RDS, à l'équilibreur de charge de l'application, au groupe Auto Scaling, au compartiment S3, ainsi qu'à l'application et au groupe Code Deploy, soit six en tout. RFCs En outre, vous pouvez soumettre une demande de service pour que les instantanés RDS soient supprimés (ils sont supprimés automatiquement au bout de dix jours, mais ils coûtent peu cher pendant leur séjour). Rassemblez la pile IDs pour tous, puis suivez ces étapes.

Cette procédure pas à pas fournit un exemple d'utilisation de la console AMS pour supprimer une pile S3 ; cette procédure s'applique à la suppression de toute pile à l'aide de la console AMS.

Note

Si vous supprimez un compartiment S3, il doit d'abord être vidé de ses objets.

DONNÉES REQUISES :

StackId: La pile à utiliser. Vous pouvez le trouver en consultant la page AMS Console Stacks, disponible via un lien dans le menu de navigation de gauche. À l'aide de l'API/CLI AMS SKMS, exécutez la référence For the AMS SKMS API, voir l'onglet Rapports dans l'opération AWS Artifact Console (dans l'interface de ligne de commande). list-stack-summaries
L'identifiant du type de modification pour cette procédure pas à pas est « 1.0 ». Pour connaître la dernière version, exécutez cette commande : ct-0q0bic0ywqk6c
```
aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=ct-0q0bic0ywqk6c
```

CRÉATION EN LIGNE :

Émettez la commande create RFC avec les paramètres d'exécution fournis en ligne (évitez les guillemets lorsque vous fournissez des paramètres d'exécution en ligne). E
```
aws amscm create-rfc --change-type-id "ct-0q0bic0ywqk6c" --change-type-version "1.0" --title "Delete My Stack" --execution-parameters "{\"StackId\":\"STACK_ID\"}"
```
Soumettez le RFC à l'aide de l'ID RFC renvoyé lors de l'opération de création du RFC. Jusqu'à ce qu'elle soit soumise, la RFC reste en l'Editingétat et ne fait l'objet d'aucune action.
```
aws amscm submit-rfc --rfc-id RFC_ID
```
Surveillez l'état de la RFC et visualisez le résultat de l'exécution :
```
aws amscm get-rfc --rfc-id RFC_ID
```

CRÉATION D'UN MODÈLE :

Exportez le modèle RFC dans un fichier de votre dossier actuel ; l'exemple le nomme DeleteStackRfc .json :
```
aws amscm create-rfc --generate-cli-skeleton > DeleteStackRfc.json
```
Modifiez et enregistrez le fichier DeleteStackRfc .json. Comme la suppression d'une pile ne comporte qu'un seul paramètre d'exécution, les paramètres d'exécution peuvent se trouver dans le fichier DeleteStackRfc .json lui-même (il n'est pas nécessaire de créer un fichier JSON distinct avec les paramètres d'exécution).

Les guillemets internes de l'extension ExecutionParameters JSON doivent être masqués par une barre oblique inverse (\). Exemple sans heure de début et de fin :
```
{
"ChangeTypeVersion":    "1.0",
"ChangeTypeId":         "ct-0q0bic0ywqk6c",
"Title":                "Delete-My-Stack-RFC"
"ExecutionParameters":  "{
        \"StackId\":\"STACK_ID\"}"
}
```
Créez le RFC :
```
aws amscm create-rfc --cli-input-json file://DeleteStackRfc.json 
```
Vous recevez le code RfcId de la nouvelle RFC dans la réponse. Exemples :
```
{
"RfcId": "daaa1867-ffc5-1473-192a-842f6b326102"
}
```
Enregistrez l'identifiant pour les étapes suivantes.
Soumettez le RFC :
```
aws amscm submit-rfc --rfc-id RFC_ID
```
Si le RFC réussit, vous ne recevez aucune confirmation sur la ligne de commande.

Pour surveiller l'état de la demande et consulter le résultat de l'exécution, procédez comme suit :


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

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Démanteler le déploiement de l'application

Création de l'infrastructure