

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

# Importazione AWS manuale delle risorse in uno CloudFormation stack
<a name="import-resources-manually"></a>

Con l'importazione delle risorse, puoi importare AWS le risorse esistenti in uno stack nuovo o esistente. CloudFormation Durante un’operazione di importazione, si crea un set di modifiche che importa le risorse esistenti in uno stack o crea un nuovo stack dalle risorse esistenti. Durante l’importazione è possibile fornire quanto segue.
+ Un modello che descrive l’intero stack, incluse le risorse dello stack originali e quelle in fase di importazione. Ogni risorsa da importare deve avere un [attributo DeletionPolicy](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-attribute-deletionpolicy.html).
+ Identificatori per le risorse che stai importando che CloudFormation possono essere utilizzati per mappare la logica IDs del modello con le risorse esistenti.

**Nota**  
CloudFormation supporta solo un livello di nidificazione utilizzando l'importazione di risorse. Ciò significa che non è possibile importare uno stack in uno stack figlio o importare uno stack con figli.

**Topics**
+ [Identificatori di risorse](#resource-import-identifiers-unique-ids)
+ [Convalida](#resource-import-validation)
+ [Codici di stato](#resource-import-status-codes)
+ [Considerazioni](#resource-import-considerations)
+ [Risorse aggiuntive](#resource-import-additional-resources)
+ [Creazione di uno stack da risorse esistenti](resource-import-new-stack.md)
+ [Importazione di risorse esistenti in uno stack](resource-import-existing-stack.md)
+ [Spostamento di risorse tra stack](refactor-stacks.md)
+ [Nidificazione di uno stack esistente](resource-import-nested-stacks.md)

## Identificatori di risorse
<a name="resource-import-identifiers-unique-ids"></a>

Vengono forniti due valori per identificare ogni risorsa che importi.
+ Una proprietà identificatore. Si tratta di una proprietà di risorsa che può essere utilizzata per identificare ogni tipo di risorsa. Ad esempio, una risorsa `AWS::S3::Bucket` può essere identificata utilizzando il suo `BucketName`.

  La proprietà di risorsa che usi per identificare la risorsa che stai importando varia a seconda del tipo di risorsa. Puoi trovare la proprietà della risorsa nella CloudFormation console. Dopo aver creato un modello che include la risorsa da importare, puoi avviare il processo di importazione, dove troverai le proprietà identificatore per le risorse che stai importando. Per alcuni tipi di risorse, potrebbero esserci diverse modalità di identificazione ed è possibile selezionare la proprietà da utilizzare negli elenchi a discesa.

  In alternativa, puoi ottenere le proprietà dell'identificatore per le risorse che stai importando chiamando il comando [get-template-summary](https://docs.aws.amazon.com/cli/latest/reference/cloudformation/get-template-summary.html)CLI e specificando l'URL S3 del modello di stack come valore per l'opzione. `--template-url`
+ Un valore identificativo. Questo è il valore effettivo della proprietà della risorsa. Ad esempio, il valore effettivo per la proprietà `BucketName` potrebbe essere `MyS3Bucket`.

  È possibile ottenere il valore della proprietà identificatore dalla console di servizio per la risorsa.

## Convalida dell’importazione delle risorse
<a name="resource-import-validation"></a>

Durante un'operazione di importazione, esegue le seguenti convalide. CloudFormation 
+ La risorsa da importare esiste.
+ Le proprietà e i valori di configurazione per ogni risorsa da importare aderiscono allo schema del tipo di risorsa, che definisce le proprietà accettate, le proprietà richieste e i valori delle proprietà supportate.
+ Le proprietà richieste sono specificate nel modello. Le proprietà richieste per ogni tipo di risorsa sono descritte nell’argomento relativo alle [informazioni di riferimento sulle proprietà e le risorse di AWS](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-template-resource-type-ref.html).
+ La risorsa da importare non appartiene a un altro stack nella stessa Regione.

CloudFormation non verifica che la configurazione del modello corrisponda alla configurazione effettiva delle proprietà delle risorse.

**Importante**  
Verifica che le risorse e le rispettive proprietà definite nel modello corrispondano alla configurazione prevista per l’importazione delle risorse per evitare modifiche impreviste.

## Codici di stato dell’importazione delle risorse
<a name="resource-import-status-codes"></a>

Questa tabella descrive i vari tipi di stato utilizzati con la funzionalità di importazione delle risorse.


| Stato dell’operazione di importazione | Description | 
| --- | --- | 
|  `IMPORT_IN_PROGRESS`  |  L’operazione di importazione è in corso.  | 
|  `IMPORT_COMPLETE`  |  L’operazione di importazione è stata completata per tutte le risorse nello stack.  | 
|  `IMPORT_ROLLBACK_IN_PROGRESS`  |  L’operazione di importazione di rollback sta eseguendo il rollback della configurazione del modello precedente.  | 
|  `IMPORT_ROLLBACK_FAILED`  |  L’operazione di rollback dell’importazione ha avuto esito negativo.  | 
|  `IMPORT_ROLLBACK_COMPLETE`  |  È stato eseguito il rollback dell’importazione alla configurazione del modello precedente.  | 

## Considerazioni durante un’operazione di importazione
<a name="resource-import-considerations"></a>
+ Al termine dell’importazione e prima di eseguire operazioni di stack successive, ti consigliamo di eseguire il rilevamento della deviazione sulle risorse importate. Il rilevamento della deviazione garantisce che la configurazione del modello corrisponda alla configurazione effettiva. Per ulteriori informazioni, consulta [Rileva la deriva su un'intera CloudFormation pila](detect-drift-stack.md).
+ Le operazioni di importazione non consentono nuove creazioni di risorse, eliminazioni di risorse o modifiche alle configurazioni di proprietà.
+ Ogni risorsa da importare deve avere un attributo `DeletionPolicy` affinché l’operazione di importazione abbia esito positivo. È possibile impostare `DeletionPolicy` su qualsiasi valore possibile. Solo le risorse che stai importando necessitano di una `DeletionPolicy`. Le risorse che fanno già parte dello stack non richiedono una `DeletionPolicy`.
+ Non è possibile importare la stessa risorsa in più stack.
+ È possibile utilizzare la condizione della policy IAM `cloudformation:ImportResourceTypes` per controllare i tipi di risorse con cui gli utenti possono lavorare durante un’operazione di importazione. Per ulteriori informazioni, consulta [Chiavi relative alle condizioni politiche per CloudFormation](control-access-with-iam.md#using-iam-conditions).
+ I limiti CloudFormation dello stack si applicano all'importazione di risorse. Per ulteriori informazioni sui limiti, consulta [Comprendi le CloudFormation quote](cloudformation-limits.md).

## Risorse aggiuntive
<a name="resource-import-additional-resources"></a>

Per risolvere la deriva dello stack con l’importazione di risorse, consulta [Risoluzione della deviazione con un’operazione di importazione](resource-import-resolve-drift.md).

# Creazione di uno stack da risorse esistenti
<a name="resource-import-new-stack"></a>

Questo argomento mostra come creare uno stack a partire da AWS risorse esistenti descrivendole in un modello. Per cercare invece le risorse esistenti e generare automaticamente un modello da utilizzare per importare risorse esistenti CloudFormation o replicare le risorse in un nuovo account, consulta. [Generazione di modelli da risorse esistenti con il generatore IaC](generate-IaC.md)

**Prerequisiti**

Prima di iniziare, devi:
+ disporre di un modello che descrive tutte le risorse che desideri nel nuovo stack; salvare il modello in locale o in un bucket Amazon S3. 
+ Per ogni risorsa che desideri importare, includi:
  + le proprietà e i valori delle proprietà che definiscono la configurazione corrente della risorsa;
  + l’identificativo univoco per la risorsa, ad esempio il nome della risorsa. Per ulteriori informazioni, consulta [Identificatori di risorse](import-resources-manually.md#resource-import-identifiers-unique-ids).
  + gli [Attributi della DeletionPolicy](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-attribute-deletionpolicy.html).

**Topics**
+ [Modello di esempio](#resource-import-new-stack-example-template)
+ [Crea uno stack dalle risorse esistenti utilizzando il Console di gestione AWS](#resource-import-new-stack-console)
+ [Crea uno stack dalle risorse esistenti utilizzando il AWS CLI](#resource-import-new-stack-cli)

## Modello di esempio
<a name="resource-import-new-stack-example-template"></a>

In questa procedura dettagliata, supponiamo che tu stia utilizzando il seguente modello di esempio, chiamato`TemplateToImport.json`, che specifica due tabelle DynamoDB che sono state create all'esterno di. CloudFormation `ServiceTable`e `GamesTable` sono gli obiettivi dell'importazione. 

**Nota**  
Questo modello è inteso solo come esempio. Per utilizzarlo per scopi di test, sostituisci le risorse di esempio con le risorse del tuo account. 

```
{
    "AWSTemplateFormatVersion": "2010-09-09",
    "Description": "Import test",
    "Resources": {
        "ServiceTable": {
            "Type": "AWS::DynamoDB::Table",
            "DeletionPolicy": "Retain",
            "Properties": {
                "TableName": "Service",
                "AttributeDefinitions": [
                    {
                        "AttributeName": "key",
                        "AttributeType": "S"
                    }
                ],
                "KeySchema": [
                    {
                        "AttributeName": "key",
                        "KeyType": "HASH"
                    }
                ],
                "ProvisionedThroughput": {
                    "ReadCapacityUnits": 5,
                    "WriteCapacityUnits": 1
                }
            }
        },
        "GamesTable": {
            "Type": "AWS::DynamoDB::Table",
            "DeletionPolicy": "Retain",
            "Properties": {
                "TableName": "Games",
                "AttributeDefinitions": [
                    {
                        "AttributeName": "key",
                        "AttributeType": "S"
                    }
                ],
                "KeySchema": [
                    {
                        "AttributeName": "key",
                        "KeyType": "HASH"
                    }
                ],
                "ProvisionedThroughput": {
                    "ReadCapacityUnits": 5,
                    "WriteCapacityUnits": 1
                }
            }
        }
    }
}
```

## Crea uno stack dalle risorse esistenti utilizzando il Console di gestione AWS
<a name="resource-import-new-stack-console"></a>

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 pagina **Stack**, scegli **Crea stack**, quindi scegli **Con risorse esistenti (risorse di importazione)**.  
![\[L’opzione Crea stack da risorse esistenti nella console.\]](http://docs.aws.amazon.com/it_it/AWSCloudFormation/latest/UserGuide/images/create-stack-with-existing-resources.png)

1. Leggi la pagina **Panoramica importazione** per un elenco di elementi da fornire durante questa operazione. Quindi, seleziona **Successivo**.

1. Nella pagina **Specifica modello**, fornisci il modello utilizzando uno dei metodi descritti di seguito, quindi scegli **Successivo**.
   + Scegli **URL Amazon S3**, quindi specificare l’URL per il tuo modello nella casella di testo.
   + Scegli **Carica un file modello**, quindi cercare il modello.

1. Nella pagina **Identifica risorse**, identifica ogni risorsa di destinazione. Per ulteriori informazioni, consulta [Identificatori di risorse](import-resources-manually.md#resource-import-identifiers-unique-ids).

   1. In **Proprietà identificatore**, scegli il tipo di identificatore di risorsa. Ad esempio, la risorsa `AWS::DynamoDB::Table` può essere identificata utilizzando la proprietà `TableName`.

   1. In **Valore identificatore**, digita il valore effettivo della proprietà. Ad esempio, il `TableName` per la risorsa `GamesTable` nel modello di esempio è `Games`. 

   1. Scegli **Successivo**.

1. Nella pagina **Specifica dettagli stack**, modifica i parametri, quindi scegli **Successivo**. Questo crea automaticamente un set di modifiche.
**Importante**  
L’operazione di importazione ha esito negativo se si modificano i parametri esistenti che iniziano un’operazione di creazione, aggiornamento o eliminazione.

1. **Nella *stack-name* pagina **Revisione**, conferma che vengano importate le risorse corrette, quindi scegli Importa risorse.** In questo modo si esegue automaticamente il set di modifiche creato nell’ultimo passaggio.

   Per il nuovo stack viene visualizzato il riquadro **Eventi** della pagina **Dettagli stack**.  
![\[La scheda Eventi nella console.\]](http://docs.aws.amazon.com/it_it/AWSCloudFormation/latest/UserGuide/images/import-events.png)

1. (Facoltativo) Esegui il rilevamento della deviazione nello stack per assicurarti che il modello e la configurazione effettiva delle risorse importate corrispondano. Per ulteriori informazioni sul rilevamento delle deviazioni, consulta [Rileva la deriva su un'intera CloudFormation pila](detect-drift-stack.md).

1. (Facoltativo) Se le risorse importate non corrispondono alle configurazioni dei modelli previste, correggi le configurazioni dei modelli o aggiorna direttamente le risorse. In questa spiegazione passo per passo, vengono corrette le configurazioni dei modelli in modo che corrispondano alle configurazioni effettive.

   1. [Ripristina l’operazione di importazione](resource-import-revert.md#resource-import-revert-console) per le risorse interessate.

   1. Aggiungi nuovamente le destinazioni di importazione al modello, assicurandoti che le configurazioni del modello corrispondano alle configurazioni effettive.

   1. Ripeti i passaggi 2-8 utilizzando il modello modificato per importare nuovamente le risorse.

## Crea uno stack a partire da risorse esistenti utilizzando il AWS CLI
<a name="resource-import-new-stack-cli"></a>

1. Per scoprire quali proprietà identificano ogni tipo di risorsa nel modello, esegui il comando **get-template-summary**, specificando l’URL S3 del modello. Ad esempio, la risorsa `AWS::DynamoDB::Table` può essere identificata utilizzando la proprietà `TableName`. Per la risorsa `GamesTable` nel modello di esempio, il valore di `TableName` è `Games`. Queste informazioni ti serviranno nella fase successiva.

   ```
   aws cloudformation get-template-summary \
       --template-url https://amzn-s3-demo-bucket.s3.us-west-2.amazonaws.com/TemplateToImport.json
   ```

   Per ulteriori informazioni, consulta [Identificatori di risorse](import-resources-manually.md#resource-import-identifiers-unique-ids).

1. Componi un elenco delle risorse attuali del modello e dei relativi identificatori univoci nel seguente formato della stringa JSON.

   ```
   [{"ResourceType":"AWS::DynamoDB::Table","LogicalResourceId":"GamesTable","ResourceIdentifier":{"TableName":"Games"}},{"ResourceType":"AWS::DynamoDB::Table","LogicalResourceId":"ServiceTable","ResourceIdentifier":{"TableName":"Service"}}]
   ```

   In alternativa, puoi specificare i parametri formattati JSON in un file di configurazione.

   Ad esempio, per importare `ServiceTable` e`GamesTable`, è possibile creare un *ResourcesToImport.txt* file che contenga la seguente configurazione.

   ```
   [
      {
         "ResourceType":"AWS::DynamoDB::Table",
         "LogicalResourceId":"GamesTable",
         "ResourceIdentifier":{
            "TableName":"Games"
         }
      },
      {
         "ResourceType":"AWS::DynamoDB::Table",
         "LogicalResourceId":"ServiceTable",
         "ResourceIdentifier":{
            "TableName":"Service"
         }
      }
   ]
   ```

1. Per creare un set di modifiche, utilizza il seguente comando **create-change-set** e sostituisci il testo segnaposto. Per l’opzione `--change-set-type`, specifica il valore di **IMPORT**. Per l’opzione `--resources-to-import`, sostituisci la stringa JSON di esempio con la stringa JSON effettiva che hai appena creato.

   ```
   aws cloudformation create-change-set \
       --stack-name TargetStack --change-set-name ImportChangeSet \
       --change-set-type IMPORT \
       --template-url https://amzn-s3-demo-bucket.s3.us-west-2.amazonaws.com/TemplateToImport.json \
       --resources-to-import '[{"ResourceType":"AWS::DynamoDB::Table","LogicalResourceId":"GamesTable","ResourceIdentifier":{"TableName":"Games"}},{"ResourceType":"AWS::DynamoDB::Table","LogicalResourceId":"ServiceTable","ResourceIdentifier":{"TableName":"Service"}}]'
   ```
**Nota**  
`--resources-to-import` non supporta YAML in linea. I requisiti per l’escape delle virgolette nella stringa JSON variano in base al terminale. Per ulteriori informazioni, consulta [Utilizzo di virgolette all’interno di stringhe](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-parameters-quoting-strings.html#cli-usage-parameters-quoting-strings-containing) nella *Guida per l’utente di AWS Command Line Interface *.

   In alternativa, è possibile anche utilizzare l’URL del file come input per l’opzione `--resources-to-import`, come mostrato nell’esempio seguente.

   ```
   --resources-to-import file://ResourcesToImport.txt
   ```

1. Esamina il set di modifiche per assicurarti che vengano importate le risorse corrette.

   ```
   aws cloudformation describe-change-set \
       --change-set-name ImportChangeSet --stack-name TargetStack
   ```

1. Per avviare il set di modifiche e importare le risorse, utilizza il seguente comando **execute-change-set** e sostituisci il testo segnaposto. Al completamento dell’operazione `(IMPORT_COMPLETE)`, le risorse vengono importate correttamente.

   ```
   aws cloudformation execute-change-set \
       --change-set-name ImportChangeSet --stack-name TargetStack
   ```

1. (Facoltativo) Esegui il rilevamento della deviazione sullo stack `IMPORT_COMPLETE` per assicurarti che il modello e la configurazione effettiva delle risorse importate corrispondano. Per ulteriori informazioni, consulta [Rilevamento della deviazione su singole risorse di stack](detect-drift-resource.md).

   1. Esegui il rilevamento della deriva sullo stack specificato.

      ```
      aws cloudformation detect-stack-drift --stack-name TargetStack
      ```

      Se eseguito correttamente, il comando restituirà il seguente output di esempio.

      ```
      { "Stack-Drift-Detection-Id" : "624af370-311a-11e8-b6b7-500cexample" }
      ```

   1. Visualizza lo stato di avanzamento di un’operazione di rilevamento della deriva per l’ID di rilevamento della deriva dello stack specificato.

      ```
      aws cloudformation describe-stack-drift-detection-status \
          --stack-drift-detection-id 624af370-311a-11e8-b6b7-500cexample
      ```

   1. Visualizza le informazioni di deviazione per le risorse la cui deviazione è stata controllata all’interno dello stack specificato.

      ```
      aws cloudformation describe-stack-resource-drifts --stack-name TargetStack
      ```

1. (Facoltativo) Se le risorse importate non corrispondono alle configurazioni dei modelli previste, correggi le configurazioni dei modelli o aggiorna direttamente le risorse. In questa spiegazione passo per passo, vengono corrette le configurazioni dei modelli in modo che corrispondano alle configurazioni effettive.

   1. [Ripristina l’operazione di importazione](resource-import-revert.md#resource-import-revert-cli) per le risorse interessate.

   1. Aggiungi nuovamente le destinazioni di importazione al modello, assicurandoti che le configurazioni del modello corrispondano alle configurazioni effettive.

   1. Ripeti i passaggi 3-6 utilizzando il modello modificato per importare nuovamente le risorse.

# Importazione di risorse esistenti in uno stack
<a name="resource-import-existing-stack"></a>

Questo argomento mostra come importare AWS risorse esistenti in uno stack esistente descrivendole in un modello. Per cercare invece le risorse esistenti e generare automaticamente un modello da utilizzare per importare risorse esistenti CloudFormation o replicare le risorse in un nuovo account, consulta. [Generazione di modelli da risorse esistenti con il generatore IaC](generate-IaC.md)

**Prerequisiti**

Prima di iniziare, devi:
+ Un modello che descrive l’intero stack, incluse le risorse che fanno già parte dello stack e le risorse da importare. Salva il modello in locale o in un bucket Amazon S3. 

  **Per ottenere una copia del modello di uno stack in esecuzione**

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

  1. Dagli elenchi di stack, scegli lo stack da cui recuperare il modello.

  1. Nel riquadro dei dettagli dello stack, scegli la scheda **Modello**, quindi scegli **Copia negli appunti**.

  1. Incolla il codice in un editor di testo per iniziare ad aggiungere altre risorse al modello.
+ Per ogni risorsa che desideri importare, includi:
  + le proprietà e i valori delle proprietà che definiscono la configurazione corrente della risorsa;
  + l’identificativo univoco per la risorsa, ad esempio il nome della risorsa. Per ulteriori informazioni, consulta [Identificatori di risorse](import-resources-manually.md#resource-import-identifiers-unique-ids).
  + gli [Attributi della DeletionPolicy](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-attribute-deletionpolicy.html).

**Topics**
+ [Modello di esempio](#resource-import-existing-stack-example-template)
+ [Importa una risorsa esistente in uno stack utilizzando il Console di gestione AWS](#resource-import-existing-stack-console)
+ [Importa una risorsa esistente in una pila utilizzando il AWS CLI](#resource-import-existing-stack-cli)

## Modello di esempio
<a name="resource-import-existing-stack-example-template"></a>

In questa procedura guidata, supponiamo che tu stia utilizzando il seguente modello di esempio, chiamato `TemplateToImport.json`, che specifica due tabelle DynamoDB. `ServiceTable` è attualmente parte dello stack e `GamesTable` è la tabella che desideri importare.

**Nota**  
Questo modello è inteso solo come esempio. Per utilizzarlo per scopi di test, sostituisci le risorse di esempio con le risorse del tuo account. 

```
{
    "AWSTemplateFormatVersion": "2010-09-09",
    "Description": "Import test",
    "Resources": {
        "ServiceTable": {
            "Type": "AWS::DynamoDB::Table",
            "Properties": {
                "TableName": "Service",
                "AttributeDefinitions": [
                    {
                        "AttributeName": "key",
                        "AttributeType": "S"
                    }
                ],
                "KeySchema": [
                    {
                        "AttributeName": "key",
                        "KeyType": "HASH"
                    }
                ],
                "ProvisionedThroughput": {
                    "ReadCapacityUnits": 5,
                    "WriteCapacityUnits": 1
                }
            }
        },
        "GamesTable": {
            "Type": "AWS::DynamoDB::Table",
            "DeletionPolicy": "Retain",
            "Properties": {
                "TableName": "Games",
                "AttributeDefinitions": [
                    {
                        "AttributeName": "key",
                        "AttributeType": "S"
                    }
                ],
                "KeySchema": [
                    {
                        "AttributeName": "key",
                        "KeyType": "HASH"
                    }
                ],
                "ProvisionedThroughput": {
                    "ReadCapacityUnits": 5,
                    "WriteCapacityUnits": 1
                }
            }
        }
    }
}
```

## Importa una risorsa esistente in uno stack utilizzando il Console di gestione AWS
<a name="resource-import-existing-stack-console"></a>

**Nota**  
La CloudFormation console non supporta l'uso della funzione intrinseca `Fn::Transform` durante l'importazione di risorse. È possibile utilizzare il AWS CLI per importare risorse che utilizzano la funzione. `Fn::Transform`

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 pagina **Stack**, scegli lo stack in cui importare le risorse.

1. Scegli **Operazioni stack**, quindi scegli **Importa risorse nello stack**.  
![\[L’opzione Importa risorse nello stack nella console.\]](http://docs.aws.amazon.com/it_it/AWSCloudFormation/latest/UserGuide/images/stack-actions-import.png)

1. Rivedi la pagina **Panoramica importazione**, quindi scegli **Successivo**.

1. Nella pagina **Specifica modello**, fornisci il modello aggiornato utilizzando uno dei metodi descritti di seguito, quindi scegli **Successivo**.
   + Scegli **URL Amazon S3**, quindi specifica l’URL per il tuo modello nella casella di testo.
   + Scegli **Carica un file modello**, quindi cercare il modello.

1. Nella pagina **Identifica risorse**, identifica ogni risorsa di destinazione. Per ulteriori informazioni, consulta [Identificatori di risorse](import-resources-manually.md#resource-import-identifiers-unique-ids).

   1. In **Proprietà identificatore**, scegli il tipo di identificatore di risorsa. Ad esempio, la risorsa `AWS::DynamoDB::Table` può essere identificata utilizzando la proprietà `TableName`.

   1. In **Valore identificatore**, digita il valore effettivo della proprietà. Ad esempio, il `TableName` per la risorsa `GamesTable` nel modello di esempio è `Games`.

   1. Scegli **Successivo**.

1. Nella pagina **Specifica dettagli stack**, aggiorna i parametri, quindi scegli **Successivo**. Questo crea automaticamente un set di modifiche.
**Nota**  
L’operazione di importazione ha esito negativo se si modificano i parametri esistenti che iniziano un’operazione di creazione, aggiornamento o eliminazione.

1. **Nella *stack-name* pagina **Revisione**, esamina le risorse da importare, quindi scegli Importa risorse.** In questo modo si esegue automaticamente il set di modifiche creato nell’ultimo passaggio. Tutti i tag a livello di stack vengono applicati alle risorse importate in questo momento. Per ulteriori informazioni, consulta [Configurazione delle opzioni dello stack](cfn-console-create-stack.md#configure-stack-options).

   Viene visualizzata la pagina **Eventi** per lo stack.  
![\[La scheda Eventi nella console.\]](http://docs.aws.amazon.com/it_it/AWSCloudFormation/latest/UserGuide/images/import-events.png)

1. (Facoltativo) Esegui il rilevamento della deviazione nello stack per assicurarti che il modello e la configurazione effettiva delle risorse importate corrispondano. Per ulteriori informazioni sul rilevamento delle deviazioni, consulta [Rileva la deriva su un'intera CloudFormation pila](detect-drift-stack.md).

1. (Facoltativo) Se le risorse importate non corrispondono alle configurazioni dei modelli previste, correggi le configurazioni dei modelli o aggiorna direttamente le risorse. Per ulteriori informazioni sull’importazione delle risorse con deviazioni, consulta [Risoluzione della deviazione con un’operazione di importazione](resource-import-resolve-drift.md).

## Importa una risorsa esistente in una pila utilizzando il AWS CLI
<a name="resource-import-existing-stack-cli"></a>

1. Per scoprire quali proprietà identificano ogni tipo di risorsa nel modello, esegui il comando **get-template-summary**, specificando l’URL S3 del modello. Ad esempio, la risorsa `AWS::DynamoDB::Table` può essere identificata utilizzando la proprietà `TableName`. Per la risorsa `GamesTable` nel modello di esempio, il valore di `TableName` è `Games`. Queste informazioni ti serviranno nella fase successiva.

   ```
   aws cloudformation get-template-summary \
       --template-url https://amzn-s3-demo-bucket.s3.us-west-2.amazonaws.com/TemplateToImport.json
   ```

   Per ulteriori informazioni, consulta [Identificatori di risorse](import-resources-manually.md#resource-import-identifiers-unique-ids).

1. Componi un elenco di risorse attuali da importare e di relativi identificatori univoci nel seguente formato della stringa JSON.

   ```
   [{"ResourceType":"AWS::DynamoDB::Table","LogicalResourceId":"GamesTable","ResourceIdentifier":{"TableName":"Games"}}]
   ```

   In alternativa, puoi specificare i parametri formattati JSON in un file di configurazione. 

   Ad esempio, per importare`GamesTable`, è possibile creare un *ResourcesToImport.txt* file che contenga la seguente configurazione.

   ```
   [
     {
         "ResourceType":"AWS::DynamoDB::Table",
         "LogicalResourceId":"GamesTable",
         "ResourceIdentifier": {
           "TableName":"Games"
         }
     }
   ]
   ```

1. Per creare un set di modifiche, utilizza il seguente comando **create-change-set** e sostituisci il testo segnaposto. Per l’opzione `--change-set-type`, specifica il valore di **IMPORT**. Per l’opzione `--resources-to-import`, sostituisci la stringa JSON di esempio con la stringa JSON effettiva che hai appena creato.

   ```
   aws cloudformation create-change-set \
       --stack-name TargetStack --change-set-name ImportChangeSet \
       --change-set-type IMPORT \
       --template-url https://amzn-s3-demo-bucket.s3.us-west-2.amazonaws.com/TemplateToImport.json \
       --resources-to-import '[{"ResourceType":"AWS::DynamoDB::Table","LogicalResourceId":"GamesTable","ResourceIdentifier":{"TableName":"Games"}}]'
   ```
**Nota**  
`--resources-to-import` non supporta YAML in linea. I requisiti per l’escape delle virgolette nella stringa JSON variano in base al terminale. Per ulteriori informazioni, consulta [Utilizzo di virgolette all’interno di stringhe](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-parameters-quoting-strings.html#cli-usage-parameters-quoting-strings-containing) nella *Guida per l’utente di AWS Command Line Interface *.

   In alternativa, è possibile anche utilizzare l’URL del file come input per l’opzione `--resources-to-import`, come mostrato nell’esempio seguente.

   ```
   --resources-to-import file://ResourcesToImport.txt
   ```

1. Esamina il set di modifiche per assicurarti che vengano importate le risorse corrette.

   ```
   aws cloudformation describe-change-set \
       --change-set-name ImportChangeSet --stack-name TargetStack
   ```

1. Per avviare il set di modifiche e importare le risorse, utilizza il seguente comando **execute-change-set** e sostituisci il testo segnaposto. Tutti i tag a livello di stack vengono applicati alle risorse importate in questo momento. Per ulteriori informazioni, consulta [Configurazione delle opzioni dello stack](cfn-console-create-stack.md#configure-stack-options). Al completamento dell’operazione `(IMPORT_COMPLETE)`, le risorse vengono importate correttamente.

   ```
   aws cloudformation execute-change-set \
       --change-set-name ImportChangeSet --stack-name TargetStack
   ```

1. (Facoltativo) Esegui il rilevamento della deviazione sullo stack `IMPORT_COMPLETE` per assicurarti che il modello e la configurazione effettiva delle risorse importate corrispondano. Per ulteriori informazioni sul rilevamento delle deviazioni, consulta [Rileva la deriva su un'intera CloudFormation pila](detect-drift-stack.md).

   1. Esegui il rilevamento della deriva sullo stack specificato.

      ```
      aws cloudformation detect-stack-drift --stack-name TargetStack
      ```

      Se eseguito correttamente, il comando restituirà il seguente output di esempio.

      ```
      { "Stack-Drift-Detection-Id" : "624af370-311a-11e8-b6b7-500cexample" }
      ```

   1. Visualizza lo stato di avanzamento di un’operazione di rilevamento della deriva per l’ID di rilevamento della deriva dello stack specificato.

      ```
      aws cloudformation describe-stack-drift-detection-status \
          --stack-drift-detection-id 624af370-311a-11e8-b6b7-500cexample
      ```

   1. Visualizza le informazioni di deviazione per le risorse la cui deviazione è stata controllata all’interno dello stack specificato.

      ```
      aws cloudformation describe-stack-resource-drifts --stack-name TargetStack
      ```

1. (Facoltativo) Se le risorse importate non corrispondono alle configurazioni dei modelli previste, correggi le configurazioni dei modelli o aggiorna direttamente le risorse. Per ulteriori informazioni sull’importazione delle risorse con deviazioni, consulta [Risoluzione della deviazione con un’operazione di importazione](resource-import-resolve-drift.md).

# Spostamento di risorse tra stack
<a name="refactor-stacks"></a>

Utilizzando la funzionalità `resource import`, è possibile spostare le risorse tra stack o eseguirne il *refactoring*. Prima di tutto è necessario aggiungere una policy di eliminazione `Retain` alla risorsa da spostare per fare in modo che la risorsa venga mantenuta quando viene rimossa dallo stack di origine e importata nello stack di destinazione.

Se non conosci l’importazione, ti consigliamo di esaminare prima le informazioni introduttive nella sezione [Importa AWS risorse in una CloudFormation pila](import-resources.md).

**Importante**  
Non tutte le risorse supportano le operazioni di importazione. Consulta [Risorse che supportano le operazioni di importazione](resource-import-supported-resources.md) prima di rimuovere una risorsa dallo stack. Se rimuovi una risorsa che non supporta le operazioni di importazione dallo stack, non potrai importarla in un altro stack o riportarla nello stack di origine.

## Rifattorizza uno stack usando il Console di gestione AWS
<a name="refactor-stacks-console"></a>

1. Nel modello di origine, specificate a `Retain` [DeletionPolicy](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-attribute-deletionpolicy.html)per la risorsa che desiderate spostare.

   Nel seguente modello di origine di esempio, `Games` è la destinazione di questo refactoring.  
**Example JSON**  

   ```
   {
       "AWSTemplateFormatVersion": "2010-09-09",
       "Description": "Import test",
       "Resources": {
           "ServiceTable":{
              "Type":"AWS::DynamoDB::Table",
              "Properties":{
                 "TableName":"Service",
                 "AttributeDefinitions":[
                    {
                       "AttributeName":"key",
                       "AttributeType":"S"
                    }
                 ],
                 "KeySchema":[
                    {
                       "AttributeName":"key",
                       "KeyType":"HASH"
                    }
                 ],
                 "ProvisionedThroughput":{
                    "ReadCapacityUnits":5,
                    "WriteCapacityUnits":1
                 }
              }
           },
           "GamesTable": {
               "Type": "AWS::DynamoDB::Table",
               "DeletionPolicy": "Retain",
               "Properties": {
                   "TableName": "Games",
                   "AttributeDefinitions": [
                       {
                           "AttributeName": "key",
                           "AttributeType": "S"
                       }
                   ],
                   "KeySchema": [
                       {
                           "AttributeName": "key",
                           "KeyType": "HASH"
                       }
                   ],
                   "ProvisionedThroughput": {
                       "ReadCapacityUnits": 5,
                       "WriteCapacityUnits": 1
                   }
               }
           }
       }
   }
   ```

1. Apri la CloudFormation console per eseguire un aggiornamento dello stack per applicare la politica di eliminazione.

   1. Nella pagina **Stack** con lo stack selezionato, scegliere **Aggiorna**.

   1. In **Prepara modello**, scegliere **Sostituisci modello corrente**.

   1. In **Specifica modello**, fornire il modello di origine aggiornato con l’attributo `DeletionPolicy` su `GamesTable`, quindi scegliere **Successivo**.
      + Scegliere **URL Amazon S3**, quindi specificare l’URL per il modello di origine aggiornato nella casella di testo.
      + Scegliere **Carica un file modello**, quindi cercare il file modello di origine aggiornato.

   1. Nella pagina **Specifica dettagli stack**, non sono necessarie modifiche. Scegli **Successivo**.

   1. Nella pagina **Configura opzioni stack** non sono necessarie modifiche. Scegli **Next (Successivo)**.

   1. Nella *SourceStackName* pagina **Revisione**, rivedi le modifiche. Se il modello contiene risorse IAM, selezionare**Acconsento che questo modello possa creare risorse IAM** per specificare che si desidera utilizzare risorse IAM nel modello. Per ulteriori informazioni sull’utilizzo delle risorse IAM nei modelli, consulta [Controlla CloudFormation l'accesso con AWS Identity and Access Management](control-access-with-iam.md). Quindi, aggiornare lo stack di origine creando un set di modifiche o aggiornare direttamente lo stack di origine.

1. Rimuovi la risorsa , i parametri correlati e gli output dal modello di origine, quindi aggiungili al modello di destinazione.

   Il modello di origine ora è simile al seguente.  
**Example JSON**  

   ```
   {
       "AWSTemplateFormatVersion": "2010-09-09",
       "Description": "Import test",
       "Resources": {
           "ServiceTable":{
              "Type":"AWS::DynamoDB::Table",
              "Properties":{
                 "TableName":"Service",
                 "AttributeDefinitions":[
                    {
                       "AttributeName":"key",
                       "AttributeType":"S"
                    }
                 ],
                 "KeySchema":[
                    {
                       "AttributeName":"key",
                       "KeyType":"HASH"
                    }
                 ],
                 "ProvisionedThroughput":{
                    "ReadCapacityUnits":5,
                    "WriteCapacityUnits":1
                 }
              }
           }
       }
   }
   ```

   Il seguente modello di destinazione di esempio ha attualmente la risorsa `PlayersTable` e ora contiene anche `GamesTable`.  
**Example JSON**  

   ```
   {
       "AWSTemplateFormatVersion": "2010-09-09",
       "Description": "Import test",
       "Resources": {
           "PlayersTable": {
               "Type": "AWS::DynamoDB::Table",
               "Properties": {
                   "TableName": "Players",
                   "AttributeDefinitions": [
                       {
                           "AttributeName": "key",
                           "AttributeType": "S"
                       }
                   ],
                   "KeySchema": [
                       {
                           "AttributeName": "key",
                           "KeyType": "HASH"
                       }
                   ],
                   "ProvisionedThroughput": {
                       "ReadCapacityUnits": 5,
                       "WriteCapacityUnits": 1
                   }
               }
           },
           "GamesTable": {
               "Type": "AWS::DynamoDB::Table",
               "DeletionPolicy": "Retain",
               "Properties": {
                   "TableName": "Games",
                   "AttributeDefinitions": [
                       {
                           "AttributeName": "key",
                           "AttributeType": "S"
                       }
                   ],
                   "KeySchema": [
                       {
                           "AttributeName": "key",
                           "KeyType": "HASH"
                       }
                   ],
                   "ProvisionedThroughput": {
                       "ReadCapacityUnits": 5,
                       "WriteCapacityUnits": 1
                   }
               }
           }
       }
   }
   ```

1. Ripeti i passaggi 2-3 per aggiornare nuovamente lo stack di origine, questa volta per eliminare la risorsa di destinazione dallo stack.

1. Eseguire un’operazione di importazione per aggiungere `GamesTable` allo stack di destinazione.

   1. Nella pagina **Stack** con lo stack padre selezionato, scegliere **Operazioni stack**, quindi scegliere **Importa risorse nello stack**.  
![\[L’opzione Importa risorse nello stack nella console.\]](http://docs.aws.amazon.com/it_it/AWSCloudFormation/latest/UserGuide/images/stack-actions-import.png)

   1. Leggere la pagina **Panoramica importazione** per un elenco di elementi da fornire durante questa operazione. Quindi, seleziona **Next**.

   1. Nella pagina **Specify template** completa una delle seguenti operazioni, quindi scegli **Next**.
      + Scegliere **URL Amazon S3**, quindi specificare un URL nella casella di testo.
      + Scegliere **Carica un file modello**, quindi cercare un file da caricare.

   1. Nella pagina **Identifica risorse**, identificare la risorsa che si sta spostando (in questo esempio `GamesTable`). Per ulteriori informazioni, consulta [Identificatori di risorse](import-resources-manually.md#resource-import-identifiers-unique-ids).

      1. In **Proprietà identificatore**, scegliere il tipo di identificatore di risorsa. Ad esempio, una risorsa `AWS::DynamoDB::Table` può essere identificata utilizzando la proprietà `TableName`.

      1. In **Valore identificatore**, digitare il valore effettivo della proprietà. Ad esempio, `GamesTables`. 

      1. Scegli **Next (Successivo)**.

   1. Nella pagina **Specifica dettagli stack**, modifica i parametri, quindi scegli **Successivo**. Questo crea automaticamente un set di modifiche.
**Importante**  
L’operazione di importazione ha esito negativo se si modificano i parametri esistenti che iniziano un’operazione di creazione, aggiornamento o eliminazione.

   1. Nella *TargetStackName* pagina **Revisione**, conferma che sia stata importata la risorsa corretta, quindi scegli **Importa risorse**. In questo modo il set di modifiche creato nell’ultima fase viene avviato automaticamente. Tutti i [tag a livello di stack](cfn-console-create-stack.md#configure-stack-options) vengono applicati alle risorse importate in questo momento.

   1. Per lo stack padre viene visualizzato il riquadro **Eventi** della pagina **Dettagli stack**.  
![\[La scheda Eventi nella console.\]](http://docs.aws.amazon.com/it_it/AWSCloudFormation/latest/UserGuide/images/import-events.png)
**Nota**  
Non è necessario eseguire il rilevamento della deviazione nello stack padre dopo questa operazione di importazione perché la risorsa `AWS::CloudFormation::Stack` è già gestita da CloudFormation.

## Effettua il refactoring di uno stack utilizzando il AWS CLI
<a name="refactor-stacks-cli"></a>

1. Nel modello di origine, specificate a `Retain` [DeletionPolicy](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-attribute-deletionpolicy.html)per la risorsa che desiderate spostare.

   Nel seguente modello di origine di esempio, `GamesTable` è la destinazione di questo refactoring.  
**Example JSON**  

   ```
   {
       "AWSTemplateFormatVersion": "2010-09-09",
       "Description": "Import test",
       "Resources": {
           "ServiceTable":{
              "Type":"AWS::DynamoDB::Table",
              "Properties":{
                 "TableName":"Service",
                 "AttributeDefinitions":[
                    {
                       "AttributeName":"key",
                       "AttributeType":"S"
                    }
                 ],
                 "KeySchema":[
                    {
                       "AttributeName":"key",
                       "KeyType":"HASH"
                    }
                 ],
                 "ProvisionedThroughput":{
                    "ReadCapacityUnits":5,
                    "WriteCapacityUnits":1
                 }
              }
           },
           "GamesTable": {
               "Type": "AWS::DynamoDB::Table",
               "DeletionPolicy": "Retain",
               "Properties": {
                   "TableName": "Games",
                   "AttributeDefinitions": [
                       {
                           "AttributeName": "key",
                           "AttributeType": "S"
                       }
                   ],
                   "KeySchema": [
                       {
                           "AttributeName": "key",
                           "KeyType": "HASH"
                       }
                   ],
                   "ProvisionedThroughput": {
                       "ReadCapacityUnits": 5,
                       "WriteCapacityUnits": 1
                   }
               }
           }
       }
   }
   ```

1. Aggiornare lo stack di origine per applicare la policy di eliminazione alla risorsa.

   ```
   aws cloudformation update-stack --stack-name SourceStackName
   ```

1. Rimuovi la risorsa, i parametri correlati e gli output dal modello di origine, quindi aggiungili al modello di destinazione.

   Il modello di origine ora è simile al seguente.  
**Example JSON**  

   ```
   {
       "AWSTemplateFormatVersion": "2010-09-09",
       "Description": "Import test",
       "Resources": {
           "ServiceTable":{
              "Type":"AWS::DynamoDB::Table",
              "Properties":{
                 "TableName":"Service",
                 "AttributeDefinitions":[
                    {
                       "AttributeName":"key",
                       "AttributeType":"S"
                    }
                 ],
                 "KeySchema":[
                    {
                       "AttributeName":"key",
                       "KeyType":"HASH"
                    }
                 ],
                 "ProvisionedThroughput":{
                    "ReadCapacityUnits":5,
                    "WriteCapacityUnits":1
                 }
              }
           }
       }
   }
   ```

   Il seguente modello di destinazione di esempio ha attualmente la risorsa `PlayersTable` e ora contiene anche `GamesTable`.  
**Example JSON**  

   ```
   {
       "AWSTemplateFormatVersion": "2010-09-09",
       "Description": "Import test",
       "Resources": {
           "PlayersTable": {
               "Type": "AWS::DynamoDB::Table",
               "Properties": {
                   "TableName": "Players",
                   "AttributeDefinitions": [
                       {
                           "AttributeName": "key",
                           "AttributeType": "S"
                       }
                   ],
                   "KeySchema": [
                       {
                           "AttributeName": "key",
                           "KeyType": "HASH"
                       }
                   ],
                   "ProvisionedThroughput": {
                       "ReadCapacityUnits": 5,
                       "WriteCapacityUnits": 1
                   }
               }
           },
           "GamesTable": {
               "Type": "AWS::DynamoDB::Table",
               "DeletionPolicy": "Retain",
               "Properties": {
                   "TableName": "Games",
                   "AttributeDefinitions": [
                       {
                           "AttributeName": "key",
                           "AttributeType": "S"
                       }
                   ],
                   "KeySchema": [
                       {
                           "AttributeName": "key",
                           "KeyType": "HASH"
                       }
                   ],
                   "ProvisionedThroughput": {
                       "ReadCapacityUnits": 5,
                       "WriteCapacityUnits": 1
                   }
               }
           }
       }
   }
   ```

1. Aggiornare lo stack di origine per eliminare la risorsa `GamesTable` e i relativi parametri e output dallo stack.

   ```
   aws cloudformation update-stack --stack-name SourceStackName
   ```

1. Componi un elenco di risorse attuali da importare e di relativi identificatori univoci nel seguente formato della stringa JSON. Per ulteriori informazioni, consulta [Identificatori di risorse](import-resources-manually.md#resource-import-identifiers-unique-ids).

   ```
   [{"ResourceType":"AWS::DynamoDB::Table","LogicalResourceId":"GamesTable","ResourceIdentifier":{"TableName":"Games"}}]
   ```

   In alternativa, puoi specificare i parametri formattati JSON in un file di configurazione. 

   Ad esempio, per importare`GamesTable`, potreste creare un *ResourcesToImport.txt* file che contenga la seguente configurazione.

   ```
   [
     {
         "ResourceType":"AWS::DynamoDB::Table",
         "LogicalResourceId":"GamesTable",
         "ResourceIdentifier": {
           "TableName":"Games"
         }
     }
   ]
   ```

1. Per creare un set di modifiche, utilizza il seguente comando **create-change-set** e sostituisci il testo segnaposto. Per l’opzione `--change-set-type`, specifica il valore di **IMPORT**. Per l’opzione `--resources-to-import`, sostituisci la stringa JSON di esempio con la stringa JSON effettiva che hai appena creato.

   ```
   aws cloudformation create-change-set \
       --stack-name TargetStackName --change-set-name ImportChangeSet \
       --change-set-type IMPORT \
       --template-body file://TemplateToImport.json \
       --resources-to-import "'[{"ResourceType":"AWS::DynamoDB::Table","LogicalResourceId":"GamesTable","ResourceIdentifier":{"TableName":"Games"}}]'"
   ```
**Nota**  
`--resources-to-import` non supporta YAML in linea. I requisiti per l’escape delle virgolette nella stringa JSON variano in base al terminale. Per ulteriori informazioni, consulta [Utilizzo di virgolette all’interno di stringhe](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-parameters-quoting-strings.html#cli-usage-parameters-quoting-strings-containing) nella *Guida per l’utente di AWS Command Line Interface *.

   In alternativa, è possibile anche utilizzare l’URL del file come input per l’opzione `--resources-to-import`, come mostrato nell’esempio seguente.

   ```
   --resources-to-import file://ResourcesToImport.txt
   ```

1. Esaminare il set di modifiche per assicurarsi che la risorsa corretta venga importata nello stack di destinazione.

   ```
   aws cloudformation describe-change-set \
       --change-set-name ImportChangeSet
   ```

1. Per creare un set di modifiche, utilizza il seguente comando **execute-change-set** e sostituisci il testo segnaposto. Tutti i tag a livello di stack vengono applicati alle risorse importate in questo momento. Al completamento dell’operazione `(IMPORT_COMPLETE)`, la risorsa viene importata correttamente.

   ```
   aws cloudformation execute-change-set \
       --change-set-name ImportChangeSet --stack-name TargetStackName
   ```
**Nota**  
Non è necessario eseguire il rilevamento della deviazione nello stack di destinazione dopo questa operazione di importazione perché la risorsa è già gestita da CloudFormation.

# Nidificazione di uno stack esistente
<a name="resource-import-nested-stacks"></a>

Utilizzare la funzionalità `resource import` per nidificare uno stack esistente all’interno di un altro stack esistente. Gli stack nidificati sono componenti comuni che l’utente dichiara e vi fa riferimento all’interno di altri modelli. In questo modo, è possibile evitare di copiare e incollare le stesse configurazioni nei modelli e semplificare gli aggiornamenti dello stack. Se si dispone di un modello per un componente comune, è possibile utilizzare la risorsa `AWS::CloudFormation::Stack` per fare riferimento a questo modello da un altro modello. Per ulteriori informazioni sugli stack nidificati, consulta [Dividi un modello in pezzi riutilizzabili usando stack nidificati](using-cfn-nested-stacks.md).

CloudFormation supporta solo un livello di nidificazione. `resource import` Ciò significa che non è possibile importare uno stack in uno stack figlio o importare uno stack con figli.

Se non hai mai effettuato l’importazione, ti consigliamo di esaminare prima le informazioni introduttive nella sezione [Importazione AWS manuale delle risorse in uno CloudFormation stack](import-resources-manually.md).

## Convalida dell’importazione dello stack nidificato
<a name="resource-import-nested-stacks-validation"></a>

Durante un'operazione di importazione di stack annidati, CloudFormation esegue le seguenti convalide.
+ La definizione `AWS::CloudFormation::Stack` nidificata nel modello di stack padre corrisponde al modello dello stack nidificato effettivo.
+ I tag per la definizione `AWS::CloudFormation::Stack` nidificata nel modello di stack padre corrispondono ai tag per la risorsa stack nidificata effettiva.

## Annidate uno stack esistente utilizzando il Console di gestione AWS
<a name="resource-import-nested-stacks-console"></a>

1. Aggiungi la `AWS::CloudFormation::Stack` risorsa al modello dello stack principale con un. `Retain` [DeletionPolicy](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-attribute-deletionpolicy.html) Nel seguente modello di stack padre di esempio, `MyNestedStack` è la destinazione dell’importazione.

   **JSON**

   ```
   {
     "AWSTemplateFormatVersion" : "2010-09-09",
     "Resources" : {
       "ServiceTable":{
              "Type":"AWS::DynamoDB::Table",
              "Properties":{
                 "TableName":"Service",
                 "AttributeDefinitions":[
                    {
                       "AttributeName":"key",
                       "AttributeType":"S"
                    }
                 ],
                 "KeySchema":[
                    {
                       "AttributeName":"key",
                       "KeyType":"HASH"
                    }
                 ],
                 "ProvisionedThroughput":{
                    "ReadCapacityUnits":5,
                    "WriteCapacityUnits":1
                 }
              }
           },
       "MyNestedStack" : {
         "Type" : "AWS::CloudFormation::Stack",
         "DeletionPolicy": "Retain",
         "Properties" : {
         "TemplateURL" : "https://s3.amazonaws.com/cloudformation-templates-us-east-2/EC2ChooseAMI.template",
           "Parameters" : {
             "InstanceType" : "t1.micro",
             "KeyName" : "mykey"
           }
         }
       }
     }
   }
   ```

   **YAML**

   ```
   AWSTemplateFormatVersion: 2010-09-09
   Resources:
     ServiceTable:
       Type: AWS::DynamoDB::Table
       Properties:
         TableName: Service
         AttributeDefinitions:
           - AttributeName: key
             AttributeType: S
         KeySchema:
           - AttributeName: key
             KeyType: HASH
         ProvisionedThroughput:
           ReadCapacityUnits: 5
           WriteCapacityUnits: 1
     MyNestedStack:
       Type: AWS::CloudFormation::Stack
       DeletionPolicy: Retain
       Properties:
         TemplateURL: >-
           https://s3.amazonaws.com/cloudformation-templates-us-east-2/EC2ChooseAMI.template
         Parameters:
           InstanceType: t1.micro
           KeyName: mykey
   ```

1. Apri la CloudFormation console.

1. Nella pagina **Stack** con lo stack padre selezionato, scegliere **Operazioni stack**, quindi scegliere **Importa risorse nello stack**.  
![\[L’opzione Importa risorse nello stack nella console.\]](http://docs.aws.amazon.com/it_it/AWSCloudFormation/latest/UserGuide/images/stack-actions-import.png)

1. Leggere la pagina **Panoramica importazione** per un elenco di elementi da fornire durante questa operazione. Quindi, seleziona **Successivo**.

1. Nella pagina **Specifica modello**, fornire il modello padre aggiornato utilizzando uno dei metodi descritti di seguito, quindi scegliere **Successivo**.
   + Scegliere **URL Amazon S3**, quindi specificare l’URL per il tuo modello nella casella di testo.
   + Scegliere **Carica un file modello**, quindi cercare il modello.

1. Nella pagina **Identifica risorse**, identifica la risorsa `AWS::CloudFormation::Stack`.

   1. In **Proprietà identificatore**, scegliere il tipo di identificatore di risorsa. Ad esempio, una risorsa `AWS::CloudFormation::Stack` può essere identificata utilizzando la proprietà `StackId`.

   1. In **Valore identificatore**, digita l’ARN dello stack che stai importando. Ad esempio, `arn:aws:cloudformation:us-west-2:12345678910:stack/mystack/5b918d10-cd98-11ea-90d5-0a9cd3354c10`.  
![\[La pagina relativa all’identificazione delle risorse nella console.\]](http://docs.aws.amazon.com/it_it/AWSCloudFormation/latest/UserGuide/images/resource-import-stackid.png)

   1. Scegli **Successivo**.

1. Nella pagina **Specifica dettagli stack**, modifica i parametri, quindi scegli **Successivo**. Questo crea automaticamente un set di modifiche.
**Importante**  
L’operazione di importazione ha esito negativo se si modificano i parametri esistenti che iniziano un’operazione di creazione, aggiornamento o eliminazione.

1. Nella *MyParentStack* pagina **Revisione**, conferma che sia stata importata la risorsa corretta, quindi scegli **Importa risorse**. In questo modo si esegue automaticamente il set di modifiche creato nell’ultimo passaggio. Tutti i tag a livello di stack vengono applicati alle risorse importate in questo momento.

1. Per lo stack padre viene visualizzato il riquadro **Eventi** della pagina **Dettagli stack**.  
![\[La scheda Eventi nella console.\]](http://docs.aws.amazon.com/it_it/AWSCloudFormation/latest/UserGuide/images/import-events.png)
**Nota**  
Non è necessario eseguire il rilevamento della deviazione nello stack padre dopo questa operazione di importazione perché la risorsa `AWS::CloudFormation::Stack` era già gestita da CloudFormation.

## Annidate uno stack esistente utilizzando il AWS CLI
<a name="resource-import-nested-stacks-cli"></a>

1. Aggiungi la `AWS::CloudFormation::Stack` risorsa al modello dello stack principale con un. `Retain` [DeletionPolicy](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-attribute-deletionpolicy.html) Nel seguente modello padre di esempio, `MyNestedStack` è la destinazione dell’importazione.

   **JSON**

   ```
   {
     "AWSTemplateFormatVersion" : "2010-09-09",
     "Resources" : {
       "ServiceTable":{
              "Type":"AWS::DynamoDB::Table",
              "Properties":{
                 "TableName":"Service",
                 "AttributeDefinitions":[
                    {
                       "AttributeName":"key",
                       "AttributeType":"S"
                    }
                 ],
                 "KeySchema":[
                    {
                       "AttributeName":"key",
                       "KeyType":"HASH"
                    }
                 ],
                 "ProvisionedThroughput":{
                    "ReadCapacityUnits":5,
                    "WriteCapacityUnits":1
                 }
              }
           },
       "MyNestedStack" : {
         "Type" : "AWS::CloudFormation::Stack",
         "DeletionPolicy": "Retain",
         "Properties" : {
         "TemplateURL" : "https://s3.amazonaws.com/cloudformation-templates-us-east-2/EC2ChooseAMI.template",
           "Parameters" : {
             "InstanceType" : "t1.micro",
             "KeyName" : "mykey"
           }
         }
       }
     }
   }
   ```

   **YAML**

   ```
   AWSTemplateFormatVersion: 2010-09-09
   Resources:
     ServiceTable:
       Type: AWS::DynamoDB::Table
       Properties:
         TableName: Service
         AttributeDefinitions:
           - AttributeName: key
             AttributeType: S
         KeySchema:
           - AttributeName: key
             KeyType: HASH
         ProvisionedThroughput:
           ReadCapacityUnits: 5
           WriteCapacityUnits: 1
     MyNestedStack:
       Type: AWS::CloudFormation::Stack
       DeletionPolicy: Retain
       Properties:
         TemplateURL: >-
           https://s3.amazonaws.com/cloudformation-templates-us-east-2/EC2ChooseAMI.template
         Parameters:
           InstanceType: t1.micro
           KeyName: mykey
   ```

1. Componi una stringa JSON come mostrato nell’esempio seguente, con queste modifiche: 
   + Sostituisci *MyNestedStack* con l'ID logico della risorsa di destinazione come specificato nel modello.
   + Sostituisci *arn:aws:cloudformation:us-west-2:12345678910:stack/mystack/5b918d10-cd98-11ea-90d5-0a9cd3354c10* con l'ARN dello stack che desideri importare.

   ```
   [{"ResourceType":"AWS::CloudFormation::Stack","LogicalResourceId":"MyNestedStack","ResourceIdentifier":{"StackId":"arn:aws:cloudformation:us-east-2:123456789012:stack/mystack/5b918d10-cd98-11ea-90d5-0a9cd3354c10"}}]
   ```

   In alternativa, puoi specificare i parametri in un file di configurazione. 

   Ad esempio, per importare`MyNestedStack`, potreste creare un *ResourcesToImport.txt* file che contenga la seguente configurazione.

   **JSON**

   ```
   [
     {
         "ResourceType":"AWS::CloudFormation::Stack",
         "LogicalResourceId":"MyNestedStack",
         "ResourceIdentifier": {
           "StackId":"arn:aws:cloudformation:us-west-2:12345678910:stack/mystack/5b918d10-cd98-11ea-90d5-0a9cd3354c10"
         }
     }
   ]
   ```

   **YAML**

   ```
   ResourceType: AWS::CloudFormation::Stack
     LogicalResourceId: MyNestedStack
     ResourceIdentifier:
       StackId: >-
         arn:aws:cloudformation:us-west-2:12345678910:stack/mystack/5b918d10-cd98-11ea-90d5-0a9cd3354c10
   ```

1. Per creare un set di modifiche, utilizza il seguente comando **create-change-set** e sostituisci il testo segnaposto. Per l’opzione `--change-set-type`, specifica il valore di **IMPORT**. Per l’opzione `--resources-to-import`, sostituisci la stringa JSON di esempio con la stringa JSON effettiva che hai appena creato.

   ```
   aws cloudformation create-change-set \
       --stack-name MyParentStack --change-set-name ImportChangeSet \
       --change-set-type IMPORT \
       --template-body file://TemplateToImport.json \
       --resources-to-import '[{"ResourceType":"AWS::CloudFormation::Stack","LogicalResourceId":"MyNestedStack","ResourceIdentifier":{"StackId":"arn:aws:cloudformation:us-west-2:12345678910:stack/mystack/5b918d10-cd98-11ea-90d5-0a9cd3354c10"}}]'
   ```
**Nota**  
`--resources-to-import` non supporta YAML in linea. I requisiti per l’escape delle virgolette nella stringa JSON variano in base al terminale. Per ulteriori informazioni, consulta [Utilizzo di virgolette all’interno di stringhe](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-parameters-quoting-strings.html#cli-usage-parameters-quoting-strings-containing) nella *Guida per l’utente di AWS Command Line Interface *.

   In alternativa, puoi anche utilizzare l’URL del file come input per l’opzione `--resources-to-import`, come mostrato nell’esempio seguente.

   ```
   --resources-to-import file://ResourcesToImport.txt
   ```

   Se eseguito correttamente, il comando restituirà il seguente output di esempio.

   ```
   {
       "Id": "arn:aws:cloudformation:us-west-2:12345678910:changeSet/ImportChangeSet/8ad75b3f-665f-46f6-a200-0b4727a9442e",
       "StackId": "arn:aws:cloudformation:us-west-2:12345678910:stack/MyParentStack/4e345b70-1281-11ef-b027-027366d8e82b"
   }
   ```

1. Esaminare il set di modifiche per assicurarsi che venga importato lo stack corretto.

   ```
   aws cloudformation describe-change-set --change-set-name ImportChangeSet
   ```

1. Per avviare il set di modifiche e importare lo stack nello stack padre di origine, utilizza il seguente comando **execute-change-set** e sostituisci il testo segnaposto. Tutti i [tag a livello di stack](cfn-console-create-stack.md#configure-stack-options) vengono applicati alle risorse importate in questo momento. Al completamento dell’operazione di importazione `(IMPORT_COMPLETE)`, lo stack viene nidificato correttamente.

   ```
   aws cloudformation execute-change-set --change-set-name ImportChangeSet
   ```
**Nota**  
Non è necessario eseguire il rilevamento della deviazione nello stack padre dopo questa operazione di importazione perché la risorsa `AWS::CloudFormation::Stack` è già gestita da CloudFormation.