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à.

# Implementa le applicazioni su Amazon EC2
<a name="deploying.applications"></a>

Puoi utilizzarlo CloudFormation per installare, configurare e avviare automaticamente le applicazioni sulle istanze Amazon EC2. Ciò ti consente di duplicare in modo semplice le implementazioni e di aggiornare le installazioni esistenti senza stabilire una connessione diretta con l’istanza, risparmiando in questo modo una quantità significativa di tempo e lavoro.

CloudFormation include un set di script di supporto (`cfn-init`, `cfn-signal``cfn-get-metadata`, e`cfn-hup`) basati su. `cloud-init` Puoi richiamare questi script di supporto dai tuoi CloudFormation modelli per installare, configurare e aggiornare le applicazioni su istanze Amazon EC2 che si trovano nello stesso modello. *Per ulteriori informazioni, consulta il riferimento agli [script di CloudFormation supporto nella Template Reference Guide.](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/cfn-helper-scripts-reference.html)CloudFormation *

Nel [tutorial introduttivo](gettingstarted.walkthrough.md), hai creato un semplice server Web utilizzando `UserData` con uno script bash di base. Sebbene abbia funzionato per una semplice pagina “Hello World”, le applicazioni reali spesso richiedono configurazioni più sofisticate, tra cui:
+ Più pacchetti software installati nell’ordine corretto.
+ File di configurazione complessi creati con contenuti specifici.
+ Servizi avviati e configurati per l’esecuzione automatica.
+ Gestione degli errori e convalida del processo di configurazione.

CloudFormationgli script di supporto forniscono un modo più affidabile e gestibile per configurare le istanze EC2 rispetto agli script bash di base in. `UserData` Lo script helper `cfn-init` legge i dati di configurazione dai metadati del modello e li applica in maniera sistematica all’istanza.

In questo tutorial, scoprirai come utilizzare lo script helper `cfn-init` e come monitorare il processo di bootstrapping.

**Nota**  
CloudFormation è gratuito, ma ti verranno addebitate le risorse Amazon EC2 che crei. Tuttavia, se sei alle prime armi AWS, puoi sfruttare il [piano gratuito](https://aws.amazon.com/free/) per ridurre al minimo o eliminare i costi durante questo processo di apprendimento.

**Topics**
+ [Prerequisiti](#bootstrapping-tutorial-prerequisites)
+ [Comprensione dei concetti di bootstrap](#bootstrapping-tutorial-understand-concepts)
+ [Inizia con un semplice esempio di bootstrap](#bootstrapping-tutorial-simple-example)
+ [Aggiungere file e comandi](#bootstrapping-tutorial-add-complexity)
+ [Aggiungere la sicurezza della rete](#bootstrapping-tutorial-security-group)
+ [Il modello di bootstrap completo](#bootstrapping-tutorial-complete-template)
+ [Crea uno stack utilizzando la console](#bootstrapping-tutorial-create-stack)
+ [Monitora il processo di bootstrap](#bootstrapping-tutorial-validate-bootstrap)
+ [Prova il server Web avviato](#bootstrapping-tutorial-test-web-server)
+ [Risoluzione dei problemi di bootstrap](#bootstrapping-tutorial-troubleshooting)
+ [Eseguire la pulizia delle risorse](#bootstrapping-tutorial-clean-up)
+ [Fasi successive](#bootstrapping-tutorial-next-steps)

## Prerequisiti
<a name="bootstrapping-tutorial-prerequisites"></a>
+ Devi aver completato il [Creazione del primo stack](gettingstarted.walkthrough.md) tutorial o avere un'esperienza equivalente con le nozioni di CloudFormation base.
+ Devi avere accesso a un utente o ruolo IAM Account AWS con le autorizzazioni per usare Amazon EC2 CloudFormation e/o l'accesso come utente amministrativo.
+ È necessario disporre di un cloud privato virtuale (VPC) con accesso a Internet. Questo modello di tutorial richiede un VPC predefinito, che viene fornito automaticamente con la versione più recente dell’ Account AWS. Se non disponi di un VPC predefinito, o se è stato eliminato, consulta la sezione sulla risoluzione dei problemi nel tutorial [Creazione del primo stack](gettingstarted.walkthrough.md) per soluzioni alternative.

## Comprensione dei concetti di bootstrap
<a name="bootstrapping-tutorial-understand-concepts"></a>

Prima di creare il modello, scopriamo i concetti chiave che fanno funzionare il bootstrapping.

### Lo script helper `cfn-init`
<a name="bootstrapping-tutorial-cfn-init-overview"></a>

CloudFormation fornisce script di supporto in Python che puoi utilizzare per installare software e avviare servizi su un'istanza Amazon EC2. Lo script `cfn-init` legge i metadati delle risorse dal modello e applica la configurazione all’istanza.

Di seguito è riportato il procedimento:

1. Definisci la configurazione nella sezione `Metadata` della tua risorsa EC2.

1. Chiami `cfn-init` dallo script `UserData`.

1. `cfn-init` legge i metadati e applica la configurazione.

1. L’istanza è configurata in base alle tue specifiche.

### Struttura dei metadati
<a name="bootstrapping-tutorial-metadata-structure"></a>

La configurazione è definita in una struttura specifica all’interno dell’istanza EC2.

```
Resources:
  EC2Instance:
    Type: AWS::EC2::Instance
    Metadata:                       # Metadata section for the resource
      AWS::CloudFormation::Init:    # Required key that cfn-init looks for
        config:                     # Configuration name (you can have multiple)
          packages:                 # Install packages
          files:                    # Create files
          commands:                 # Run commands
          services:                 # Start/stop services
```

Lo script `cfn-init` elabora queste sezioni in un ordine specifico: pacchetti, gruppi, utenti, origini, file, comandi e servizi.

## Inizia con un semplice esempio di bootstrap
<a name="bootstrapping-tutorial-simple-example"></a>

Cominciamo con un esempio di bootstrap minimo, che si limita a installare e avviare Apache.

```
Resources:
  EC2Instance:
    Type: AWS::EC2::Instance
    Metadata:
      AWS::CloudFormation::Init:
        config:
          packages:                 # Install Apache web server
            yum:
              httpd: []
          services:                 # Start Apache and enable it to start on boot
            systemd:
              httpd:
                enabled: true
                ensureRunning: true
    Properties:
      ImageId: !Ref LatestAmiId
      InstanceType: !Ref InstanceType
      UserData: !Base64             # Script that runs when instance starts
        Fn::Sub: |
          #!/bin/bash
          yum install -y aws-cfn-bootstrap
          /opt/aws/bin/cfn-init -v --stack ${AWS::StackName} --resource EC2Instance --region ${AWS::Region}
```

Questo semplice esempio illustra i concetti fondamentali:
+ La sezione `packages` installa il pacchetto `httpd` utilizzando yum. Funziona su Amazon Linux e altre distribuzioni Linux che utilizzano yum.
+ La sezione `services` garantisce l’avvio e l’esecuzione automatica di `httpd`.
+ `UserData` installa gli strumenti di bootstrap più recenti e chiama `cfn-init`.

## Aggiungere file e comandi
<a name="bootstrapping-tutorial-add-complexity"></a>

Ora, miglioriamo il nostro esempio aggiungendo una pagina Web personalizzata e un file di log nella directory `/var/log` dell’istanza EC2.

### Creazione dei file
<a name="bootstrapping-tutorial-files-section"></a>

La sezione `files` consente di creare file sull’istanza con contenuti specifici. La barra verticale (`|`) consente di passare un blocco letterale di testo (codice HTML) come contenuto del file (`/var/www/html/index.html`).

```
files:
  /var/www/html/index.html:
    content: |
      <body>
        <h1>Congratulations, you have successfully launched the AWS CloudFormation sample.</h1>
      </body>
```

### Esecuzione di comandi
<a name="bootstrapping-tutorial-commands-section"></a>

La sezione `commands` consente di eseguire i comandi della shell durante il processo di bootstrap. Questo comando crea un file di log in `/var/log/welcome.txt` sull’istanza EC2. Per visualizzarlo, è necessaria una coppia di chiavi di Amazon EC2 da utilizzare per l’accesso SSH e un intervallo dell’indirizzo IP che può essere utilizzato per effettuare l’accesso SSH all’istanza (non descritto in questa sezione).

```
commands:
  createWelcomeLog:
    command: "echo 'cfn-init ran successfully!' > /var/log/welcome.txt"
```

## Aggiungere la sicurezza della rete
<a name="bootstrapping-tutorial-security-group"></a>

Poiché stiamo configurando un server Web, dobbiamo consentire al traffico Web (HTTP) di raggiungere la nostra istanza EC2. Per farlo, creeremo un gruppo di sicurezza che consente il traffico in entrata sulla porta 80 dal tuo indirizzo IP. Le istanze EC2 devono inoltre inviare traffico verso Internet, ad esempio per installare gli aggiornamenti dei pacchetti. Per impostazione predefinita, i gruppi di sicurezza autorizzano tutto il traffico in uscita. Assoceremo quindi questo gruppo di sicurezza alla nostra istanza EC2 utilizzando la proprietà `SecurityGroupIds`.

```
WebServerSecurityGroup:
  Type: AWS::EC2::SecurityGroup
  Properties:
    GroupDescription: Allow HTTP access from my IP address
    SecurityGroupIngress:
      - IpProtocol: tcp
        Description: HTTP
        FromPort: 80
        ToPort: 80
        CidrIp: !Ref MyIP
```

## Il modello di bootstrap completo
<a name="bootstrapping-tutorial-complete-template"></a>

Ora, mettiamo insieme tutti i pezzi. Ecco il modello completo che combina tutti i concetti di cui abbiamo parlato.

```
AWSTemplateFormatVersion: 2010-09-09
Description: Bootstrap an EC2 instance with Apache web server using cfn-init

Parameters:
  LatestAmiId:
    Description: The latest Amazon Linux 2 AMI from the Parameter Store
    Type: AWS::SSM::Parameter::Value<AWS::EC2::Image::Id>
    Default: '/aws/service/ami-amazon-linux-latest/amzn2-ami-hvm-x86_64-gp2'

  InstanceType:
    Description: EC2 instance type
    Type: String
    Default: t2.micro
    AllowedValues:
      - t3.micro
      - t2.micro
    ConstraintDescription: must be a valid EC2 instance type.

  MyIP:
    Description: Your IP address in CIDR format (e.g. 203.0.113.1/32)
    Type: String
    MinLength: 9
    MaxLength: 18
    Default: 0.0.0.0/0
    AllowedPattern: '^(\d{1,3}\.){3}\d{1,3}\/\d{1,2}$'
    ConstraintDescription: must be a valid IP CIDR range of the form x.x.x.x/x.

Resources:
  WebServerSecurityGroup:
    Type: AWS::EC2::SecurityGroup
    Properties:
      GroupDescription: Allow HTTP access from my IP address
      SecurityGroupIngress:
        - IpProtocol: tcp
          Description: HTTP
          FromPort: 80
          ToPort: 80
          CidrIp: !Ref MyIP

  WebServer:
    Type: AWS::EC2::Instance
    Metadata:
      AWS::CloudFormation::Init:
        config:
          packages:
            yum:
              httpd: []
          files:
            /var/www/html/index.html:
              content: |
                <body>
                  <h1>Congratulations, you have successfully launched the AWS CloudFormation sample.</h1>
                </body>
          commands:
            createWelcomeLog:
              command: "echo 'cfn-init ran successfully!' > /var/log/welcome.txt"
          services:
            systemd:
              httpd:
                enabled: true
                ensureRunning: true
    Properties:
      ImageId: !Ref LatestAmiId
      InstanceType: !Ref InstanceType
      SecurityGroupIds:
        - !Ref WebServerSecurityGroup
      UserData: !Base64
        Fn::Sub: |
          #!/bin/bash
          yum install -y aws-cfn-bootstrap
          /opt/aws/bin/cfn-init -v --stack ${AWS::StackName} --resource WebServer --region ${AWS::Region}
      Tags:
        - Key: Name
          Value: Bootstrap Tutorial Web Server

Outputs:
  WebsiteURL:
    Value: !Sub 'http://${WebServer.PublicDnsName}'
    Description: EC2 instance public DNS name
```

## Crea uno stack utilizzando la console
<a name="bootstrapping-tutorial-create-stack"></a>

La procedura seguente prevede il caricamento del modello di stack di esempio da un file. Apri un editor di testo sul tuo computer locale e aggiungi il modello. Salva il file con il nome `samplelinux2stack.template`.

**Avvio del modello dello stack**

1. [Accedi e apri la console all'indirizzo Console di gestione AWS /cloudformazione. CloudFormation https://console.aws.amazon.com](https://console.aws.amazon.com/cloudformation/)

1. Scegli **Crea stack**, **Con nuove risorse (standard)**.

1. In **Specifica modello**, seleziona **Carica un file di modello** e poi **Scegli file** per caricare il file `samplelinux2stack.template`. 

1. Scegli **Successivo**.

1. Nella pagina **Specifica i dettagli dello stack**, inserisci **BootstrapTutorialStack** come nome dello stack.

1. Per **Parametri**, effettua le seguenti operazioni.
   + **LatestAmiId**: lascia il valore predefinito.
   + **InstanceType**: Scegli **t2.micro o **t3.micro**** per il tipo di istanza EC2.
   + **MyIP**: inserisci il tuo indirizzo IP pubblico con un suffisso `/32`.

1. Scegli **Avanti** due volte, quindi **Invia** per creare lo stack.

## Monitora il processo di bootstrap
<a name="bootstrapping-tutorial-validate-bootstrap"></a>

I processi di bootstrap richiedono più tempo rispetto ai semplici avvii di EC2 perché vengono installati e configurati software aggiuntivi.

**Per monitorare l’avanzamento del bootstrap**

1. **Nella CloudFormation console, seleziona il tuo stack e apri la scheda Eventi.**

1. Cerca l’evento `WebServer CREATE_IN_PROGRESS`. Il processo di bootstrap inizia dopo l’avvio dell’istanza.

1. In genere, il processo di bootstrap richiede pochi minuti. Al termine vedrai `WebServer CREATE_COMPLETE`.

Se vuoi vedere cosa succede durante il processo di bootstrap, puoi controllare i log delle istanze.

**Visualizzare i log di bootstrap (facoltativo)**

1. Apri la [console EC2](https://console.aws.amazon.com/ec2/) e trova l’istanza.

1. Seleziona l’istanza e poi scegli **Operazioni**, **Monitoraggio e risoluzione dei problemi**, **Ottieni il log di sistema** per visualizzare i progressi del bootstrap.

1. Se non vedi i log immediatamente, attendi e aggiorna la pagina. 

## Prova il server Web avviato
<a name="bootstrapping-tutorial-test-web-server"></a>

Quando il tuo stack mostra `CREATE_COMPLETE`, esegui il test del tuo server Web.

**Per testare il server web**

1. Nella CloudFormation console, vai alla scheda **Output** relativa al tuo stack.

1. Fai clic sul valore **WebsiteURL** per aprire il tuo server Web in una nuova scheda.

1. Dovresti vedere la tua pagina Web personalizzata con il messaggio `Congratulations, you have successfully launched the AWS CloudFormation sample`.

**Nota**  
Se la pagina non viene caricata immediatamente, attendi un minuto e riprova. Il processo di bootstrap potrebbe essere ancora completato anche dopo che lo stack mostra `CREATE_COMPLETE`.

## Risoluzione dei problemi di bootstrap
<a name="bootstrapping-tutorial-troubleshooting"></a>

Se il processo di bootstrap fallisce o il server Web non funziona, ecco i problemi e le soluzioni più comuni.

### Problemi comuni
<a name="bootstrapping-tutorial-common-issues"></a>
+ **La creazione dello stack fallisce**: controlla la scheda **Eventi** per messaggi di errore specifici.
+ **Server Web non accessibile**: verifica che l’indirizzo IP sia corretto nel parametro `MyIP`. Ricordati di includere `/32` alla fine.
+ **Il processo di bootstrap fallisce**: l’istanza si avvia ma `cfn-init` fallisce. Controlla i log di sistema come descritto nella sezione di monitoraggio.

## Eseguire la pulizia delle risorse
<a name="bootstrapping-tutorial-clean-up"></a>

Per evitare addebiti in corso, puoi eseguire una pulizia eliminando lo stack e le relative risorse. 

**Eliminare lo stack e delle relative risorse**

1. Apri la [CloudFormation console](https://console.aws.amazon.com/cloudformation/).

1. Nella pagina **Stack** seleziona l’opzione accanto al nome dello stack che hai creato (**BootstrapTutorialStack**), quindi scegli **Elimina**.

1. Quando viene richiesta la conferma, seleziona **Elimina**.

1. Monitora l’avanzamento del processo di eliminazione dello stack nella scheda **Evento**. Lo stato di **BootstrapTutorialStack** cambia in `DELETE_IN_PROGRESS`. Una volta CloudFormation completata l'eliminazione dello stack, lo rimuove dall'elenco.

## Fasi successive
<a name="bootstrapping-tutorial-next-steps"></a>

Complimenti\$1 Hai imparato con successo come avviare le istanze EC2 con. CloudFormation Ora sai:
+ Come usare gli script helper `cfn-init`
+ Come strutturare i metadati per il bootstrapping
+ Come installare pacchetti, creare file, eseguire comandi e gestire servizi
+ Come monitorare i problemi di bootstrap

Per continuare a imparare:
+ Scopri come aggiornare uno stack in esecuzione e utilizzare lo script di supporto. `cfn-hup` Per ulteriori informazioni, consulta [Aggiornare uno CloudFormation stack](updating.stacks.walkthrough.md).
+ Scopri come eseguire il bootstrap di uno stack Windows. Per ulteriori informazioni, consulta [Stack basati sul bootstrap Windows CloudFormation](cfn-windows-stacks-bootstrapping.md).
+ Esplora scenari di bootstrap più complessi con più set di configurazione. *Per maggiori informazioni, consulta [cfn-init](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/cfn-init.html) e [AWS::CloudFormation::Init](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-init.html)nella Template Reference Guide.CloudFormation *
+ Scopri come segnalare lo stato di completamento del bootstrap con `cfn-signal`. Per ulteriori informazioni, consulta [cfn-signal](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/cfn-signal.html) in *CloudFormation Template Reference Guide*.