Creazione di un RFC utilizzando la CLI Crea un pacchetto di WordPress applicazioni per CodeDeploy Distribuisci l' WordPress Application Bundle con CodeDeploy Convalida la distribuzione dell'applicazione Annulla la distribuzione dell'applicazione

Tutorial CLI: implementazione di un sito Web Tier and Tie WordPress

Questa sezione descrive come implementare un WordPress sito ad alta disponibilità (HA) in un ambiente AMS utilizzando l'AMS CLI. Questo set di istruzioni include un esempio di creazione del necessario file di pacchetto WordPress CodeDeploy compatibile (ad esempio zip).

Nota

Questa procedura dettagliata di implementazione è progettata per l'uso con un ambiente Linux AMZN.

I parametri delle variabili essenziali sono indicati comereplaceable; tuttavia, è possibile modificare altri parametri in base alla propria situazione.

Riepilogo delle attività e delle attività richieste RFCs:

Crea l'infrastruttura:
1. Creare uno stack RDS (CLI)
2. Creazione di un sistema di bilanciamento del carico
3. Crea un gruppo di Auto Scaling e collegalo al load balancer
4. Crea un bucket S3 per le applicazioni CodeDeploy
Crea un pacchetto di WordPress applicazioni (non richiede una RFC)
Distribuisci il pacchetto di WordPress applicazioni con: CodeDeploy
1. Crea un'applicazione CodeDeploy
2. Creare un gruppo CodeDeploy di distribuzione
3. Carica il tuo pacchetto di WordPress applicazioni nel bucket S3 (non richiede una RFC)
4. Implementa l' CodeDeploy applicazione
Convalida la distribuzione
Distruggi la distribuzione

Segui tutti i passaggi indicati nella riga di comando dal tuo account autenticato.

Creazione di un RFC utilizzando la CLI

Per informazioni dettagliate sulla creazione RFCs, vedere Creazione RFCs; per una spiegazione dei parametri RFC comuni, vedere Parametri comuni RFC.

Crea un pacchetto di WordPress applicazioni per CodeDeploy

Questa sezione fornisce un esempio di creazione di un pacchetto di distribuzione delle applicazioni.

Scarica WordPress, estrai i file e crea un file. cartella /scripts.

Comando Linux:
```
wget https://github.com/WordPress/WordPress/archive/master.zip
```
Windows: incolla https://github.com/WordPress/WordPress/archive/master.zip in una finestra del browser e scarica il file zip.

Crea una directory temporanea in cui assemblare il pacchetto.

Linux:
```
mkdir /tmp/WordPress
```
Windows: crea una cartella "WordPress", utilizzerai il percorso della directory in seguito.
Estrai il WordPress codice sorgente nella cartella WordPress "" e crea un file. cartella /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: vai alla cartella "WordPress" che hai creato e lì crea una cartella «scripts».

Se utilizzate un ambiente Windows, assicuratevi di impostare il tipo di interruzione per i file di script su Unix (LF). In Notepad ++, questa è un'opzione in basso a destra della finestra.
Crea il file CodeDeploy appspec.yml, nella WordPress directory (se copi l'esempio, controlla l'indentazione, ogni spazio conta). IMPORTANTE: assicurati che il percorso «sorgente» sia corretto per copiare WordPress i file (in questo caso, nella tua WordPress directory) nella destinazione prevista (/). var/www/html/WordPress Nell'esempio, il file appspec.yml si trova nella directory con WordPress i file, quindi è necessario solo «/». Inoltre, anche se hai usato un'AMI RHEL per il tuo gruppo Auto Scaling, lascia la riga «os: linux» così com'è. Esempio di file 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
```
Crea script di file bash in. WordPress cartella /scripts.

Innanzitutto, crea config_wordpress.sh con il seguente contenuto (se preferisci, puoi modificare direttamente il file wp-config.php).

Nota
Sostituisci DBName con il valore fornito nell'HA Stack RFC (ad esempio,wordpress).
Sostituisci DB_MasterUsername con il MasterUsername valore fornito nell'HA Stack RFC (ad esempio,). admin
Sostituisci DB_MasterUserPassword con il MasterUserPassword valore fornito nell'HA Stack RFC (ad esempio,). p4ssw0rd
Sostituire DB_ENDPOINT con il nome DNS dell'endpoint negli output di esecuzione di HA Stack RFC (ad esempio,). srt1cz23n45sfg.clgvd67uvydk.us-east-1.rds.amazonaws.com Puoi trovarlo con l'GetRfcoperazione (CLI: get-rfc --rfc-id RFC_ID) o nella pagina dei dettagli RFC della console AMS per l'HA Stack RFC che hai inviato in precedenza.
```
#!/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
```
install_dependencies.shNella stessa directory, crea con il seguente contenuto:
```
#!/bin/bash
yum install -y php
yum install -y php-mysql
yum install -y mysql
service httpd restart
```
Nota
HTTPS viene installato come parte dei dati utente al momento del lancio per consentire il funzionamento dei controlli sanitari sin dall'inizio.

Nella stessa directory, crea start_server.sh con il seguente contenuto:

Per le istanze Amazon Linux, usa questo:
```
#!/bin/bash
service httpd start
```

Per le istanze RHEL, usa questo (i comandi aggiuntivi sono politiche che consentono a SELINUX di accettare): 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

Nella stessa directory create stop_server.sh con il seguente contenuto:
```
#!/bin/bash
service httpd stop
```
Crea il pacchetto zip.

Linux:
```
$ cd /tmp/WordPress
$ zip -r wordpress.zip .
```
Windows: vai alla cartella WordPress "" e seleziona tutti i file e crea un file zip, assicurati di chiamarlo wordpress.zip.

Distribuisci l' WordPress Application Bundle con CodeDeploy

CodeDeploy È un servizio di distribuzione AWS che automatizza le distribuzioni di applicazioni su istanze Amazon. EC2 Questa parte del processo prevede la creazione di un' CodeDeploy applicazione, la creazione di un gruppo di CodeDeploy distribuzione e quindi la distribuzione dell'applicazione utilizzando. CodeDeploy

Creare un'applicazione CodeDeploy

L' CodeDeploy applicazione è semplicemente un nome o un contenitore utilizzato da AWS CodeDeploy per garantire che durante una distribuzione venga fatto riferimento alla revisione, alla configurazione di distribuzione e al gruppo di distribuzione corretti. La configurazione di distribuzione, in questo caso, è il WordPress pacchetto creato in precedenza.

DATI RICHIESTI:

VpcId: Il VPC che stai usando dovrebbe essere lo stesso del VPC usato in precedenza.
CodeDeployApplicationName: Deve essere unico nell'account. Controlla la CodeDeploy console per verificare i nomi delle applicazioni esistenti.
ChangeTypeIdeChangeTypeVersion: L'ID del tipo di modifica per questa procedura dettagliata èct-0ah3gwb9seqk2, per scoprire la versione più recente, esegui questo comando:
```
aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=ct-0ah3gwb9seqk2
```

Invia lo schema JSON dei parametri di esecuzione per l' CodeDeploy applicazione CT in un file nella cartella corrente; l'esempio lo chiama Create Params.json. CDApp
```
aws amscm get-change-type-version --change-type-id "ct-0ah3gwb9seqk2" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > CreateCDAppParams.json
```

Modificate e salvate il file JSON come segue; potete eliminare e sostituire il contenuto.


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

Esporta il modello JSON CreateRfc per in un file nella cartella corrente; l'esempio lo chiama CDApp Create RFC.json.
```
aws amscm create-rfc --generate-cli-skeleton > CreateCDAppRfc.json
```
Modifica e salva il file JSON come segue; puoi eliminare e sostituire il contenuto. Nota che RequestedStartTime ora RequestedEndTime sono facoltativi; la loro esclusione fa sì che la RFC venga eseguita non appena viene approvata (cosa che di solito avviene automaticamente). Per inviare una RFC «pianificata», aggiungi questi valori.
```
{
"ChangeTypeVersion":    "1.0",
"ChangeTypeId":         "ct-0ah3gwb9seqk2",
"Title":                "CD-App-For-WP-Stack-RFC"
}
```
Crea la RFC, specificando il file Create CDApp Rfc e il file dei parametri di esecuzione:
```
aws amscm create-rfc --cli-input-json file://CreateCDAppRfc.json --execution-parameters file://CreateCDAppParams.json
```
Nella risposta riceverai l'ID RFC del nuovo RFC. Salva l'ID per i passaggi successivi.
Invia la RFC:
```
aws amscm submit-rfc --rfc-id RFC_ID
```
Se la RFC ha esito positivo, non riceverai alcun output.
Invia la RFC:
```
aws amscm get-rfc --rfc-id RFC_ID
```

Crea un gruppo di CodeDeploy distribuzione

Crea il gruppo CodeDeploy di distribuzione.

Un gruppo CodeDeploy di distribuzione definisce un insieme di istanze individuali destinate a una distribuzione.

DATI RICHIESTI:

VpcId: Il VPC che stai usando dovrebbe essere lo stesso del VPC usato in precedenza.
CodeDeployApplicationName: Usa il valore che hai creato in precedenza.
CodeDeployAutoScalingGroups: utilizza il nome del gruppo Auto Scaling creato in precedenza.
CodeDeployDeploymentGroupName: nome per il gruppo di distribuzione. Questo nome deve essere univoco per ogni applicazione associata al gruppo di distribuzione.
CodeDeployServiceRoleArn: Usa la formula fornita nell'esempio.
ChangeTypeIdeChangeTypeVersion: L'ID del tipo di modifica per questa procedura dettagliata èct-2gd0u847qd9d2, per scoprire la versione più recente, esegui questo comando:
```
aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=ct-2gd0u847qd9d2
```

Invia lo schema JSON dei parametri di esecuzione in un file nella cartella corrente; l'esempio lo chiama Create .json. CDDep GroupParams


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

Modifica e salva il file JSON come segue; puoi eliminare e sostituire il contenuto.


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

Esporta il modello JSON CreateRfc per in un file nella cartella corrente; l'esempio lo chiama CDDep GroupRfc Create .json.
```
aws amscm create-rfc --generate-cli-skeleton > CreateCDDepGroupRfc.json
```
Modifica e salva il file JSON come segue; puoi eliminare e sostituire il contenuto. Nota che RequestedStartTime ora RequestedEndTime sono facoltativi; la loro esclusione fa sì che la RFC venga eseguita non appena viene approvata (cosa che di solito avviene automaticamente). Per inviare una RFC «programmata», aggiungi questi valori.
```
{
"ChangeTypeVersion":    "1.0",
"ChangeTypeId":         "ct-2gd0u847qd9d2",
"Title":                "CD-Dep-Group-For-WP-Stack-RFC"
}
```
Create la RFC, specificando il CDDep GroupRfc file Create e il file dei parametri di esecuzione:
```
aws amscm create-rfc --cli-input-json file://CreateCDDepGroupRfc.json --execution-parameters file://CreateCDDepGroupParams.json
```
Nella risposta riceverai l'ID RFC della nuova RFC. Salva l'ID per i passaggi successivi.
Invia la RFC:
```
aws amscm submit-rfc --rfc-id RFC_ID
```
Se la RFC ha esito positivo, non riceverai alcun output.
Controlla lo stato della RFC:
```
aws amscm get-rfc --rfc-id RFC_ID
```

Carica l'applicazione WordPress

Hai automaticamente accesso a qualsiasi istanza di bucket S3 che crei. Puoi accedervi tramite i tuoi Bastions (vedi Accesso alle istanze) o tramite la console S3 e caricare il pacchetto. CodeDeploy Il pacchetto deve essere disponibile per continuare a distribuire lo stack. L'esempio utilizza il nome del bucket creato in precedenza.


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

Distribuisci l' WordPress applicazione con CodeDeploy

Distribuisci l' CodeDeploy applicazione.

Una volta che hai il pacchetto di CodeDeploy applicazioni e il gruppo di distribuzione, usa questa RFC per distribuire l'applicazione.

DATI RICHIESTI:

VPC-ID: Il VPC che stai utilizzando, dovrebbe essere lo stesso del VPC usato in precedenza.
CodeDeployApplicationName: Usa il nome dell' CodeDeploy applicazione che hai creato in precedenza.
CodeDeployDeploymentGroupName: utilizza il nome del gruppo di CodeDeploy distribuzione creato in precedenza.
S3Location(dove hai caricato il pacchetto di applicazioni):S3Bucket: BucketName Quello che hai creato in precedenza S3BundleType eS3Key: il tipo e il nome del pacchetto che hai inserito nel tuo negozio S3.
ChangeTypeIdeChangeTypeVersion: L'ID del tipo di modifica per questa procedura dettagliata èct-2edc3sd1sqmrb, per scoprire la versione più recente, esegui questo comando:
```
aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=ct-2edc3sd1sqmrb
```

Esporta lo schema JSON dei parametri di esecuzione per la distribuzione dell' CodeDeploy applicazione CT in un file nella cartella corrente; l'esempio lo chiama Deploy Params.json. CDApp
```
aws amscm get-change-type-version --change-type-id "ct-2edc3sd1sqmrb" --query "ChangeTypeVersion.ExecutionInputSchema" --output text > DeployCDAppParams.json
```

Modificate il file JSON come segue; potete eliminare e sostituire il contenuto. PerS3Bucket, usa BucketName quello che hai creato in precedenza.


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

Esporta il modello JSON in un file nella cartella corrente; l'esempio lo chiama Deploy CDApp RFC.json: CreateRfc
```
aws amscm create-rfc --generate-cli-skeleton > DeployCDAppRfc.json
```

Modifica e salva il file Deploy CDApp RFC.json; puoi eliminare e sostituire il contenuto.


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

Crea la RFC, specificando il file dei parametri di esecuzione e il file Deploy Rfc: CDApp
```
aws amscm create-rfc --cli-input-json file://DeployCDAppRfc.json  --execution-parameters file://DeployCDAppParams.json
```
Riceverai il RfcId nuovo RFC nella risposta. Salva l'ID per i passaggi successivi.
Invia la RFC:
```
aws amscm submit-rfc --rfc-id RFC_ID
```
Se la RFC ha esito positivo, non riceverai alcun output.

Convalida la distribuzione dell'applicazione

Passa all'endpoint (ELB CName) del sistema di bilanciamento del carico creato in precedenza, con il percorso distribuito:/. WordPress WordPress Ad esempio:


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

Annulla la distribuzione dell'applicazione

Per interrompere la distribuzione, inviate il Delete Stack CT allo stack di database RDS, all'application load balancer, al gruppo Auto Scaling, al bucket S3 e all'applicazione e al gruppo Code Deploy, sei in tutto. RFCs Inoltre, puoi inviare una richiesta di servizio per l'eliminazione degli snapshot RDS (vengono eliminati automaticamente dopo dieci giorni, ma costano una piccola somma). Raccogli lo stack IDs per tutti e poi segui questi passaggi.

Questa procedura dettagliata fornisce un esempio di utilizzo della console AMS per eliminare uno stack S3; questa procedura si applica all'eliminazione di qualsiasi stack utilizzando la console AMS.

Nota

Se si elimina un bucket S3, è necessario prima svuotarlo degli oggetti.

DATI RICHIESTI:

StackId: Lo stack da usare. Puoi trovarlo consultando la pagina AMS Console Stacks, disponibile tramite un link nel menu di navigazione a sinistra. Utilizzando l'API/CLI AMS SKMS, esegui il riferimento per l'API AMS SKMS, consulta la scheda Report nella Console AWS Artifact. Operazione (nella CLI). list-stack-summaries
L'ID del tipo di modifica per questa procedura dettagliata è «1.0"ct-0q0bic0ywqk6c, per scoprire la versione più recente, esegui questo comando:
```
aws amscm list-change-type-version-summaries --filter Attribute=ChangeTypeId,Value=ct-0q0bic0ywqk6c
```

CREAZIONE IN LINEA:

Esegui il comando create RFC con i parametri di esecuzione forniti in linea (evita le virgolette quando fornisci i parametri di esecuzione in linea). E


aws amscm create-rfc --change-type-id "ct-0q0bic0ywqk6c" --change-type-version "1.0" --title "Delete My Stack" --execution-parameters "{\"StackId\":\"STACK_ID\"}"

Invia la RFC utilizzando l'ID RFC restituito nell'operazione di creazione RFC. Fino all'invio, la RFC rimane nello Editing stato e non viene applicata.
```
aws amscm submit-rfc --rfc-id RFC_ID
```
Monitora lo stato RFC e visualizza l'output di esecuzione:
```
aws amscm get-rfc --rfc-id RFC_ID
```

CREAZIONE DEL MODELLO:

Esporta il modello RFC in un file nella cartella corrente; l'esempio lo chiama DeleteStackRfc .json:
```
aws amscm create-rfc --generate-cli-skeleton > DeleteStackRfc.json
```
Modifica e salva il file.json. DeleteStackRfc Poiché l'eliminazione di uno stack ha un solo parametro di esecuzione, i parametri di esecuzione possono essere contenuti nel DeleteStackRfc file.json stesso (non è necessario creare un file JSON separato con parametri di esecuzione).

Le virgolette interne dell'estensione ExecutionParameters JSON devono essere eliminate con una barra rovesciata (\). Esempio senza ora di inizio e fine:
```
{
"ChangeTypeVersion":    "1.0",
"ChangeTypeId":         "ct-0q0bic0ywqk6c",
"Title":                "Delete-My-Stack-RFC"
"ExecutionParameters":  "{
        \"StackId\":\"STACK_ID\"}"
}
```

Crea la RFC:


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

Riceverai RfcId il nuovo RFC nella risposta. Ad esempio:


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

Salva l'ID per i passaggi successivi.

Invia la RFC:
```
aws amscm submit-rfc --rfc-id RFC_ID
```
Se la RFC ha esito positivo, non riceverai alcuna conferma dalla riga di comando.

Per monitorare lo stato della richiesta e visualizzare l'output di esecuzione:


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

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Riduci la distribuzione delle applicazioni

Crea l'infrastruttura