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

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