Avviso di fine del supporto: il 30 giugno 2027, AWS terminerà il supporto per AMS Advanced. Dopo il 30 giugno 2027, non sarà più possibile accedere alla console AMS Advanced o alle risorse AMS Advanced. Per ulteriori informazioni, vedere Fine del supporto [ per ](https://docs.aws.amazon.com/managedservices/latest/userguide/SunsetPlan.html) AMS Advanced.
Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# 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 come{{replaceable}}; tuttavia, è possibile modificare altri parametri in base alla propria situazione.
Riepilogo delle attività e delle attività richieste RFCs:
1. Crea l'infrastruttura:
1. [Creare uno stack RDS (CLI)](ex-WP-stack-rds-create.md)
1. Creazione di un sistema di bilanciamento del carico
1. Crea un gruppo di Auto Scaling e collegalo al load balancer
1. Crea un bucket S3 per le applicazioni CodeDeploy
1. Crea un pacchetto di WordPress applicazioni (non richiede una RFC)
1. Distribuisci il pacchetto di WordPress applicazioni con: CodeDeploy
1. Crea un'applicazione CodeDeploy
1. Creare un gruppo CodeDeploy di distribuzione
1. Carica il tuo pacchetto di WordPress applicazioni nel bucket S3 (non richiede una RFC)
1. Implementa l' CodeDeploy applicazione
1. Convalida la distribuzione
1. 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](https://docs.aws.amazon.com/managedservices/latest/userguide/create-rfcs.html); per una spiegazione dei parametri RFC comuni, vedere Parametri comuni [RFC](https://docs.aws.amazon.com/managedservices/latest/userguide/rfc-common-params.html).
## Crea un pacchetto di WordPress applicazioni per CodeDeploy
Questa sezione fornisce un esempio di creazione di un pacchetto di distribuzione delle applicazioni.
1. 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.
1. 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.
1. 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
```
1. 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'[GetRfc](https://docs.aws.amazon.com/managedservices/latest/ApiReference-cm/API_GetRfc.html)operazione (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
```
1. `install_dependencies.sh`Nella 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.
1. 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
```
1. Nella stessa directory create `stop_server.sh` con il seguente contenuto:
```
#!/bin/bash
service httpd stop
```
1. 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.
+ `ChangeTypeId`e`ChangeTypeVersion`: 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
```
1. 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
```
1. 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}}"
}
}
```
1. 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
```
1. 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}}"
}
```
1. 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.
1. Invia la RFC:
```
aws amscm submit-rfc --rfc-id {{RFC_ID}}
```
Se la RFC ha esito positivo, non riceverai alcun output.
1. 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.
+ `ChangeTypeId`e`ChangeTypeVersion`: 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
```
1. 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
```
1. 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"
}
}
```
1. 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
```
1. 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}}"
}
```
1. 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.
1. Invia la RFC:
```
aws amscm submit-rfc --rfc-id {{RFC_ID}}
```
Se la RFC ha esito positivo, non riceverai alcun output.
1. 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](https://docs.aws.amazon.com/managedservices/latest/userguide/using-bastions.html)) 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` e`S3Key`: il tipo e il nome del pacchetto che hai inserito nel tuo negozio S3.
+ `ChangeTypeId`e`ChangeTypeVersion`: 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
```
1. 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
```
1. Modificate il file JSON come segue; potete eliminare e sostituire il contenuto. Per`S3Bucket`, 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}}" }
}
}
}
```
1. 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
```
1. 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}}"
}
```
1. 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.
1. 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*:
1. 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
```
1. 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}}\"}"
}
```
1. 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.
1. 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.
1. 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
```