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: Esegui WordPress la distribuzione su un'istanza Amazon EC2 (Amazon Linux o Red Hat Enterprise Linux e Linux, macOS o Unix)
In questo tutorial, WordPress distribuisci uno strumento di blogging open source e un sistema di gestione dei contenuti basato su PHP e MySQL su una singola istanza Amazon EC2 che esegue Amazon Linux o Red Hat Enterprise Linux (RHEL).
Non hai trovato ciò che cerchi?
+ Per fare pratica con la distribuzione su un'istanza Amazon EC2 che esegue invece Windows Server, consulta. [Tutorial: distribuisci un messaggio «ciao, mondo\$1» applicazione con CodeDeploy (Windows Server)](tutorials-windows.md)
+ Per fare pratica con la distribuzione su un'istanza locale anziché su un'istanza Amazon EC2, consulta. [Tutorial: Implementa un'applicazione su un'istanza locale con CodeDeploy (Windows Server, Ubuntu Server o Red Hat Enterprise Linux)](tutorials-on-premises-instance.md)
I passaggi di questo tutorial sono presentati dal punto di vista di una macchina di sviluppo locale che esegue Linux, macOS o Unix. Sebbene sia possibile completare buona parte della procedura su un computer locale che esegue Windows, occorrerà adattare le fasi che includono comandi quali **chmod** e **wget**, applicazioni come sed e percorsi di directory quali `/tmp`.
Prima di avviare questo tutorial, è necessario completare i prerequisiti in [Guida introduttiva con CodeDeploy](getting-started-codedeploy.md). Questi includono la configurazione di un utente, l'installazione o l'aggiornamento e la AWS CLI creazione di un profilo di istanza IAM e di un ruolo di servizio.
**Topics**
+ [Fase 1: Avvio e configurazione di un'istanza Amazon Linux o Red Hat Enterprise Linux Amazon EC2](tutorials-wordpress-launch-instance.md)
+ [Fase 2: configura il contenuto sorgente da distribuire sull'istanza Amazon Linux o Red Hat Enterprise Linux Amazon EC2](tutorials-wordpress-configure-content.md)
+ [Fase 3: carica l' WordPress applicazione su Amazon S3](tutorials-wordpress-upload-application.md)
+ [Fase 4: Implementazione dell'applicazione WordPress](tutorials-wordpress-deploy-application.md)
+ [Fase 5: Aggiornare e ridistribuire l'applicazione WordPress](tutorials-wordpress-update-and-redeploy-application.md)
+ [Passaggio 6: Pulisci WordPress l'applicazione e le risorse correlate](tutorials-wordpress-clean-up.md)
# Fase 1: Avvio e configurazione di un'istanza Amazon Linux o Red Hat Enterprise Linux Amazon EC2
Per distribuire l' WordPress applicazione CodeDeploy, avrai bisogno di un'istanza Amazon EC2 che esegua Amazon Linux o Red Hat Enterprise Linux (RHEL). L'istanza Amazon EC2 richiede una nuova regola di sicurezza in entrata che consenta le connessioni HTTP. Questa regola è necessaria per visualizzare la WordPress pagina in un browser dopo che è stata distribuita correttamente.
Segui le istruzioni in [Crea un'istanza Amazon EC2 per CodeDeploy](instances-ec2-create.md). Quando arrivi alla parte di queste istruzioni sull'assegnazione di un tag di istanza Amazon EC2 all'istanza, assicurati di specificare la chiave del tag e il valore **Name** del tag di. **CodeDeployDemo** (Se viene specificata una chiave o un valore del tag, le istruzioni in [Fase 4: Implementazione dell'applicazione WordPress](tutorials-wordpress-deploy-application.md) possono portare a risultati inaspettati).
Dopo aver seguito le istruzioni per avviare l'istanza Amazon EC2, torna a questa pagina e passa alla sezione successiva. Non continuare con [Crea un'applicazione con CodeDeploy](applications-create.md) il passaggio successivo.
## Connect alla tua istanza Amazon Linux o RHEL Amazon EC2
Dopo il lancio della tua nuova istanza Amazon EC2, segui queste istruzioni per esercitarti a connetterti ad essa.
1. Usa il **ssh** comando (o un emulatore di terminale compatibile con SSH come [PuTTY](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/putty.html)) per connetterti alla tua istanza Amazon Linux o RHEL Amazon EC2. Avrai bisogno dell'indirizzo DNS pubblico dell'istanza e della chiave privata per la coppia di chiavi utilizzata all'avvio dell'istanza Amazon EC2. Per ulteriori informazioni, consulta [Connect to Your Instance](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-connect-to-instance-linux.html).
Ad esempio, se l'indirizzo DNS pubblico è **ec2-01-234-567-890.compute-1.amazonaws.com** e la coppia di chiavi dell'istanza Amazon EC2 per l'accesso SSH è **codedeploydemo.pem** denominata, devi digitare:
```
ssh -i /path/to/codedeploydemo.pem ec2-user@ec2-01-234-567-890.compute-1.amazonaws.com
```
Sostituisci `/path/to/codedeploydemo.pem` con il percorso del `.pem` file e l'indirizzo DNS di esempio con l'indirizzo della tua istanza Amazon Linux o RHEL Amazon EC2.
**Nota**
Se si riceve un errore riguardo al fatto che le autorizzazioni della chiave del file sono troppo aperte, sarà necessario limitare le autorizzazioni per dare accesso solo all'utente attuale (tu). Ad esempio, con il **chmod** comando su Linux, macOS o Unix, digitare:
```
chmod 400 /path/to/codedeploydemo.pem
```
1. Dopo aver effettuato l'accesso, vedrai il banner AMI per l'istanza Amazon EC2. Per Amazon Linux, dovrebbe avere il seguente aspetto:
```
__| __|_ )
_| ( / Amazon Linux AMI
___|\___|___|
```
1. Ora puoi disconnetterti dall'istanza Amazon EC2 in esecuzione.
**avvertimento**
Non interrompere o terminare l'istanza Amazon EC2. In caso contrario, CodeDeploy non sarà possibile eseguire la distribuzione su di essa.
## Aggiungi una regola in entrata che consenta il traffico HTTP verso la tua istanza Amazon Linux o RHEL Amazon EC2
Il passaggio successivo conferma che l'istanza Amazon EC2 ha una porta HTTP aperta in modo da poter visualizzare la home page dell' WordPress applicazione distribuita in un browser.
1. Accedi Console di gestione AWS e apri la console Amazon EC2 all'indirizzo. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. Scegli **Istanze**, quindi scegli la tua istanza.
1. Nella scheda **Descrizione**, in **Gruppi di sicurezza**, scegli **Visualizza regole in entrata**.
Dovresti vedere un elenco di regole nel tuo gruppo di sicurezza come il seguente:
```
Security Groups associated with i-1234567890abcdef0
Ports Protocol Source launch-wizard-N
22 tcp 0.0.0.0/0 ✔
```
1. In **Gruppi di sicurezza**, scegli il gruppo di sicurezza per la tua istanza Amazon EC2. Potrebbe essere denominato **launch-wizard-*N***. Il nome ***N*** è un numero assegnato al proprio gruppo di sicurezza quando è stata creata l'istanza.
Seleziona la scheda **Inbound (In entrata)**. Se il gruppo di sicurezza per la tua istanza è configurato correttamente, dovresti vedere una regola con i seguenti valori:
+ **Type (Tipo)**: HTTP
+ **Protocollo**: TCP
+ **Port Range** (Intervallo porte): 80
+ **Fonte**: 0.0.0.0/0
1. Se non vedi una regola con questi valori, usa le procedure in [Aggiungere regole a un gruppo di sicurezza per aggiungerle a una](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/using-network-security.html#adding-security-group-rule) nuova regola di sicurezza.
# Fase 2: configura il contenuto sorgente da distribuire sull'istanza Amazon Linux o Red Hat Enterprise Linux Amazon EC2
È ora possibile configurare l'applicazione dei contenuti di origine in modo da avere materiale da distribuire all'istanza.
**Topics**
+ [Ottieni il codice sorgente](#tutorials-wordpress-configure-content-download-code)
+ [Crea script per eseguire la tua applicazione](#tutorials-wordpress-configure-content-create-scripts)
+ [Aggiungere un file di specifiche dell'applicazione](#tutorials-wordpress-configure-content-add-appspec-file)
## Ottieni il codice sorgente
In questo tutorial, distribuisci la piattaforma di pubblicazione WordPress dei contenuti dalla tua macchina di sviluppo all'istanza Amazon EC2 di destinazione. Per ottenere il codice WordPress sorgente, puoi utilizzare chiamate da riga di comando integrate. In alternativa, si può usare Git se è installato nel computer di sviluppo.
Per questi passaggi, supponiamo che tu abbia scaricato una copia del codice WordPress sorgente `/tmp` nella directory del tuo computer di sviluppo. È possibile scegliere una directory qualsiasi, ma ci si deve ricordare di sostituire la posizione per `/tmp` nel punto specificato in queste fasi.
Scegli una delle due opzioni seguenti per copiare i file WordPress sorgente sulla tua macchina di sviluppo. La prima opzione utilizza le chiamate della riga di comando integrata. La seconda usa Git.
**Topics**
+ [Per ottenere una copia del codice WordPress sorgente (chiamate da riga di comando integrate)](#tutorials-wordpress-configure-content-download-code-command-line)
+ [Per ottenere una copia del codice WordPress sorgente (Git)](#tutorials-wordpress-configure-content-download-code-git)
### Per ottenere una copia del codice WordPress sorgente (chiamate da riga di comando integrate)
1. Chiamate il **wget** comando per scaricare una copia del codice WordPress sorgente, come file.zip, nella directory corrente:
```
wget https://github.com/WordPress/WordPress/archive/master.zip
```
1. Chiamare i comandi **unzip**, **mkdir**, **cp** e **rm** per:
+ Decomprimere il file .zip `master` nella directory (cartella) `/tmp/WordPress_Temp`.
+ Copiare i contenuti estratti dallo zip nella cartella di destinazione `/tmp/WordPress`.
+ Eliminare la cartella temporanea `/tmp/WordPress_Temp` e il file `master`.
Eseguire uno alla volta i comandi:
```
unzip master -d /tmp/WordPress_Temp
```
```
mkdir -p /tmp/WordPress
```
```
cp -paf /tmp/WordPress_Temp/WordPress-master/* /tmp/WordPress
```
```
rm -rf /tmp/WordPress_Temp
```
```
rm -f master
```
Questo ti lascia con un set pulito di file di codice WordPress sorgente nella `/tmp/WordPress` cartella.
### Per ottenere una copia del codice WordPress sorgente (Git)
1. Scaricare e installare [Git](http://git-scm.com) sul computer di sviluppo.
1. Nella cartella `/tmp/WordPress`, chiamare il comando **git init**.
1. Chiamate il **git clone** comando per clonare l' WordPressarchivio pubblico, creandone una copia nella cartella di `/tmp/WordPress` destinazione:
```
git clone https://github.com/WordPress/WordPress.git /tmp/WordPress
```
Questo ti lascia con un set pulito di file di codice WordPress sorgente nella `/tmp/WordPress` cartella.
## Crea script per eseguire la tua applicazione
Quindi, crea una cartella e degli script nella directory. CodeDeploy utilizza questi script per configurare e distribuire la revisione dell'applicazione sull'istanza Amazon EC2 di destinazione. È possibile usare qualsiasi editor di testo per creare gli script.
1. Crea una directory di script nella tua copia del codice sorgente: WordPress
```
mkdir -p /tmp/WordPress/scripts
```
1. Creare un file `install_dependencies.sh` in `/tmp/WordPress/scripts`. Aggiungere le seguenti righe al file. Questo script `install_dependencies.sh` installa Apache, MySQL e PHP. Aggiunge inoltre il supporto MySQL a PHP.
```
#!/bin/bash
sudo amazon-linux-extras install php7.4
sudo yum install -y httpd mariadb-server php
```
1. Creare un file `start_server.sh` in `/tmp/WordPress/scripts`. Aggiungere le seguenti righe al file. Questo script `start_server.sh` avvia Apache e MySQL.
```
#!/bin/bash
systemctl start mariadb.service
systemctl start httpd.service
systemctl start php-fpm.service
```
1. Creare un file `stop_server.sh` in `/tmp/WordPress/scripts`. Aggiungere le seguenti righe al file. Questo script `stop_server.sh` arresta Apache e MySQL.
```
#!/bin/bash
isExistApp="pgrep httpd"
if [[ -n $isExistApp ]]; then
systemctl stop httpd.service
fi
isExistApp=pgrep mysqld
if [[ -n $isExistApp ]]; then
systemctl stop mariadb.service
fi
isExistApp=pgrep php-fpm
if [[ -n $isExistApp ]]; then
systemctl stop php-fpm.service
fi
```
1. Creare un file `create_test_db.sh` in `/tmp/WordPress/scripts`. Aggiungere le seguenti righe al file. Questo `create_test_db.sh` script utilizza MySQL per creare **test** un database WordPress da utilizzare.
```
#!/bin/bash
mysql -uroot <
Quindi, aggiungete un file di specifiche dell'applicazione (AppSpec file), un file in formato [YAML](http://www.yaml.org) utilizzato da per: CodeDeploy
+ Mappa i file di origine nella revisione dell'applicazione alle relative destinazioni sull'istanza Amazon EC2 di destinazione.
+ Specificare autorizzazioni personalizzate per i file distribuiti.
+ Specificare gli script da eseguire sull'istanza Amazon EC2 di destinazione durante la distribuzione.
Il AppSpec file deve avere un nome. `appspec.yml` Deve essere inserito nella directory root del codice sorgente dell'applicazione. In questo tutorial, la directory root è `/tmp/WordPress`.
Con un editor di testo, creare un file denominato `appspec.yml`. Aggiungere le seguenti righe al file:
```
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/change_permissions.sh
timeout: 300
runas: root
ApplicationStart:
- location: scripts/start_server.sh
- location: scripts/create_test_db.sh
timeout: 300
runas: root
ApplicationStop:
- location: scripts/stop_server.sh
timeout: 300
runas: root
```
CodeDeploy utilizza questo AppSpec file per copiare tutti i file nella `/tmp/WordPress` cartella sulla macchina di sviluppo nella `/var/www/html/WordPress` cartella sull'istanza Amazon EC2 di destinazione. Durante la distribuzione, CodeDeploy esegue gli script specificati come `root` nella `/var/www/html/WordPress/scripts` cartella sull'istanza Amazon EC2 di destinazione in occasione di eventi specifici durante il ciclo di vita della distribuzione, ad esempio e. **BeforeInstall** **AfterInstall** Se l'esecuzione di uno di questi script impiega più di 300 secondi (5 minuti), CodeDeploy interrompe la distribuzione e contrassegna la distribuzione come fallita.
Per ulteriori informazioni su queste impostazioni, consulta i [CodeDeploy AppSpec riferimento al file](reference-appspec-file.md).
**Importante**
Le ubicazioni e i numeri di spazi tra ciascuna delle voci in questo file sono importanti. Se la spaziatura non è corretta, CodeDeploy genera un errore di cui potrebbe essere difficile eseguire il debug. Per ulteriori informazioni, consulta [AppSpec Spaziatura tra i file](reference-appspec-file.md#reference-appspec-file-spacing).
# Fase 3: carica l' WordPress applicazione su Amazon S3
Ora preparerai e caricherai i tuoi contenuti di origine in una posizione da cui CodeDeploy distribuirli. Le seguenti istruzioni mostrano come effettuare il provisioning di un bucket Amazon S3, preparare i file di revisione dell'applicazione per il bucket, raggruppare i file della revisione e quindi inserire la revisione nel bucket.
**Nota**
Sebbene non sia trattato in questo tutorial, puoi CodeDeploy utilizzarlo per distribuire applicazioni dai repository alle istanze. GitHub Per ulteriori informazioni, consulta [Integrazione con CodeDeploy GitHub](integrations-partners-github.md).
**Topics**
+ [Esegui il provisioning di un bucket Amazon S3](#tutorials-wordpress-upload-application-create-s3-bucket)
+ [Prepara i file dell'applicazione per il bucket](#tutorials-wordpress-upload-application-prepare-application-files)
+ [Raggruppate i file dell'applicazione in un unico file di archivio e inviate il file di archivio](#tutorials-wordpress-upload-application-bundle-and-push-archive)
## Esegui il provisioning di un bucket Amazon S3
Crea un contenitore o un *bucket* di storage in Amazon S3 o usa un bucket esistente. Assicurati di poter caricare la revisione nel bucket e che le istanze Amazon EC2 utilizzate nelle distribuzioni possano scaricare la revisione dal bucket.
Puoi usare la AWS CLI console Amazon S3 o Amazon S3 per creare un APIs bucket Amazon S3. Dopo aver creato il bucket, assicurati di concedere le autorizzazioni di accesso al bucket e al tuo account. AWS
**Nota**
I nomi dei bucket devono essere univoci in Amazon S3 per AWS tutti gli account. Se non si è in grado di utilizzare **amzn-s3-demo-bucket**, provare un altro nome del bucket, ad esempio **amzn-s3-demo-bucket** seguito da un trattino e le iniziali o altri identificatori univoci. Assicurarsi quindi di sostituire il nome del bucket per **amzn-s3-demo-bucket** ovunque sia presente in questo tutorial.
Il bucket Amazon S3 deve essere creato nella stessa AWS regione in cui vengono lanciate le istanze Amazon EC2 di destinazione. Ad esempio, se crei il bucket nella regione Stati Uniti orientali (Virginia settentrionale), le istanze Amazon EC2 di destinazione devono essere avviate nella regione Stati Uniti orientali (Virginia settentrionale).
**Topics**
+ [Per creare un bucket Amazon S3 (CLI)](#tutorials-wordpress-upload-application-create-s3-bucket-cli)
+ [Per creare un bucket Amazon S3 (console)](#tutorials-wordpress-upload-application-create-s3-bucket-console)
+ [Concedi le autorizzazioni al bucket e all'account Amazon S3 AWS](#tutorials-wordpress-upload-application-create-s3-bucket-grant-permissions)
### Per creare un bucket Amazon S3 (CLI)
Chiama il **mb** comando per creare un bucket Amazon S3 denominato: **amzn-s3-demo-bucket**
```
aws s3 mb s3://amzn-s3-demo-bucket --region region
```
### Per creare un bucket Amazon S3 (console)
1. Apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Nella console Amazon S3, scegli **Crea** bucket.
1. Nella casella **Nome bucket**, digitare un nome per il bucket.
1. Nell'elenco **Regione** selezionare la regione di destinazione, quindi selezionare **Crea**.
### Concedi le autorizzazioni al bucket e all'account Amazon S3 AWS
È necessario disporre delle autorizzazioni per il caricamento nel bucket Amazon S3. Puoi specificare queste autorizzazioni tramite una policy sui bucket di Amazon S3. Ad esempio, nella seguente policy sui bucket di Amazon S3, l'utilizzo del carattere wildcard (\$1) consente `111122223333` all' AWS account di caricare file in qualsiasi directory del bucket Amazon S3 denominata: `amzn-s3-demo-bucket`
```
{
"Statement": [
{
"Action": [
"s3:PutObject"
],
"Effect": "Allow",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*",
"Principal": {
"AWS": [
"111122223333"
]
}
}
]
}
```
[Per visualizzare l'ID del tuo AWS account, consulta Finding Your account ID. AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/console_account-alias.html#FindingYourAWSId)
Ora è il momento giusto per verificare che il bucket Amazon S3 consenta le richieste di download da ogni istanza Amazon EC2 partecipante. Puoi specificarlo tramite una policy sui bucket di Amazon S3. Ad esempio, nella seguente policy sui bucket di Amazon S3, l'utilizzo del carattere wildcard (\$1) consente a qualsiasi istanza Amazon EC2 con un profilo di istanza IAM allegato contenente l'ARN di scaricare file `arn:aws:iam::444455556666:role/CodeDeployDemo` da qualsiasi directory del bucket Amazon S3 denominata: `amzn-s3-demo-bucket`
```
{
"Statement": [
{
"Action": [
"s3:Get*",
"s3:List*"
],
"Effect": "Allow",
"Resource": "arn:aws:s3:::amzn-s3-demo-bucket/*",
"Principal": {
"AWS": [
"arn:aws:iam::444455556666:role/CodeDeployDemo"
]
}
}
]
}
```
Per informazioni su come generare e allegare una bucket policy di Amazon S3, consulta Esempi di policy [Bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/example-bucket-policies.html).
Per informazioni su come creare e allegare una policy IAM, consulta [Working](https://docs.aws.amazon.com/IAM/latest/UserGuide/ManagingPolicies.html#AddingPermissions_Console) with policies.
## Prepara i file dell'applicazione per il bucket
Assicurati che i file WordPress dell'applicazione, il AppSpec file e gli script siano organizzati sulla tua macchina di sviluppo in modo simile al seguente:
```
/tmp/
|--WordPress/
|-- appspec.yml
|-- scripts/
| |-- change_permissions.sh
| |-- create_test_db.sh
| |-- install_dependencies.sh
| |-- start_server.sh
| |-- stop_server.sh
|-- wp-admin/
| |-- (various files...)
|-- wp-content/
| |-- (various files...)
|-- wp-includes/
| |-- (various files...)
|-- index.php
|-- license.txt
|-- readme.html
|-- (various files ending with .php...)
```
## Raggruppate i file dell'applicazione in un unico file di archivio e inviate il file di archivio
Raggruppa i file WordPress dell'applicazione e il AppSpec file in un file di archivio (noto come *revisione* dell'applicazione).
**Nota**
Potrebbero essere addebitati dei costi per lo storage degli oggetti in un bucket e per il trasferimento delle revisioni dell'applicazione dentro e fuori un bucket. Per ulteriori informazioni, consulta [Prezzi di Amazon S3](https://aws.amazon.com/s3/pricing/).
1. Sul computer di sviluppo, passare alla cartella in cui sono archiviati i file:
```
cd /tmp/WordPress
```
**Nota**
Se non si passa a questa cartella, il raggruppamento dei file verrà avviato nella cartella corrente. Ad esempio, se la cartella corrente è `/tmp` invece di `/tmp/WordPress`, il raggruppamento verrà quindi avviato con i file e le sottocartelle presenti nella cartella `tmp`, che può includere più di una sottocartella `WordPress`.
1. Chiamare il comando **create-application** per registrare una nuova applicazione denominata **WordPress\$1App**
```
aws deploy create-application --application-name WordPress_App
```
1. Richiama il comando CodeDeploy [push](https://docs.aws.amazon.com/cli/latest/reference/deploy/push.html) per raggruppare i file, caricare le revisioni su Amazon S3 e registrare le informazioni CodeDeploy sulla revisione caricata, il tutto in un'unica operazione.
```
aws deploy push \
--application-name WordPress_App \
--s3-location s3://amzn-s3-demo-bucket/WordPressApp.zip \
--ignore-hidden-files
```
Questo comando raggruppa i file dalla directory corrente (esclusi i file nascosti) in un unico file di archivio denominato**WordPressApp.zip**, carica la revisione nel **amzn-s3-demo-bucket** bucket e registra le informazioni sulla revisione caricata. CodeDeploy
# Fase 4: Implementazione dell'applicazione WordPress
Ora distribuisci la revisione dell' WordPress applicazione di esempio che hai caricato su Amazon S3. Puoi utilizzare la console AWS CLI o la CodeDeploy console per distribuire la revisione e monitorare l'avanzamento della distribuzione. Una volta distribuita la revisione dell'applicazione, si possono controllare i risultati.
**Topics**
+ [Implementa la revisione dell'applicazione con CodeDeploy](#tutorials-wordpress-deploy-application-create-deployment)
+ [Monitora e risolvi i problemi della distribuzione](#tutorials-wordpress-deploy-application-monitor)
+ [Verifica la tua implementazione](#tutorials-wordpress-deploy-application-verify-deployment)
## Implementa la revisione dell'applicazione con CodeDeploy
Usa la console AWS CLI o la console per distribuire la revisione dell'applicazione.
**Topics**
+ [Per distribuire la revisione dell'applicazione (CLI)](#tutorials-wordpress-deploy-application-create-deployment-cli)
+ [Per distribuire la revisione dell'applicazione (console)](#tutorials-wordpress-deploy-application-create-deployment-console)
### Per distribuire la revisione dell'applicazione (CLI)
1. La distribuzione richiede un gruppo di distribuzione. Tuttavia, prima di creare il gruppo di distribuzione, è necessario un ARN del ruolo del servizio. Un ruolo di servizio è un ruolo IAM che concede al servizio l'autorizzazione ad agire per tuo conto. In questo caso, il ruolo di servizio consente di CodeDeploy accedere alle istanze Amazon EC2 per espandere (leggere) i relativi tag di istanza Amazon EC2.
Per creare un ruolo del servizio occorre avere già eseguito le istruzioni in [Creare un ruolo di servizio (CLI)](getting-started-create-service-role.md#getting-started-create-service-role-cli). Per ottenere l'ARN del ruolo del servizio, consulta [Ottieni il ruolo di servizio ARN (CLI)](getting-started-create-service-role.md#getting-started-get-service-role-cli).
1. Ora che hai il ruolo di servizio ARN, chiama il **create-deployment-group** comando per creare un gruppo di distribuzione denominato**WordPress\$1DepGroup**, associato all'applicazione denominata**WordPress\$1App**, utilizzando il tag Amazon EC2 denominato e la configurazione di distribuzione **CodeDeployDemo** denominata: **CodeDeployDefault.OneAtATime**
```
aws deploy create-deployment-group \
--application-name WordPress_App \
--deployment-group-name WordPress_DepGroup \
--deployment-config-name CodeDeployDefault.OneAtATime \
--ec2-tag-filters Key=Name,Value=CodeDeployDemo,Type=KEY_AND_VALUE \
--service-role-arn serviceRoleARN
```
**Nota**
Il [create-deployment-group](https://docs.aws.amazon.com/cli/latest/reference/deploy/create-deployment-group.html)comando fornisce supporto per la creazione di trigger che comportano l'invio di notifiche Amazon SNS agli abbonati all'argomento su eventi specifici nelle distribuzioni e nelle istanze. Il comando supporta anche opzioni per il rollback automatico delle distribuzioni e l'impostazione di allarmi per interrompere le distribuzioni quando vengono raggiunte le soglie di monitoraggio negli allarmi Amazon. CloudWatch I comandi per queste azioni non sono inclusi in questo tutorial.
1. Prima di creare una distribuzione, l' CodeDeploy agente deve essere installato sulle istanze del gruppo di distribuzione. È possibile installare l'agente dalla riga di comando con AWS Systems Manager tramite il seguente comando:
```
aws ssm create-association \
--name AWS-ConfigureAWSPackage \
--targets Key=tag:Name,Values=CodeDeployDemo \
--parameters action=Install,name=AWSCodeDeployAgent \
--schedule-expression "cron(0 2 ? * SUN *)"
```
Questo comando crea un'associazione in Systems Manager State Manager che installerà l' CodeDeploy agente e quindi tenterà di aggiornarlo alle 2:00 ogni domenica mattina. Per ulteriori informazioni sull' CodeDeploy agente, vedere [Lavorare con l' CodeDeploy agente.](https://docs.aws.amazon.com/codedeploy/latest/userguide/codedeploy-agent.html) Per ulteriori informazioni su Systems Manager, vedere [What is AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/what-is-systems-manager.html).
1. Chiamare ora il comando **create-deployment** per creare una distribuzione associata all'applicazione denominata **WordPress\$1App**, la configurazione della distribuzione denominata **CodeDeployDefault.OneAtATime** e il gruppo di distribuzione denominato **WordPress\$1DepGroup** utilizzando la revisione dell'applicazione denominata **WordPressApp.zip** nel bucket denominato **amzn-s3-demo-bucket**:
```
aws deploy create-deployment \
--application-name WordPress_App \
--deployment-config-name CodeDeployDefault.OneAtATime \
--deployment-group-name WordPress_DepGroup \
--s3-location bucket=amzn-s3-demo-bucket,bundleType=zip,key=WordPressApp.zip
```
### Per distribuire la revisione dell'applicazione (console)
1. Prima di utilizzare la CodeDeploy console per distribuire la revisione dell'applicazione, è necessario un ARN per il ruolo di servizio. Un ruolo di servizio è un ruolo IAM che autorizza il servizio ad agire per conto dell'utente. In questo caso, il ruolo di servizio consente di CodeDeploy accedere alle istanze Amazon EC2 per espandere (leggere) i relativi tag di istanza Amazon EC2.
Per creare un ruolo del servizio occorre avere già eseguito le istruzioni in [Crea un ruolo di servizio (console)](getting-started-create-service-role.md#getting-started-create-service-role-console). Per ottenere l'ARN del ruolo del servizio, consulta [Ottieni il ruolo di servizio ARN (console)](getting-started-create-service-role.md#getting-started-get-service-role-console).
1. Ora che hai l'ARN, usa la CodeDeploy console per distribuire la revisione dell'applicazione:
[Accedi Console di gestione AWS e apri la CodeDeploy console all'indirizzo /codedeploy. https://console.aws.amazon.com](https://console.aws.amazon.com/codedeploy)
**Nota**
Accedi con lo stesso utente che hai configurato. [Guida introduttiva con CodeDeploy](getting-started-codedeploy.md)
1. Nel riquadro di navigazione, espandi **Distribuisci**, quindi scegli **Applicazioni**.
1. Nell'elenco delle applicazioni, scegli **WordPress\$1App**.
1. Nella scheda **Deployment groups (Gruppi di distribuzione)**, scegliere **Create deployment group (Crea gruppo di distribuzione)**.
1. In **Deployment group name (Nome del gruppo di distribuzione)**, immettere **WordPress\$1DepGroup**.
1. In **Deployment type (Tipo di distribuzione)** scegliere **In-place deployment (Distribuzione in loco)**.
1. Nella **configurazione dell'ambiente**, seleziona le **istanze Amazon EC2**.
1. Nella **configurazione dell'agente con AWS Systems Manager**, mantieni le impostazioni predefinite.
1. In **Key (Chiave)**, immettere **Name**.
1. In **Valore**, immetti **CodeDeployDemo**.
**Nota**
Dopo aver digitato**CodeDeployDemo**, dovrebbe apparire un **1** in **Istanze corrispondenti** per confermare che è CodeDeploy stata trovata un'istanza Amazon EC2 corrispondente.
1. **In **Configurazione di distribuzione, scegli**. CodeDeployDefault OneAtATime**.
1. In **Service role ARN (ARN ruolo di servizio)**, scegliere l'ARN del ruolo di servizio, quindi scegliere **Create deployment group (Crea gruppo di distribuzione)**.
1. Scegli **Create deployment (Crea distribuzione)**.
1. In **Deployment group (Gruppo di distribuzione)** scegliere **WordPress\$1DepGroup**.
1. Accanto a **Tipo di repository**, seleziona **La mia applicazione è archiviata in Amazon** S3. In **Luogo di revisione**, inserisci la posizione della revisione dell' WordPress applicazione di esempio che hai precedentemente caricato su Amazon S3. Per ottenere la posizione:
1. Apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Nell'elenco dei bucket, scegli **amzn-s3-demo-bucket (o il nome del bucket** in cui hai caricato la revisione dell'applicazione).
1. Nell'elenco degli **WordPressAppoggetti**, scegliete .zip.
1. Nella scheda **Panoramica** copiare negli Appunti il valore del campo **Link**.
Potrebbe essere simile al seguente:
**https://s3.amazonaws.com/amzn-s3-demo-bucket/WordPressApp.zip**
1. Torna alla CodeDeploy console e, nella **posizione Revisione**, incolla il valore del campo **Link**.
1. Se nell'elenco **File type (Tipo di file)** vene visualizzato un messaggio che informa che non è stato possibile trovare il tipo di file, scegliere **.zip**.
1. (Facoltativo) digitare un commento nella casella **Deployment description (Descrizione distribuzione)**.
1. **Espandi le sostituzioni del gruppo di distribuzione** **e, in **Configurazione di distribuzione**, scegli. CodeDeployDefault OneAtATime**.
1. Selezionare **Start deployment (Avvia distribuzione)**. Nella pagina **Deployments (Distribuzioni)** vengono visualizzate le informazioni relative alla nuova distribuzione creata.
## Monitora e risolvi i problemi della distribuzione
Usa la console AWS CLI o la console per monitorare e risolvere i problemi della distribuzione.
**Topics**
+ [Per monitorare e risolvere problemi relativi alla distribuzione (CLI)](#tutorials-wordpress-deploy-application-monitor-cli)
+ [Per monitorare e risolvere problemi relativi alla distribuzione (console)](#tutorials-wordpress-deploy-application-monitor-console)
### Per monitorare e risolvere problemi relativi alla distribuzione (CLI)
1. Ottenere l'ID della distribuzione chiamando il comando **list-deployments** rispetto all'applicazione denominata **WordPress\$1App** e il gruppo di distribuzione denominato **WordPress\$1DepGroup**:
```
aws deploy list-deployments --application-name WordPress_App --deployment-group-name WordPress_DepGroup --query 'deployments' --output text
```
1. Chiamare il comando **get-deployment** con l'ID di distribuzione:
```
aws deploy get-deployment --deployment-id deploymentID --query 'deploymentInfo.status' --output text
```
1. Il comando restituisce lo stato complessivo della distribuzione. In caso di esito positivo, il valore è `Succeeded`.
Se lo stato complessivo è `Failed`, è possibile chiamare comandi quali [list-deployment-instances](https://docs.aws.amazon.com/cli/latest/reference/deploy/list-deployment-instances.html) e [get-deployment-instance](https://docs.aws.amazon.com/cli/latest/reference/deploy/get-deployment-instance.html) per risolvere i problemi. Per ulteriori opzioni di risoluzione dei problemi, consulta [Analisi dei file di log per individuare gli errori di distribuzione nelle istanze](troubleshooting-ec2-instances.md#troubleshooting-deploy-failures).
### Per monitorare e risolvere problemi relativi alla distribuzione (console)
**Nella pagina **Distribuzioni** della CodeDeploy console, puoi monitorare lo stato della distribuzione nella colonna Stato.**
Per ottenere ulteriori informazioni sulla distribuzione, in particolare se il valore della colonna **Status (Stato)** è diverso da **Succeeded (Riuscito)**:
1. Nella scheda **Deployments (Distribuzioni)** scegliere il nome della distribuzione. Se una distribuzione non riesce, viene visualizzato un messaggio che descrive il motivo dell'errore.
1. In **Instance activity (Attività istanza)** vengono visualizzate altre informazioni sulla distribuzione. Dopo un errore di distribuzione, potresti essere in grado di determinare su quali istanze Amazon EC2 e in quale fase l'implementazione non è riuscita.
1. Se si vuole procedere alla risoluzione del problema, è possibile avvalersi di una tecnica come quella descritta in [Visualizza i dettagli dell'istanza con CodeDeploy](instances-view-details.md). Puoi anche analizzare i file di log di distribuzione su un'istanza Amazon EC2. Per ulteriori informazioni, consulta [Analisi dei file di log per individuare gli errori di distribuzione nelle istanze](troubleshooting-ec2-instances.md#troubleshooting-deploy-failures).
## Verifica la tua implementazione
Una volta completata la distribuzione, verifica che l' WordPress installazione funzioni. Utilizza l'indirizzo DNS pubblico dell'istanza Amazon EC2, seguito `/WordPress` da, per visualizzare il tuo sito in un browser Web. **(Per ottenere il valore DNS pubblico, nella console Amazon EC2, scegli l'istanza Amazon EC2 e, nella scheda Descrizione, cerca **il** valore di Public DNS.)**
Ad esempio, se l'indirizzo DNS pubblico della tua istanza Amazon EC2 **ec2-01-234-567-890.compute-1.amazonaws.com** è, utilizzerai il seguente URL:
```
http://ec2-01-234-567-890.compute-1.amazonaws.com/WordPress
```
Quando visualizzi il sito nel tuo browser, dovresti vedere una pagina di WordPress benvenuto simile alla seguente:
![\[WordPress pagina di benvenuto\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/images/WordPress-Welcome-Page-013118.png)
Se alla tua istanza Amazon EC2 non è stata aggiunta una regola di ingresso HTTP al relativo gruppo di sicurezza, la pagina di WordPress benvenuto non viene visualizzata. Se vedi un messaggio che indica che il server remoto non risponde, assicurati che il gruppo di sicurezza per la tua istanza Amazon EC2 abbia la regola in entrata. Per ulteriori informazioni, consulta [Aggiungi una regola in entrata che consenta il traffico HTTP verso la tua istanza Amazon Linux o RHEL Amazon EC2Aggiungi una regola in entrata che consenta il traffico HTTP verso la tua istanza Amazon EC2 di Windows Server](tutorials-wordpress-launch-instance.md#tutorials-wordpress-launch-instance-add-inbound-rule).
# Fase 5: Aggiornare e ridistribuire l'applicazione WordPress
Ora che hai distribuito correttamente la revisione dell'applicazione, aggiorna il WordPress codice sulla macchina di sviluppo e CodeDeploy usalo per ridistribuire il sito. Successivamente, dovresti vedere le modifiche al codice sull'istanza Amazon EC2.
**Topics**
+ [Configura il sito WordPress](#tutorials-wordpress-update-and-redeploy-application-configure-and-install)
+ [Modifica il sito](#tutorials-wordpress-update-and-redeploy-application-modify-code)
+ [Ridistribuisci il sito](#tutorials-wordpress-update-and-redeploy-application-deploy-updates)
## Configura il sito WordPress
Per vedere gli effetti della modifica del codice, completa la configurazione del WordPress sito in modo da avere un'installazione completamente funzionante.
1. Digitare l'URL del sito nel browser Web. L'URL è l'indirizzo DNS pubblico dell'istanza Amazon EC2 più `/WordPress` un'estensione. Per questo WordPress sito di esempio (e ad esempio l'indirizzo DNS pubblico dell'istanza Amazon EC2), l'URL è. **http://ec2-01-234-567-890.compute-1.amazonaws.com/WordPress**
1. Se non hai ancora configurato il sito, viene visualizzata la pagina di benvenuto WordPress predefinita. Selezionare **Let's go\$1 (Iniziamo\$1)**.
1. Per utilizzare l'impostazione predefinita del database MySQL, nella pagina di configurazione del database digitare i seguenti valori:
+ **Database Name (Nome del database)**: **test**
+ **User Name**: **root**
+ **Password**: lasciare vuoto.
+ **Database Host**: **localhost**
+ **Table Prefix**: **wp\$1**
Selezionare **Submit (Invia)** per configurare il database.
1. Continuare la configurazione del sito. Nella pagina di **benvenuto**, inserisci i valori che desideri e scegli **Installa WordPress**. Al termine dell'installazione, è possibile accedere al pannello di controllo.
**Importante**
Durante la distribuzione dell' WordPress applicazione, **change\$1permissions.sh** lo script ha aggiornato le autorizzazioni della `/tmp/WordPress` cartella in modo che chiunque possa scrivervi. In questa fase è possibile eseguire il comando seguente per limitare le autorizzazioni in modo che solo il proprietario possa scrivere nella cartella:
```
chmod -R 755 /var/www/html/WordPress
```
## Modifica il sito
Per modificare il WordPress sito, vai alla cartella dell'applicazione sulla tua macchina di sviluppo:
```
cd /tmp/WordPress
```
Per modificare alcuni dei colori del sito, nel file `wp-content/themes/twentyfifteen/style.css` utilizzare un editor di testo o **sed** per modificare `#fff` in `#768331`.
In Linux o altri sistemi con GNU **sed**, utilizzare:
```
sed -i 's/#fff/#768331/g' wp-content/themes/twentyfifteen/style.css
```
In macOS, Unix o altri sistemi con BSD **sed**, utilizzare:
```
sed -i '' 's/#fff/#768331/g' wp-content/themes/twentyfifteen/style.css
```
## Ridistribuisci il sito
Ora che hai modificato il codice del sito, usa Amazon S3 e ridistribuisci CodeDeploy il sito.
Raggruppa e carica le modifiche su Amazon S3, come descritto in. [Raggruppate i file dell'applicazione in un unico file di archivio e inviate il file di archivio](tutorials-wordpress-upload-application.md#tutorials-wordpress-upload-application-bundle-and-push-archive) (Nel seguire queste istruzioni, ricordare che non è necessario creare un'applicazione). Assegnare alla nuova revisione la stessa chiave di prima (**WordPressApp.zip**). Caricalo nello stesso bucket Amazon S3 che hai creato in precedenza (ad esempio,). **amzn-s3-demo-bucket**
Usa AWS CLI, la CodeDeploy console o il CodeDeploy APIs per ridistribuire il sito.
**Topics**
+ [Per ridistribuire il sito (CLI)](#tutorials-wordpress-update-and-redeploy-application-deploy-updates-cli)
+ [Per ridistribuire il sito (console)](#tutorials-wordpress-update-and-redeploy-application-deploy-updates-console)
### Per ridistribuire il sito (CLI)
Chiamare il comando **create-deployment** per creare una distribuzione basata sulla revisione appena caricata. Utilizzare l'applicazione denominata **WordPress\$1App**, la configurazione della distribuzione denominata **CodeDeployDefault.OneAtATime**, il gruppo di distribuzione denominato **WordPress\$1DepGroup** e la revisione denominata **WordPressApp.zip** nel bucket denominato **amzn-s3-demo-bucket**:
```
aws deploy create-deployment \
--application-name WordPress_App \
--deployment-config-name CodeDeployDefault.OneAtATime \
--deployment-group-name WordPress_DepGroup \
--s3-location bucket=amzn-s3-demo-bucket,bundleType=zip,key=WordPressApp.zip
```
È possibile controllare lo stato della distribuzione, come descritto in [Monitora e risolvi i problemi della distribuzione](tutorials-wordpress-deploy-application.md#tutorials-wordpress-deploy-application-monitor).
Dopo CodeDeploy aver ridistribuito il sito, visita nuovamente il sito nel browser Web per verificare che i colori siano stati modificati. (Potrebbe essere necessario aggiornare il browser). Se i colori sono stati modificati, la modifica e la ridistribuzione del sito sono riuscite.
### Per ridistribuire il sito (console)
1. [Accedi Console di gestione AWS e apri la CodeDeploy console all'indirizzo /codedeploy. https://console.aws.amazon.com](https://console.aws.amazon.com/codedeploy)
**Nota**
Accedi con lo stesso utente che hai configurato. [Guida introduttiva con CodeDeploy](getting-started-codedeploy.md)
1. Nel riquadro di navigazione, espandi **Distribuisci**, quindi scegli **Applicazioni**.
1. Nell'elenco delle applicazioni, scegli **WordPress\$1App**.
1. Nella scheda **Deployment groups (Gruppi di distribuzione)**, scegliere **WordPress\$1DepGroup**.
1. Scegli **Create deployment (Crea distribuzione)**.
1. Nella pagina **Create deployment (Crea distribuzione)**:
1. In **Deployment group (Gruppo di distribuzione)**, scegliere **WordPress\$1DepGroup**.
1. **Nell'area **Tipo di archivio**, scegli **La mia applicazione è archiviata in Amazon** S3, quindi copia il link Amazon S3 della tua revisione nella casella Posizione di revisione.** Per individuare il valore del link:
1. In una scheda del browser separata:
Accedi a Console di gestione AWS e apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
Naviga e apri **amzn-s3-demo-bucket**, quindi scegli la tua revisione,. **WordPressApp.zip**
1. Se il riquadro **Proprietà** non è visibile nella console Amazon S3, scegli il pulsante **Proprietà**.
1. Nel riquadro **Proprietà**, copia il valore del campo **Link** nella casella **Posizione di revisione** della CodeDeploy console.
1. Se viene visualizzato un messaggio che informa che non è stato possibile individuare il tipo di file, scegliere **.zip**.
1. Lasciare vuota la casella **Deployment description (Descrizione distribuzione)**.
1. **Espandi le sostituzioni del gruppo di distribuzione** **e da **Configurazione di distribuzione**, scegli. CodeDeployDefault OneAtATime**.
1. Selezionare **Start deployment (Avvia distribuzione)**. Nella pagina **Deployments (Distribuzioni)** vengono visualizzate le informazioni relative alla nuova distribuzione creata.
1. È possibile controllare lo stato della distribuzione, come descritto in [Monitora e risolvi i problemi della distribuzione](tutorials-wordpress-deploy-application.md#tutorials-wordpress-deploy-application-monitor).
Dopo CodeDeploy aver ridistribuito il sito, visita nuovamente il sito nel tuo browser web per verificare che i colori siano stati cambiati. (Potrebbe essere necessario aggiornare il browser). Se i colori sono stati modificati, la modifica e la ridistribuzione del sito sono riuscite.
# Passaggio 6: Pulisci WordPress l'applicazione e le risorse correlate
Ora hai effettuato con successo un aggiornamento del WordPress codice e ridistribuito il sito. Per evitare addebiti continuativi per risorse create per questo tutorial, devi eliminare:
+ Qualsiasi CloudFormation stack (o termina qualsiasi istanza Amazon EC2, se le hai create all'esterno). CloudFormation
+ Qualsiasi bucket Amazon S3.
+ L'applicazione `WordPress_App` in CodeDeploy.
+ L'associazione AWS Systems Manager State Manager dell' CodeDeploy agente.
Puoi usare Amazon S3 CloudFormation, Amazon EC2 CodeDeploy e le console oppure eseguire AWS APIs la pulizia. AWS CLI
**Topics**
+ [Per cancellare le risorse (CLI)](#tutorials-wordpress-clean-up-cli)
+ [Per cancellare le risorse (console)](#tutorials-wordpress-clean-up-console)
+ [Fasi successive](#tutorials-wordpress-clean-up-whats-next)
## Per cancellare le risorse (CLI)
1. Se hai usato il nostro CloudFormation modello per questo tutorial, chiama il **delete-stack** comando sullo stack denominato. **CodeDeployDemoStack** Ciò interromperà tutte le istanze Amazon EC2 associate ed eliminerà tutti i ruoli IAM associati allo stack creato:
```
aws cloudformation delete-stack --stack-name CodeDeployDemoStack
```
1. Per eliminare il bucket Amazon S3, chiama il **rm** comando con lo **--recursive** switch accanto al bucket denominato. **amzn-s3-demo-bucket** Il bucket e tutti gli oggetti in esso contenuti saranno quindi eliminati:
```
aws s3 rm s3://amzn-s3-demo-bucket --recursive --region region
```
1. Per eliminare l'applicazione `WordPress_App`, chiamare il comando **delete-application**. In questo modo verranno inoltre eliminati tutti i record del gruppo di distribuzione associato e i record di distribuzione per l'applicazione:
```
aws deploy delete-application --application-name WordPress_App
```
1. Per eliminare l'associazione Systems Manager State Manager, chiamare il **delete-association** comando.
```
aws ssm delete-association --assocation-id association-id
```
È possibile ottenerla *association-id* chiamando il **describe-association** comando.
```
aws ssm describe-association --name AWS-ConfigureAWSPackage --targets Key=tag:Name,Values=CodeDeployDemo
```
Se non hai utilizzato lo CloudFormation stack per questo tutorial, chiama il **terminate-instances** comando per terminare tutte le istanze Amazon EC2 che hai creato manualmente. Fornisci l'ID dell'istanza Amazon EC2 da terminare:
```
aws ec2 terminate-instances --instance-ids instanceId
```
## Per cancellare le risorse (console)
Se hai utilizzato il nostro CloudFormation modello per questo tutorial, elimina lo stack associato CloudFormation .
1. Accedi Console di gestione AWS e apri la CloudFormation console all'indirizzo [https://console.aws.amazon.com/cloudformazione.](https://console.aws.amazon.com/cloudformation/)
1. Nella casella **Filtro**, digita il nome dello CloudFormation stack creato in precedenza (ad esempio,). **CodeDeployDemoStack**
1. Selezionare la casella accanto al nome dello stack. Nel menu **Actions (Operazioni)**, scegli **Delete Stack (Elimina stack)**.
CloudFormation elimina lo stack, termina tutte le istanze Amazon EC2 associate ed elimina tutti i ruoli IAM associati.
Per terminare le istanze Amazon EC2 che hai creato al di fuori di uno stack: CloudFormation
1. Accedi Console di gestione AWS e apri la console Amazon EC2 all'indirizzo. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. Nell'elenco **INSTANCES**, scegliere **Instances (Istanze)**.
1. Nella casella di ricerca, digita il nome dell'istanza Amazon EC2 che desideri terminare (ad esempio,**CodeDeployDemo**), quindi premi Invio.
1. Scegli il nome dell'istanza Amazon EC2.
1. Nel menu **Actions (Operazioni)**, passare a **Instance State (Stato istanza)**, quindi selezionare **Terminate (Termina)**. Quando richiesto, scegliere **Yes, Terminate (Sì, termina)**.
Ripeti queste fasi per ogni istanza.
Per eliminare il bucket Amazon S3:
1. Accedi a Console di gestione AWS e apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Nell'elenco dei bucket, cerca e scegli il nome del bucket Amazon S3 che hai creato in precedenza (ad esempio,). **amzn-s3-demo-bucket**
1. Per eliminare un bucket, occorre innanzitutto rimuoverne i contenuti. Selezionare tutti i file nel bucket, ad esempio **WordPressApp.zip**. Dal menu **Actions (Operazioni)**, scegliere **Delete (Elimina)**. Quando viene richiesto di confermare l'eliminazione, scegliere **OK (OK)**.
1. Una volta svuotato, il bucket può essere eliminato. Nell'elenco dei bucket, selezionare la riga del bucket d'interesse (non il suo nome). Selezionare **Delete bucket (Elimina bucket)** e, quando viene richiesto di confermare, selezionare **OK (OK)**.
Per eliminare l'applicazione da: `WordPress_App` CodeDeploy
1. Accedi Console di gestione AWS e apri la CodeDeploy console all'indirizzo [https://console.aws.amazon.com/codedeploy.](https://console.aws.amazon.com/codedeploy)
**Nota**
Accedi con lo stesso utente con cui hai effettuato la configurazione. [Guida introduttiva con CodeDeploy](getting-started-codedeploy.md)
1. Nel riquadro di navigazione, espandi **Distribuisci**, quindi scegli **Applicazioni**.
1. Nell'elenco delle applicazioni, scegli **WordPress\$1App**.
1. Nella pagina **Application details (Dettagli applicazione)**, scegliere **Delete application (Elimina applicazione)**.
1. Quando richiesto, digitare il nome dell'applicazione per confermare che si desidera eliminarla, quindi scegliere **Delete (Elimina)**.
Per eliminare l'associazione Systems Manager State Manager:
1. Aprire la AWS Systems Manager console in https://console.aws.amazon.com /systems-manager.
1. Nel riquadro di navigazione, seleziona **State Manager**.
1. Scegli l'associazione creata e seleziona **Elimina**.
## Fasi successive
Se sei arrivato qui, complimenti. Hai completato una distribuzione CodeDeploy e quindi aggiornato e ridistribuito il codice del sito.