

# Mover recursos entre pilhas
<a name="refactor-stacks"></a>

Com o recurso `resource import`, é possível mover recursos entre pilhas ou *refatorar* pilhas. Primeiro, você precisa adicionar uma política de exclusão `Retain` ao recurso que você deseja mover para garantir que o recurso seja preservado ao removê-lo da pilha de origem e importá-lo na pilha de destino.

Se você não tiver familiaridade com a importação, recomendamos que primeiro revise as informações introdutórias no tópico [Importar recursos da AWS para uma pilha do CloudFormation](import-resources.md).

**Importante**  
Nem todos os recursos são compatíveis com as operações de importação. Consulte [Recursos compatíveis com as operações de importação](resource-import-supported-resources.md) antes de remover um recurso da pilha. Se você remover um recurso que não é compatível com operações de importação da pilha, não será possível importar o recurso para outra pilha ou trazê-lo de volta para a pilha de origem.

## Refatorar uma pilha usando o Console de gerenciamento da AWS
<a name="refactor-stacks-console"></a>

1. No modelo de origem, especifique uma [DeletionPolicy](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-attribute-deletionpolicy.html) `Retain` para o recurso que deseja mover.

   No modelo de origem de exemplo a seguir, `Games` é o destino desta refatoração.  
**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. Abra o console do CloudFormation para executar uma atualização de pilha para aplicar a política de exclusão.

   1. Na página **Stacks (Pilhas)** com a pilha selecionada, escolha **Update (Atualizar)**.

   1. Em **Preparar modelo**, escolha **Substituir modelo atual**.

   1. Em **Specify template (Especificar modelo)**, forneça o modelo de origem atualizado com o atributo `DeletionPolicy` na `GamesTable` e escolha **Next (Próximo)**.
      + Escolha **Amazon S3 URL (URL do Amazon S3)** e especifique o URL para o modelo de origem atualizado na caixa de texto.
      + Escolha **Upload a template file (Fazer upload de um arquivo de modelo)** e procure o arquivo de modelo de origem atualizado.

   1. Na página **Specify stack details (Especificar detalhes da pilha)** nenhuma alteração é necessária. Escolha **Próximo**.

   1. Na página **Configure stack options (Configurar opções de pilha)** nenhuma alteração é necessária. Escolha **Próximo**.

   1. Na página **Analisar *SourceStackName***, analise as alterações. Se o seu modelo contém recursos do IAM, selecione **I acknowledge that this template may create IAM resources (Eu reconheço que este modelo pode criar recursos do IAM)** para especificar que você deseja usar recursos do IAM no modelo. Para obter mais informações sobre o uso de recursos do IAM em modelos, consulte [Controle o acesso ao CloudFormation com o AWS Identity and Access Management](control-access-with-iam.md). Depois, atualize sua pilha de origem criando um conjunto de alterações ou atualize sua pilha de origem diretamente.

1. Remova o recurso, os parâmetros relacionados e as saídas do modelo de origem e adicione-os ao modelo de destino.

   O modelo de origem agora se parece com o seguinte.  
**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
                 }
              }
           }
       }
   }
   ```

   O modelo de destino de exemplo a seguir tem atualmente o recurso `PlayersTable` e agora também contém `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. Repita as etapas 2 e 3 para atualizar a pilha de origem novamente, desta vez para excluir o recurso de destino da pilha.

1. Execute uma operação de importação para adicionar `GamesTable` à pilha de destino.

   1. Na página **Stacks (Pilhas)**, com a pilha pai selecionada, escolha **Stack actions (Ações da pilha)** e **Import resources into stack (Importar recursos para a pilha)**.  
![\[A opção Importar recursos para a pilha no console.\]](http://docs.aws.amazon.com/pt_br/AWSCloudFormation/latest/UserGuide/images/stack-actions-import.png)

   1. Leia a página **Import overview (Visão geral da importação)** para obter uma lista de itens que você deve fornecer durante esta operação. Em seguida, escolha **Próximo**.

   1. Na página **Specify template** (Especificar modelo), siga um destes procedimentos e escolha **Next** (Próximo).
      + Escolha **Amazon S3 URL (URL do Amazon S3)** e especifique um URL na caixa de texto.
      + Escolha **Upload a template file (Fazer upload de um arquivo de modelo)** e procure um arquivo a ser carregado.

   1. Na página **Identify resources (Identificar recursos)** identifique o recurso que você está movendo (neste exemplo, `GamesTable`). Para obter mais informações, consulte [Identificadores de recursos](import-resources-manually.md#resource-import-identifiers-unique-ids).

      1. Em **Identifier property (Propriedade do identificador)**, escolha o tipo de identificador do recurso. Por exemplo, um recurso `AWS::DynamoDB::Table` pode ser identificado usando a propriedade `TableName`.

      1. Em **Identifier value (Valor do identificador)**, digite o valor real da propriedade. Por exemplo, .`GamesTables` 

      1. Escolha **Próximo**.

   1. Na página **Specify stack details (Especificar detalhes da pilha)**, modifique os parâmetros e escolha **Next (Próximo)**. Isso cria automaticamente um conjunto de alterações.
**Importante**  
A operação de importação falhará se você modificar os parâmetros existentes que iniciam uma operação de criação, atualização ou exclusão.

   1. Na página **Analisar *TargetStackName***, confirme se o recurso correto está sendo importado e, em seguida, escolha **Importar recursos**. Isso inicia automaticamente o conjunto de alterações criadas na última etapa. As [tags no nível da pilha](cfn-console-create-stack.md#configure-stack-options) são aplicadas aos recursos importados no momento.

   1. O painel **Events (Eventos)** da página **Stack details (Detalhes da pilha)** de sua pilha pai será exibido.  
![\[A guia Eventos no console.\]](http://docs.aws.amazon.com/pt_br/AWSCloudFormation/latest/UserGuide/images/import-events.png)
**nota**  
Não é necessário executar a detecção de desvio na pilha pai após essa operação de importação, pois o recurso `AWS::CloudFormation::Stack` já é gerenciado pelo CloudFormation.

## Refatorar uma pilha usando o AWS CLI
<a name="refactor-stacks-cli"></a>

1. No modelo de origem, especifique uma [DeletionPolicy](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-attribute-deletionpolicy.html) `Retain` para o recurso que deseja mover.

   No modelo de origem de exemplo a seguir, `GamesTable` é o destino desta refatoração.  
**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. Atualize a pilha de origem para aplicar a política de exclusão ao recurso.

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

1. Remova o recurso, os parâmetros relacionados e as saídas do modelo de origem e adicione-os ao modelo de destino.

   O modelo de origem agora se parece com o seguinte.  
**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
                 }
              }
           }
       }
   }
   ```

   O modelo de destino de exemplo a seguir tem atualmente o recurso `PlayersTable` e agora também contém `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. Atualize a pilha de origem para excluir o recurso `GamesTable` e os parâmetros relacionados, além das saídas da pilha.

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

1. Componha uma lista com os recursos reais a serem importados e os identificadores exclusivos no formato de string JSON apresentado a seguir. Para obter mais informações, consulte [Identificadores de recursos](import-resources-manually.md#resource-import-identifiers-unique-ids).

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

   Como alternativa, é possível especificar os parâmetros formatados em JSON em um arquivo de configuração. 

   Por exemplo, para importar `GamesTable`, é possível criar um arquivo *ResourcesToImport.txt* que contém a configuração apresentada a seguir.

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

1. Para criar um conjunto de alterações, use o comando **create-change-set**, apresentado a seguir, e substitua o texto do espaço reservado. Para a opção,`--change-set-type` especifique um valor de **IMPORT**. Para a opção `--resources-to-import`, substitua a string JSON de exemplo pela string JSON real que você acabou de criar.

   ```
   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**  
A opção `--resources-to-import` não oferece suporte para a linguagem YAML incorporada. Os requisitos para usar sequências de escape de aspas em uma string JSON variam de acordo com o terminal utilizado. Para obter mais informações, consulte [Using quotation marks inside strings](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-parameters-quoting-strings.html#cli-usage-parameters-quoting-strings-containing) no *Guia do usuário da AWS Command Line Interface*.

   Como alternativa, é possível usar um URL de arquivo como entrada para a opção `--resources-to-import`, conforme mostrado no exemplo a seguir.

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

1. Revise o conjunto de alterações para certificar-se de que o recurso correto está sendo importado para a pilha de destino.

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

1. Para iniciar o conjunto de alterações e importar o recurso, use o comando **execute-change-set**, apresentado a seguir, e substitua o texto do espaço reservado. As tags no nível da pilha são aplicadas aos recursos importados no momento. Após a conclusão com êxito da operação `(IMPORT_COMPLETE)`, o recurso será importado com êxito.

   ```
   aws cloudformation execute-change-set \
       --change-set-name ImportChangeSet --stack-name TargetStackName
   ```
**nota**  
Não é necessário executar a detecção de desvio na pilha de destino após a operação de importação porque o recurso já é gerenciado pelo CloudFormation.