

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

# Guida introduttiva con CloudFormation
<a name="GettingStarted"></a>

Puoi iniziare a CloudFormation utilizzarlo creando uno stack a partire da un modello di esempio, che ti aiuterà a imparare le basi della creazione di stack. Console di gestione AWS Un *modello* è un file di testo che definisce tutte le risorse all’interno di uno stack. Uno *stack* è l'implementazione di un modello. CloudFormation Da un singolo modello puoi creare più stack. Ogni stack contiene una raccolta di AWS risorse che possono essere gestite come una singola unità.

CloudFormation è un servizio gratuito; tuttavia, ti verranno addebitati i costi per le AWS risorse che includi negli stack alle tariffe correnti per ciascuno di essi. Per ulteriori informazioni sui AWS prezzi, consulta la pagina dei dettagli di ciascun prodotto all'[indirizzo http://aws.amazon.com](https://aws.amazon.com/).

**Video: Guida introduttiva a CloudFormation**  
Il video seguente è un'introduzione alla creazione di CloudFormation pile da. Console di gestione AWS

[![AWS Videos](http://img.youtube.com/vi/https://www.youtube.com/embed/1h-GPXQrLZw?si=MYHlJvBkE3DspKcL/0.jpg)](http://www.youtube.com/watch?v=https://www.youtube.com/embed/1h-GPXQrLZw?si=MYHlJvBkE3DspKcL)


**Topics**
+ [Come CloudFormation funziona](cloudformation-overview.md)
+ [Iscrizione a un Account AWS](cfn-sign-up-for-aws.md)
+ [Creazione del primo stack](gettingstarted.walkthrough.md)

# Come CloudFormation funziona
<a name="cloudformation-overview"></a>

Questo argomento descrive come CloudFormation funziona e presenta i concetti chiave che è necessario conoscere durante l'utilizzo.

**Topics**
+ [Concetti chiave](#cfn-whatis-concepts)
+ [Come funziona CloudFormation](#cfn-whatis-howdoesitwork)
+ [Modi per iniziare con CloudFormation](#ways-to-get-started)

## Concetti chiave
<a name="cfn-whatis-concepts"></a>

Quando lo usi CloudFormation, lavori con *modelli* e *pile*. Crei modelli per descrivere AWS le tue risorse e le loro proprietà. Ogni volta che crei uno stack, CloudFormation effettua il provisioning delle risorse descritte nel modello.

**Topics**
+ [Modelli](#cfn-concepts-templates)
+ [Stack](#cfn-concepts-stacks)
+ [Set di modifiche](#cfn-concepts-change-sets)

### Modelli
<a name="cfn-concepts-templates"></a>

Un CloudFormation modello è un file di testo in formato YAML o JSON. È possibile salvare questi file con qualsiasi estensione, ad esempio,, o`.yaml`. `.json` `.template` `.txt` CloudFormation utilizza questi modelli come modelli per creare le tue AWS risorse. Ad esempio, in un modello è possibile descrivere un’istanza Amazon EC2, come il tipo di istanza, l’ID AMI, le mappature dei dispositivi a blocchi e il relativo nome della coppia di chiavi Amazon EC2. Ogni volta che si crea uno stack, è possibile specificare anche un modello che CloudFormation utilizza per creare ciò che è stato descritto nel modello.

Ad esempio, se hai creato uno stack con il seguente modello, effettua il CloudFormation provisioning di un'istanza con un ID `ami-0ff8a91507f77f867` AMI, un tipo di `t2.micro` istanza, un nome di `testkey` key pair e un volume Amazon EBS.

#### YAML
<a name="t2-micro-example.yaml"></a>

```
AWSTemplateFormatVersion: 2010-09-09
Description: A sample template
Resources:
  MyEC2Instance:
    Type: AWS::EC2::Instance
    Properties:
      ImageId: ami-0ff8a91507f77f867
      InstanceType: t2.micro
      KeyName: testkey
      BlockDeviceMappings:
        - DeviceName: /dev/sdm
          Ebs:
            VolumeType: io1
            Iops: 200
            DeleteOnTermination: false
            VolumeSize: 20
```

#### JSON
<a name="t2-micro-example.json"></a>

```
{
    "AWSTemplateFormatVersion": "2010-09-09",
    "Description": "A sample template",
    "Resources": {
        "MyEC2Instance": {
            "Type": "AWS::EC2::Instance",
            "Properties": {
                "ImageId": "ami-0ff8a91507f77f867",
                "InstanceType": "t2.micro",
                "KeyName": "testkey",
                "BlockDeviceMappings": [
                    {
                        "DeviceName": "/dev/sdm",
                        "Ebs": {
                            "VolumeType": "io1",
                            "Iops": 200,
                            "DeleteOnTermination": false,
                            "VolumeSize": 20
                        }
                    }
                ]
            }
        }
    }
}
```

È anche possibile specificare più risorse in un singolo modello e configurare tali risorse in modo che funzionino insieme. Ad esempio, puoi modificare il modello precedente per includere un indirizzo IP elastico (EIP) e associarlo all’istanza Amazon EC2, come illustrato nell’esempio seguente:

#### YAML
<a name="multiple-resources-single-template.yaml"></a>

```
AWSTemplateFormatVersion: 2010-09-09
Description: A sample template
Resources:
  MyEC2Instance:
    Type: AWS::EC2::Instance
    Properties:
      ImageId: ami-0ff8a91507f77f867
      InstanceType: t2.micro
      KeyName: testkey
      BlockDeviceMappings:
        - DeviceName: /dev/sdm
          Ebs:
            VolumeType: io1
            Iops: 200
            DeleteOnTermination: false
            VolumeSize: 20
  MyEIP:
    Type: AWS::EC2::EIP
    Properties:
      InstanceId: !Ref MyEC2Instance
```

#### JSON
<a name="multiple-resources-single-template.json"></a>

```
{
    "AWSTemplateFormatVersion": "2010-09-09",
    "Description": "A sample template",
    "Resources": {
        "MyEC2Instance": {
            "Type": "AWS::EC2::Instance",
            "Properties": {
                "ImageId": "ami-0ff8a91507f77f867",
                "InstanceType": "t2.micro",
                "KeyName": "testkey",
                "BlockDeviceMappings": [
                    {
                        "DeviceName": "/dev/sdm",
                        "Ebs": {
                            "VolumeType": "io1",
                            "Iops": 200,
                            "DeleteOnTermination": false,
                            "VolumeSize": 20
                        }
                    }
                ]
            }
        },
        "MyEIP": {
            "Type": "AWS::EC2::EIP",
            "Properties": {
                "InstanceId": {
                    "Ref": "MyEC2Instance"
                }
            }
        }
    }
}
```

I modelli precedenti sono incentrati su una singola istanza di Amazon EC2; tuttavia CloudFormation, i modelli dispongono di funzionalità aggiuntive che puoi utilizzare per creare set complessi di risorse e riutilizzare tali modelli in più contesti. Ad esempio, puoi aggiungere parametri di input i cui valori vengono specificati quando crei uno stack. CloudFormation In altre parole, è possibile specificare un valore, ad esempio il tipo di istanza, al momento della creazione di uno stack anziché quando si crea il modello, rendendo il modello più semplice da riutilizzare in situazioni diverse.

### Stack
<a name="cfn-concepts-stacks"></a>

Quando si utilizza CloudFormation, si gestiscono le risorse correlate come una singola unità denominata pila. Puoi creare, aggiornare ed eliminare una raccolta di risorse mediante la creazione, l’aggiornamento e l’eliminazione di stack. Tutte le risorse di uno stack sono definite dal modello dello stack. CloudFormation Supponi di aver creato un modello che include un gruppo Auto Scaling, un bilanciatore del carico Elastic Load Balancing e un’istanza database Amazon Relational Database Service (Amazon RDS). Per creare queste risorse, crei uno stack inviando il modello che hai creato ed esegui il CloudFormation provisioning di tutte quelle risorse al posto tuo.

### Set di modifiche
<a name="cfn-concepts-change-sets"></a>

Per apportare modifiche alle risorse in esecuzione in uno stack, puoi aggiornare lo stack. Prima di apportare modifiche alle risorse, è possibile generare un set di modifiche, che è un riepilogo delle modifiche proposte. I set di modifiche consentono di vedere in che modo le modifiche possono influire sulle risorse in esecuzione, soprattutto nel caso di risorse critiche, prima di applicarle.

Ad esempio, se modifichi il nome di un'istanza di database Amazon RDS, CloudFormation creerà un nuovo database ed eliminerà quello precedente. Perderai i dati nel vecchio database, a meno che non abbia già eseguito il backup. Se generi un set di modifiche, vedrai che la modifica causerà la sostituzione del database e sarai in grado di pianificare le attività di conseguenza prima di aggiornare lo stack. 

## Come funziona CloudFormation
<a name="cfn-whatis-howdoesitwork"></a>

Quando si utilizza CloudFormation per creare lo stack, CloudFormation effettua chiamate di servizio sottostanti AWS per fornire e configurare le risorse descritte nel modello. È necessaria l’autorizzazione per creare queste risorse. Ad esempio, per creare istanze EC2 utilizzando CloudFormation, sono necessarie le autorizzazioni per creare istanze. Gestisci queste autorizzazioni con [AWS Identity and Access Management](https://docs.aws.amazon.com/IAM/latest/UserGuide/) (IAM).

Le chiamate effettuate sono tutte CloudFormation dichiarate dal modello. Ad esempio, supponiamo che disponi di un modello che descrive un’istanza EC2 con un tipo di istanza `t2.micro`. Quando usi quel modello per creare uno stack, CloudFormation chiama l'API di creazione istanza di Amazon EC2 e specifica il tipo di istanza come. `t2.micro` Il seguente diagramma riepiloga il flusso di elaborazione CloudFormation per la creazione di stack.

![\[Un modello creato o esistente che viene salvato localmente, o in un bucket, utilizzato per creare uno stack.\]](http://docs.aws.amazon.com/it_it/AWSCloudFormation/latest/UserGuide/images/create-stack-diagram.png)


**Per creare uno stack**

1. Usa un editor di testo per creare un CloudFormation modello in formato YAML o JSON. Il modello CloudFormation descrive le risorse desiderate e le relative impostazioni. Utilizza [Infrastructure Composer](infrastructure-composer-for-cloudformation.md) per visualizzare e convalidare il tuo modello. Questa operazione ti aiuta ad assicurarti che il modello sia strutturato correttamente e privo di errori di sintassi. Per ulteriori informazioni, consulta [Lavorare con i CloudFormation modelli](template-guide.md).

1. salvare il modello in locale o in un bucket Amazon S3.

1. Crea uno CloudFormation stack specificando la posizione del file modello, ad esempio un percorso sul tuo computer locale o un URL Amazon S3. Se il modello contiene parametri, è possibile specificare i valori di input quando si crea lo stack. I parametri ti consentono di trasferire valori al modello per personalizzare le risorse ogni volta che si crea uno stack.
**Nota**  
Se specifichi un file modello archiviato localmente, lo CloudFormation carica in un bucket S3 del tuo account. AWS CloudFormation crea un bucket per ogni regione in cui carichi un file modello. I bucket sono accessibili a chiunque disponga delle autorizzazioni Amazon Simple Storage Service (Amazon S3) nel tuo account. AWS Se CloudFormation è già presente un bucket creato da, il modello viene aggiunto a quel bucket.  
Puoi utilizzare il tuo bucket e gestirne le autorizzazioni caricando manualmente i modelli su Amazon S3. Quindi ogni volta che crei o aggiorni uno stack, specifica l’URL Amazon S3 di un file del modello.

Dopo che tutte le risorse sono state create, CloudFormation segnala che lo stack è stato creato. È quindi possibile iniziare a utilizzare le risorse nello stack. Se la creazione dello stack non riesce, CloudFormation esegue il rollback delle modifiche eliminando le risorse create.

### Aggiornamento di uno stack con un set di modifiche
<a name="updating-stack-with-change-sets"></a>

Quando è necessario aggiornare le risorse del proprio stack, è possibile modificare il modello dello stack. Non è necessario creare un nuovo stack ed eliminare quello precedente. Per aggiornare uno stack, create un set di modifiche inviando una versione modificata del modello di stack originale, diversi valori dei parametri di input o entrambi. CloudFormation confronta il modello modificato con il modello originale e genera un set di modifiche. Il set di modifiche elenca le modifiche proposte. Dopo avere esaminato le modifiche, puoi avviare il set di modifiche per aggiornare lo stack oppure puoi creare un nuovo set di modifiche. Il seguente diagramma riepiloga il flusso di elaborazione per l’aggiornamento di stack.

![\[Un modello che utilizza un set di modifiche per visualizzare il valore modificato prima di eseguire il set di modifiche per aggiornare lo stack.\]](http://docs.aws.amazon.com/it_it/AWSCloudFormation/latest/UserGuide/images/update-stack-diagram.png)


**Per aggiornare uno stack con un set di modifiche**

1. È possibile modificare un modello di CloudFormation pila utilizzando [Infrastructure Composer](infrastructure-composer-for-cloudformation.md) o un editor di testo. Per ulteriori informazioni, consulta [Aggiornare il modello di stack](using-cfn-updating-stacks-get-template.md).

   Quando aggiorni il modello, tieni presente che gli aggiornamenti possono causare interruzioni. A seconda della risorsa e delle proprietà che si intende aggiornare, un aggiornamento potrebbe interrompere o anche sostituire una risorsa esistente. Per ulteriori informazioni, consulta [Comprendere l’aggiornamento dei comportamenti delle risorse stack](using-cfn-updating-stacks-update-behaviors.md).

1. Salva il CloudFormation modello localmente o in un bucket S3.

1. Creare un set di modifiche specificando lo stack che si desidera aggiornare e la posizione del modello modificato, ad esempio un percorso sul computer locale o un URL Amazon S3. Per ulteriori informazioni sulla creazione di set di modifiche, vedi [Aggiorna CloudFormation gli stack utilizzando i set di modifiche](using-cfn-updating-stacks-changesets.md).
**Nota**  
Se specifichi un modello archiviato sul tuo computer locale, carica CloudFormation automaticamente il modello in un bucket S3 del tuo. Account AWS

1. Visualizza il set di modifiche per verificare che esegua le modifiche che CloudFormation ti aspetti. Ad esempio, controlla se CloudFormation sostituirà eventuali risorse critiche dello stack. È possibile creare il numero di set di modifiche necessario per includere le modifiche desiderate.
**Importante**  
I set di modifiche non indicano se l’aggiornamento dello stack è riuscito. Ad esempio, un set di modifiche non controlla se superi la [quota](cloudformation-limits.md) di un account, se stai aggiornando una risorsa che non supporta aggiornamenti o se non disponi di [autorizzazioni](control-access-with-iam.md) sufficienti per modificare una risorsa, il che può comportare errori nell’aggiornamento dello stack.

1. Avvia il set di modifiche che desideri applicare allo stack. CloudFormation aggiorna lo stack aggiornando solo le risorse che hai modificato e segnala che lo stack è stato aggiornato con successo. Se l'aggiornamento dello stack fallisce, CloudFormation ripristina le modifiche per ripristinare lo stack all'ultimo stato di funzionamento noto.

## Modi per iniziare con CloudFormation
<a name="ways-to-get-started"></a>

Per creare uno CloudFormation stack Hello World con la console, vedi[Creazione del primo stack](gettingstarted.walkthrough.md).

Per un apprendimento guidato, prova il workshop [Getting Started with CloudFormation](https://catalog.us-east-1.prod.workshops.aws/workshops/df7f72cf-4f10-4664-acb6-b30dc8d4bcf0/en-US), che offre un’esperienza pratica con lo sviluppo di modelli.

# Iscrizione a un Account AWS
<a name="cfn-sign-up-for-aws"></a>

Quando ti iscrivi AWS, il tuo Account AWS viene automaticamente iscritto a tutti i servizi in AWS, incluso CloudFormation. Se ne hai Account AWS già uno, passa all'argomento successivo. Se non ne hai uno Account AWS, usa la procedura seguente per crearne uno.

## Registrati per un Account AWS
<a name="sign-up-for-aws"></a>

Se non ne hai uno Account AWS, completa i seguenti passaggi per crearne uno.

**Per iscriverti a un Account AWS**

1. Apri la [https://portal.aws.amazon.com/billing/registrazione.](https://portal.aws.amazon.com/billing/signup)

1. Segui le istruzioni online.

   Nel corso della procedura di registrazione riceverai una telefonata o un messaggio di testo e ti verrà chiesto di inserire un codice di verifica attraverso la tastiera del telefono.

   Quando ti iscrivi a un Account AWS, *Utente root dell'account AWS*viene creato un. L’utente root dispone dell’accesso a tutte le risorse e tutti i Servizi AWS nell’account. Come best practice di sicurezza, assegna l’accesso amministrativo a un utente e utilizza solo l’utente root per eseguire [attività che richiedono l’accesso di un utente root](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).

AWS ti invia un'email di conferma dopo il completamento della procedura di registrazione. In qualsiasi momento, puoi visualizzare l'attività corrente del tuo account e gestirlo accedendo a [https://aws.amazon.com/](https://aws.amazon.com/)e scegliendo **Il mio account**.

## Crea un utente con accesso amministrativo
<a name="create-an-admin"></a>

Dopo esserti registrato Account AWS, proteggi Utente root dell'account AWS AWS IAM Identity Center, abilita e crea un utente amministrativo in modo da non utilizzare l'utente root per le attività quotidiane.

**Proteggi i tuoi Utente root dell'account AWS**

1.  Accedi [Console di gestione AWS](https://console.aws.amazon.com/)come proprietario dell'account scegliendo **Utente root** e inserendo il tuo indirizzo Account AWS email. Nella pagina successiva, inserisci la password.

   Per informazioni sull’accesso utilizzando un utente root, consulta la pagina [Accedere come utente root](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) nella *Guida per l’utente di Accedi ad AWS *.

1. Abilita l’autenticazione a più fattori (MFA) per l’utente root.

   Per istruzioni, consulta [Abilitare un dispositivo MFA virtuale per l'utente Account AWS root (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) nella Guida per l'*utente IAM*.

**Crea un utente con accesso amministrativo**

1. Abilita il Centro identità IAM.

   Per istruzioni, consulta [Abilitazione del AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) nella *Guida per l’utente di AWS IAM Identity Center *.

1. Nel Centro identità IAM, assegna l’accesso amministrativo a un utente.

   Per un tutorial sull'utilizzo di IAM Identity Center directory come fonte di identità, consulta [Configurare l'accesso utente con l'impostazione predefinita IAM Identity Center directory](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) nella *Guida per l'AWS IAM Identity Center utente*.

**Accesso come utente amministratore**
+ Per accedere come utente del Centro identità IAM, utilizza l’URL di accesso che è stato inviato al tuo indirizzo e-mail quando hai creato l’utente del Centro identità IAM.

  Per informazioni sull'accesso utilizzando un utente IAM Identity Center, consulta [AWS Accedere al portale di accesso](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) nella *Guida per l'Accedi ad AWS utente*.

**Assegnazione dell’accesso ad altri utenti**

1. Nel Centro identità IAM, crea un set di autorizzazioni conforme alla best practice per l’applicazione di autorizzazioni con il privilegio minimo.

   Segui le istruzioni riportate nella pagina [Creazione di un set di autorizzazioni](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) nella *Guida per l’utente di AWS IAM Identity Center *.

1. Assegna al gruppo prima gli utenti e poi l’accesso con autenticazione unica (Single Sign-On).

   Per istruzioni, consulta [Aggiungere gruppi](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) nella *Guida per l’utente di AWS IAM Identity Center *.

**Nota**  
Per ulteriori informazioni su come gestire chi ha accesso a cosa, consulta [Controlla CloudFormation l'accesso con AWS Identity and Access Management](control-access-with-iam.md).

# Creazione del primo stack
<a name="gettingstarted.walkthrough"></a>

Questo argomento illustra come creare il primo CloudFormation stack utilizzando. Console di gestione AWS Seguendo questo tutorial, imparerai come fornire AWS risorse di base, monitorare gli eventi dello stack e generare output.

Per questo esempio, il CloudFormation modello è scritto in YAML. YAML è un formato leggibile dall’uomo, ampiamente utilizzato per definire l’infrastruttura come codice. Man mano che approfondisci CloudFormation, potresti incontrare anche altri modelli in formato JSON, ma per questo tutorial, YAML è stato scelto per la sua leggibilità.

**Nota**  
CloudFormation è gratuito, ma ti verranno addebitati i costi per le risorse Amazon EC2 e Amazon S3 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](#getting-started-prerequisites)
+ [Crea uno CloudFormation stack con la console](#getting-started-create-stack)
+ [Monitoraggio della creazione dello stack](#getting-started-monitor-stack-creation)
+ [Test del server web](#getting-started-test-web-server)
+ [Risoluzione dei problemi](#getting-started-troubleshooting)
+ [Eliminazione](#getting-started-clean-up)
+ [Fasi successive](#getting-started-next-steps)

## Prerequisiti
<a name="getting-started-prerequisites"></a>
+ Devi avere accesso a un utente o ruolo IAM Account AWS con le autorizzazioni per utilizzare Amazon EC2, Amazon S3 e/o l'accesso come utente CloudFormation amministrativo.
+ Devi disporre di un cloud privato virtuale (VPC) con accesso a Internet. Questo modello di procedura dettagliata richiede un VPC predefinito, che viene fornito automaticamente agli Account AWS più recenti. Se non disponi di un VPC predefinito o se è stato eliminato, consulta la sezione relativa alla risoluzione dei problemi in questo argomento per soluzioni alternative.

## Crea uno CloudFormation stack con la console
<a name="getting-started-create-stack"></a>

**Per creare uno CloudFormation stack Hello world con la console**

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

1. Scegli **Crea stack**.

1. Nella pagina **Crea stack**, scegli **Costruisci da Infrastructure Composer**, quindi **Crea in Infrastructure Composer**. In questo modo si accede a Infrastructure Composer in modalità CloudFormation console, dove è possibile caricare e convalidare il modello di esempio.

1. Per caricare e convalidare il modello di esempio, esegui queste operazioni:

   1. Scegli **Modello**. Quindi, copia e incolla il seguente CloudFormation modello nell'editor dei modelli:

      ```
      AWSTemplateFormatVersion: 2010-09-09
      Description: CloudFormation Template for WebServer with Security Group and EC2 Instance
      
      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: WebServer 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 via my IP address
            SecurityGroupIngress:
              - IpProtocol: tcp
                FromPort: 80
                ToPort: 80
                CidrIp: !Ref MyIP
      
        WebServer:
          Type: AWS::EC2::Instance
          Properties:
            ImageId: !Ref LatestAmiId
            InstanceType: !Ref InstanceType
            SecurityGroupIds:
              - !Ref WebServerSecurityGroup
            UserData: !Base64 |
              #!/bin/bash
              yum update -y
              yum install -y httpd
              systemctl start httpd
              systemctl enable httpd
              echo "<html><body><h1>Hello World!</h1></body></html>" > /var/www/html/index.html
      
      Outputs:
        WebsiteURL:
          Value: !Join
            - ''
            - - http://
              - !GetAtt WebServer.PublicDnsName
          Description: Website URL
      ```

      Prima di passare alla fase successiva, prendiamoci un momento per dare un'occhiata al modello e comprendere alcuni CloudFormation concetti chiave.
      + La sezione **`Parameters`** dichiara valori che è possibile trasmettere al modello al momento della creazione dello stack. Le risorse specificate più avanti nel modello fanno riferimento a questi valori e utilizzano i dati. I parametri sono un modo efficace per specificare le informazioni che non desideri archiviare nel modello stesso. Questo è anche un modo per specificare le informazioni che potrebbero essere univoche per l’applicazione o la configurazione specifica che stai implementando.
      + Il modello definisce i parametri seguenti:
        + **`LatestAmiId`**: recupera l’ID AMI Amazon Linux 2 più recente dal Parameter Store AWS Systems Manager .
        + **`InstanceType`**: consente la selezione del tipo di istanza EC2 (impostazione predefinita: `t2.micro`, consentiti: `t3.micro`, `t2.micro`). 
        + **`MyIP`**: specifica l’intervallo di indirizzi IP per l’accesso HTTP (impostazione predefinita: 0.0.0.0/0, che consente l’accesso da qualsiasi IP).
      + La **`Resources`**sezione contiene le definizioni delle AWS risorse che desideri creare con il modello. Le dichiarazioni di risorse sono un modo efficiente per specificare tutte queste impostazioni di configurazione in una sola volta. Quando inserisci dichiarazioni di risorse in un modello, puoi creare e configurare tutte le risorse dichiarate utilizzando il modello per creare uno stack. Puoi inoltre creare nuovi stack a partire dallo stesso modello per avviare configurazioni di risorse identiche.
      + Questo modello crea le seguenti risorse:
        + **`WebServerSecurityGroup`**: un gruppo di sicurezza EC2 che consente il traffico HTTP in entrata sulla porta 80 dall’intervallo IP specificato.
        + **`WebServer`**: una istanza EC2 con la seguente configurazione:
          + Utilizza l’AMI di Amazon Linux 2 più recente
          + Applica il tipo di istanza selezionato
          + Aggiunge `WebServerSecurityGroup` alla proprietà `SecurityGroupIds`
          + Include uno script di dati utente per installare Apache HTTP Server
      + Viene specificato un nome logico all’inizio di ogni dichiarazione di risorse e parametri. Ad esempio, `WebServerSecurityGroup` è il nome logico assegnato alla risorsa del gruppo di sicurezza EC2. La funzione `Ref` viene quindi utilizzata per fare riferimento a risorse e parametri tramite i rispettivi nomi logici in altre parti del modello. Quando una risorsa fa riferimento a un’altra risorsa, ciò crea una dipendenza tra di esse.
      + La sezione **`Outputs`** definisce valori personalizzati restituiti dopo la creazione dello stack. È possibile utilizzare i valori di output per restituire informazioni dalle risorse dello stack, ad esempio identificatori di risorse o. URLs
      + Il modello definisce un output:
        + **`WebsiteURL`**: l’URL del server web distribuito, creato utilizzando il nome DNS pubblico dell’istanza EC2. La funzione `Join` aiuta a combinare l’`http://` fisso con il `PublicDnsName` variabile in un’unica stringa, semplificando l’output dell’URL completo del server web.

   1. Scegli **Convalida** per assicurarti che il codice YAML sia valido prima di caricare il modello.

   1. Quindi, scegli **Crea modello** per creare il modello e aggiungerlo a un bucket S3.

   1. Nella finestra di dialogo che si apre, prendi nota del nome del bucket S3 in modo da poterlo eliminare in un secondo momento. Quindi, scegli **Conferma e continua con**. CloudFormation Questo ti porta alla CloudFormation console in cui è ora specificato il percorso S3 del tuo modello.

1. Nella pagina **Crea stack**, scegli **Avanti**.

1. Nella pagina **Specifica dettagli dello stack**, inserisci un nome nel campo **Nome stack**. Il nome dello stack non può contenere spazi. Per questo esempio, utilizzare **MyTestStack**.

1. In **Parametri** specifica i valori dei parametri come segue:
   + **LatestAmiId**: per impostazione predefinita, è impostata sull'ultima AMI Amazon Linux 2.
   + **InstanceType**: Scegli **t2.micro o **t3.micro**** per il tipo di istanza EC2.
**Nota**  
Se non lo utilizzi AWS, puoi utilizzare il piano gratuito per avviare e utilizzare un'`t2.micro`istanza gratuitamente per 12 mesi (nelle regioni in cui non `t2.micro` è disponibile, puoi utilizzare un'`t3.micro`istanza al di sotto del livello gratuito).
   + **MyIP**: specifica il tuo indirizzo IP pubblico effettivo con un suffisso `/32`. Il suffisso `/32` viene utilizzato nella notazione CIDR per specificare che è consentito un solo indirizzo IP. In sostanza significa consentire il traffico unicamente da e verso questo indirizzo IP specifico.

1. Scegli **Avanti** due volte per andare alla pagina **Nomina, verifica e crea**. Per questo tutorial, puoi lasciare le impostazioni predefinite nella pagina **Configura le opzioni dello stack** così come sono.

1. Rivedi le informazioni per lo stack. Quando si è soddisfatti delle impostazioni, seleziona **Submit (Invia)**.

## Monitoraggio della creazione dello stack
<a name="getting-started-monitor-stack-creation"></a>

Dopo aver scelto **Invia**, CloudFormation inizia a creare le risorse specificate nel modello. Il nuovo stack,**MyTestStack**, viene visualizzato nell'elenco nella parte superiore della **CloudFormation**console. Il suo stato dovrebbe essere `CREATE_IN_PROGRESS`. È possibile vedere lo stato dettagliato di uno stack visualizzandone gli eventi.

**Visualizzazione degli eventi per lo stack**

1. Sulla CloudFormation console, scegli lo stack dall'**MyTestStack**elenco.

1. Nel riquadro dei dettagli dello stack, scegliere la scheda **Events (Eventi)**.

   La console aggiorna automaticamente l’elenco di eventi con quelli più recenti ogni 60 secondi.

La scheda **Eventi** mostra tutte le fasi principali nella creazione dello stack, ordinate per orario dell’evento, con gli ultimi eventi nella parte superiore.

Il primo evento (nella parte inferiore dell’elenco di eventi) è l’inizio del processo di creazione dello stack:

`2024-12-23 18:54 UTC-7 MyTestStack CREATE_IN_PROGRESS User initiated`

Di seguito vengono mostrati tutti gli eventi che segnano l’inizio e il completamento della creazione di ogni risorsa. Ad esempio, la creazione dell’istanza EC2 genera le seguenti voci:

`2024-12-23 18:59 UTC-7 WebServer CREATE_COMPLETE`

`2024-12-23 18:54 UTC-7 WebServer CREATE_IN_PROGRESS Resource creation initiated`

L'`CREATE_IN_PROGRESS`evento viene registrato quando CloudFormation segnala che ha iniziato a creare la risorsa. L’evento `CREATE_COMPLETE` viene registrato quando la risorsa viene creata senza errori.

Una volta CloudFormation creato con successo lo stack, vedrai il seguente evento nella parte superiore della scheda **Eventi**:

`2024-12-23 19:17 UTC-7 MyTestStack CREATE_COMPLETE`

Se non CloudFormation riesce a creare una risorsa, segnala un `CREATE_FAILED` evento e, per impostazione predefinita, ripristina lo stack ed elimina tutte le risorse che sono state create. La colonna **Status Reason (Motivo dello stato)** mostra il problema che ha causato l’errore.

Dopo aver creato lo stack, puoi andare alla scheda **Risorse** per visualizzare l’istanza EC2 e il gruppo di sicurezza che hai creato.

## Test del server web
<a name="getting-started-test-web-server"></a>

Dopo aver creato correttamente lo stack, vai alla scheda **Output nella console**. CloudFormation Cerca il campo **WebsiteURL**. Questo campo conterrà l’URL pubblico della tua istanza EC2.

Apri un browser e vai all’URL elencato in **WebsiteURL**. Dovresti visualizzare un semplice messaggio "Hello World\$1" nel browser.

Ciò conferma che l’istanza EC2 esegue Apache HTTP Server e serve una pagina web di base.

## Risoluzione dei problemi
<a name="getting-started-troubleshooting"></a>

Se si verifica un rollback durante la creazione dello stack, la causa potrebbe essere la mancanza di un VPC. Ecco come risolvere il problema.

### VPC predefinito non disponibile
<a name="getting-started-troubleshooting-no-default-vpc"></a>

Il modello in questa procedura dettagliata richiede un VPC predefinito. Se la creazione dello stack non riesce a causa di errori di disponibilità del VPC o della sottorete, potresti non avere un VPC predefinito nel tuo account. Sono disponibili le seguenti opzioni:
+ **Crea un nuovo VPC predefinito**: puoi creare un nuovo VPC predefinito tramite la console Amazon VPC. Per le istruzioni, consulta [Create a default VPC](https://docs.aws.amazon.com/vpc/latest/userguide/work-with-default-vpc.html#create-default-vpc) nella *Guida per l’utente di Amazon VPC*.
+ **Modifica il modello per specificare una sottorete**: se disponi di un VPC non predefinito, puoi modificare il modello per specificare in modo esplicito il VPC e la sottorete. IDs Aggiungi al modello il seguente parametro:

  ```
    SubnetId:
      Description: The subnet ID to launch the instance into
      Type: AWS::EC2::Subnet::Id
  ```

  Quindi, aggiorna la risorsa `WebServer` per includere l’ID della sottorete:

  ```
    WebServer:
      Type: AWS::EC2::Instance
      Properties:
        ImageId: !Ref LatestAmiId
        InstanceType: !Ref InstanceType
        SecurityGroupIds:
          - !Ref WebServerSecurityGroup
        SubnetId: !Ref SubnetId
        UserData: !Base64 |
          #!/bin/bash
          yum update -y
          yum install -y httpd
          systemctl start httpd
          systemctl enable httpd
          echo "<html><body><h1>Hello World!</h1></body></html>" > /var/www/html/index.html
  ```

  Durante la creazione dello stack, devi specificare una sottorete con accesso a Internet affinché il server Web sia raggiungibile.

## Eliminazione
<a name="getting-started-clean-up"></a>

Per assicurarti che non ti vengano addebitati servizi indesiderati, puoi eseguire una pulizia eliminando lo stack e le relative risorse. Puoi anche eliminare il bucket S3 che memorizza il modello dello stack.

**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 (**MyTestStack**), 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 **MyTestStack** cambia in `DELETE_IN_PROGRESS`. Una volta CloudFormation completata l'eliminazione dello stack, lo rimuove dall'elenco.

Se hai finito di lavorare con il modello di esempio e non hai più bisogno del bucket Amazon S3, eliminalo. Per eliminare un bucket devi innanzitutto rimuoverne i contenuti. Lo svuotamento di un bucket comporta l’eliminazione di tutti gli oggetti in esso contenuti.

**Svuotamento ed eliminazione del bucket Amazon S3**

1. Apri la [console Amazon S3](https://console.aws.amazon.com/s3/).

1. Nel riquadro di navigazione sul lato sinistro della console scegli **Bucket**.

1. Nell’elenco **Bucket**, scegli l’opzione accanto al nome del bucket che desideri svuotare, quindi scegli **Svuota**.

1. Nella pagina **Svuota il bucket**, conferma che desideri svuotare il bucket digitando **permanently delete** nel campo di testo, quindi scegli **Svuota**.

1. Monitorare l’avanzamento del processo di svuotamento del bucket nella pagina **Svuota bucket: stato**. 

1. Per tornare all’elenco dei bucket, scegliere **Esci**.

1. Seleziona l’opzione accanto al nome del bucket, quindi scegli **Elimina**.

1. Quando viene richiesta la conferma, digita il nome del bucket e scegli **Elimina bucket**.

1. Monitora l’avanzamento del processo di eliminazione del bucket dall’elenco **Bucket**. Quando Amazon S3 completa l’eliminazione del bucket, rimuove il bucket dall’elenco.

## Fasi successive
<a name="getting-started-next-steps"></a>

Complimenti\$1 Hai creato con successo uno stack, hai monitorato le sue creazioni e ne hai utilizzato l’output.

Per continuare a imparare:
+ Scopri di più sui modelli per crearne uno personalizzato. Per ulteriori informazioni, consulta [Lavorare con i CloudFormation modelli](template-guide.md).
+ Prova il workshop [Getting Started with CloudFormation](https://catalog.us-east-1.prod.workshops.aws/workshops/df7f72cf-4f10-4664-acb6-b30dc8d4bcf0/en-US) per ulteriori esercitazioni pratiche sulla creazione di modelli.
+ Per una versione abbreviata di [Getting](https://catalog.us-east-1.prod.workshops.aws/workshops/df7f72cf-4f10-4664-acb6-b30dc8d4bcf0/en-US) Started with, consulta. CloudFormation[Implementa le applicazioni su Amazon EC2](deploying.applications.md) Questo argomento descrive lo stesso scenario di utilizzo di uno script di CloudFormation supporto per avviare un'istanza Amazon EC2. `cfn-init`