

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Verschieben von Ressourcen zwischen Stacks
<a name="refactor-stacks"></a>

Mithilfe des `resource import`-Features können Sie Ressourcen zwischen Stacks verschieben oder Stacks *umgestalten*. Sie müssen zuerst eine `Retain`-Löschrichtlinie zu der Ressource hinzufügen, die Sie verschieben möchten, um sicherzustellen, dass die Ressource erhalten bleibt, wenn Sie sie aus dem Quell-Stack entfernen und in den Ziel-Stack importieren.

Wenn Sie mit dem Importieren noch nicht vertraut sind, empfehlen wir Ihnen, zunächst die einführenden Informationen im Thema [AWS Ressourcen in einen CloudFormation Stack importieren](import-resources.md) durchzulesen.

**Wichtig**  
Nicht alle Ressourcen unterstützen Importvorgänge. Weitere Informationen finden Sie unter [Ressourcen, die Importvorgänge unterstützen](resource-import-supported-resources.md) bevor Sie eine Ressource aus dem Stack entfernen. Wenn Sie eine Ressource entfernen, die keine Importvorgänge aus dem Stack unterstützt, können Sie die Ressource nicht in einen anderen Stack importieren oder sie wieder in den Quell-Stack bringen.

## Refaktorieren Sie einen Stack mit dem AWS-Managementkonsole
<a name="refactor-stacks-console"></a>

1. Geben Sie in der Quellvorlage a `Retain` [DeletionPolicy](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-attribute-deletionpolicy.html)für die Ressource an, die Sie verschieben möchten.

   In der folgenden Beispiel-Quellvorlage ist `Games` das Ziel dieser Umgestaltung.  
**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. Öffnen Sie die CloudFormation Konsole, um ein Stack-Update durchzuführen und die Löschrichtlinie anzuwenden.

   1. Wählen Sie auf der Seite **Stacks (Stapel)** bei ausgewähltem Stack **Update (Aktualisieren)** aus.

   1. Wählen Sie unter **Vorlage vorbereiten** die Option **Aktuelle Vorlage ersetzen** aus.

   1. Geben Sie unter **Vorlage angeben** die aktualisierte Quellvorlage mit dem `DeletionPolicy`-Attribut für `GamesTable` ein und wählen Sie dann **Weiter** aus.
      + Wählen Sie **Amazon S3-URL** aus und geben Sie dann im Textfeld die URL zur aktualisierten Quellvorlage an.
      + Wählen Sie **Vorlagendatei hochladen** aus und suchen Sie dann nach der aktualisierten Quellvorlagendatei.

   1. Auf der Seite **Stack-Details angeben** sind keine Änderungen erforderlich. Wählen Sie **Weiter** aus.

   1. Auf der Seite **Stack-Optionen konfigurieren** sind keine Änderungen erforderlich. Wählen Sie **Weiter** aus.

   1. **Überprüfen Sie** auf der *SourceStackName* Seite „Überprüfen“ Ihre Änderungen. Wenn Ihre Vorlage IAM-Ressourcen enthält, wählen Sie **I acknowledge that this template may create IAM resources**, um anzugeben, dass Sie IAM-Ressourcen in der Vorlage verwenden möchten. Weitere Informationen zum Verwenden von IAM-Ressourcen in Vorlagen finden Sie unter [Steuern CloudFormation Sie den Zugriff mit AWS Identity and Access Management](control-access-with-iam.md). Aktualisieren Sie dann entweder Ihren Quell-Stack, indem Sie einen Änderungssatz erstellen, oder aktualisieren Sie Ihren Quell-Stack direkt.

1. Entfernen Sie die Ressource, die zugehörigen Parameter und Ausgaben aus der Quellvorlage und fügen Sie sie dann der Zielvorlage hinzu.

   Die Quellvorlage sieht nun wie folgt aus.  
**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
                 }
              }
           }
       }
   }
   ```

   Die folgende Beispiel-Zielvorlage enthält derzeit die `PlayersTable`-Ressource und enthält nun auch `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. Wiederholen Sie die Schritte 2–3, um den Quell-Stack erneut zu aktualisieren, um dieses Mal die Zielressource aus dem Stack zu löschen.

1. Führen Sie einen Importvorgang aus, der `GamesTable` dem Ziel-Stack hinzufügt.

   1. Wählen Sie auf der Seite **Stacks** mit ausgewähltem übergeordneten Stack **Stack-Aktionen** und dann **Ressourcen in Stack importieren** aus.  
![\[Die Option „Ressourcen in Stack importieren“ in der Konsole.\]](http://docs.aws.amazon.com/de_de/AWSCloudFormation/latest/UserGuide/images/stack-actions-import.png)

   1. Auf der Seite **Importübersicht** finden Sie eine Liste der Dinge, die Sie während dieses Vorgangs angeben müssen. Wählen Sie anschließend **Weiter**.

   1. Führen Sie auf der Seite **Vorlage angeben** eine der folgenden Aktionen aus und wählen Sie dann **Weiter**.
      + Wählen Sie **Amazon S3-URL** aus und geben Sie dann im Textfeld eine URL an.
      + Wählen Sie **Vorlagendatei hochladen** aus und suchen Sie dann nach einer Datei, die hochgeladen werden soll.

   1. Identifizieren Sie auf der Seite **Ressourcen identifizieren** die Ressource, die Sie verschieben möchten (in diesem Beispiel `GamesTable`). Weitere Informationen finden Sie unter [Identifikatoren für Ressourcen](import-resources-manually.md#resource-import-identifiers-unique-ids).

      1. Wählen Sie unter **Bezeichnereigenschaft** den Typ des Ressourcenbezeichners aus. Beispielsweise kann eine `AWS::DynamoDB::Table`-Ressource mit der `TableName`-Eigenschaft identifiziert werden.

      1. Geben Sie unter **Bezeichnerwert** den tatsächlichen Eigenschaftswert ein. Beispiel, `GamesTables`. 

      1. Wählen Sie **Weiter** aus.

   1. Ändern Sie auf der Seite **Stack-Details angeben** alle Parameter und wählen Sie dann **Weiter** aus. Dadurch wird automatisch ein Änderungssatz erstellt.
**Wichtig**  
Der Importvorgang schlägt fehl, wenn Sie vorhandene Parameter ändern, die einen Erstellungs-, Aktualisierungs- oder Löschvorgang initiieren.

   1. Vergewissern Sie sich auf der *TargetStackName* Seite **Überprüfen**, dass die richtige Ressource importiert wurde, und wählen Sie dann **Ressourcen importieren** aus. Dadurch wird der im letzten Schritt erstellte Änderungssatz automatisch ausgeführt. Alle [Tags auf Stack-Ebene](cfn-console-create-stack.md#configure-stack-options) werden zu diesem Zeitpunkt auf importierte Ressourcen angewendet.

   1. Der Bereich **Ereignisse** der Seite **Stack-Details** für Ihren übergeordneten Stack wird angezeigt.  
![\[Die Registerkarte „Ereignisse“ in der Konsole.\]](http://docs.aws.amazon.com/de_de/AWSCloudFormation/latest/UserGuide/images/import-events.png)
**Anmerkung**  
Es ist nicht erforderlich, die Abweichungserkennung für den übergeordneten Stack nach diesem Importvorgang auszuführen, da die `AWS::CloudFormation::Stack`-Ressource bereits von CloudFormation verwaltet wird.

## Refaktorieren Sie einen Stack mit dem AWS CLI
<a name="refactor-stacks-cli"></a>

1. Geben Sie in der Quellvorlage a `Retain` [DeletionPolicy](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-attribute-deletionpolicy.html)für die Ressource an, die Sie verschieben möchten.

   In der folgenden Beispiel-Quellvorlage ist `GamesTable` das Ziel dieser Umgestaltung.  
**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. Aktualisieren Sie den Quell-Stack, um die Löschrichtlinie auf die Ressource anzuwenden.

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

1. Entfernen Sie die Ressource, die zugehörigen Parameter und Ausgaben aus der Quellvorlage und fügen Sie sie dann der Zielvorlage hinzu.

   Die Quellvorlage sieht nun wie folgt aus.  
**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
                 }
              }
           }
       }
   }
   ```

   Die folgende Beispiel-Zielvorlage enthält derzeit die `PlayersTable`-Ressource und enthält nun auch `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. Aktualisieren Sie den Quell-Stack, um die `GamesTable`-Ressource und die zugehörigen Parameter und Ausgaben aus dem Stack zu löschen.

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

1. Stellen Sie eine Liste der zu importierenden Ressourcen und ihrer eindeutigen Bezeichner im folgenden JSON-String-Format zusammen. Weitere Informationen finden Sie unter [Identifikatoren für Ressourcen](import-resources-manually.md#resource-import-identifiers-unique-ids).

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

   Alternativ können Sie die JSON-formatierten Parameter in einer Konfigurationsdatei angeben. 

   Um beispielsweise zu importieren`GamesTable`, können Sie eine *ResourcesToImport.txt* Datei erstellen, die die folgende Konfiguration enthält.

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

1. Um einen Änderungssatz zu erstellen, verwenden Sie den folgenden Befehl **create-change-set** und ersetzen den Platzhaltertext. Geben Sie für die Option `--change-set-type` einen Wert von **IMPORT** an. Ersetzen Sie bei der Option `--resources-to-import` die Beispiel-JSON-Zeichenfolge durch die tatsächliche JSON-Zeichenfolge, die Sie gerade erstellt haben.

   ```
   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"}}]'"
   ```
**Anmerkung**  
`--resources-to-import` unterstützt kein Inline-YAML. Die Anforderungen für das Escapen von Anführungszeichen in der JSON-Zeichenfolge variieren je nach Ihrem Terminal. Weitere Informationen finden Sie unter [Anführungszeichen in Zeichenketten verwenden](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-parameters-quoting-strings.html#cli-usage-parameters-quoting-strings-containing) im *AWS Command Line Interface -Benutzerhandbuch*.

   Alternativ können Sie auch eine Datei-URL als Eingabe für die Option `--resources-to-import` verwenden, wie im folgenden Beispiel gezeigt.

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

1. Überprüfen Sie den Änderungssatz, um sicherzustellen, dass die richtige Ressource in den Ziel-Stack importiert wird.

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

1. Um den Änderungssatz zu initiieren und die Ressource zu importieren, verwenden Sie den folgenden **execute-change-set**-Befehl und ersetzen den Platzhaltertext. Alle Tags auf Stack-Ebene werden zu diesem Zeitpunkt auf importierte Ressourcen angewendet. Nach erfolgreichem Abschluss des Vorgangs `(IMPORT_COMPLETE)` wird die Ressource erfolgreich importiert.

   ```
   aws cloudformation execute-change-set \
       --change-set-name ImportChangeSet --stack-name TargetStackName
   ```
**Anmerkung**  
Es ist nicht erforderlich, die Abweichungserkennung für den Ziel-Stack nach diesem Importvorgang auszuführen, da die Ressource bereits von CloudFormation verwaltet wird.