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.
# Tutorial: Ändern Sie die Integrationsanfrage und die Antwort für Integrationen zu AWS service
Das folgende Tutorial zeigt, wie Sie mithilfe von Mapping-Vorlagentransformationen Mapping-Vorlagen einrichten, um Integrationsanfragen und -antworten mithilfe der Konsole und der AWS CLI zu transformieren.
**Topics**
+ [Einrichten einer Datentransformation mithilfe der API-Gateway-Konsole](#mapping-example-console)
+ [Richten Sie die Datentransformation mit dem ein AWS CLI](#mapping-example-cli)
+ [Datentransformation abgeschlossen CloudFormation Vorlage](#api-gateway-data-transformations-full-cfn-stack)
## Einrichten einer Datentransformation mithilfe der API-Gateway-Konsole
In diesem Tutorial erstellen Sie eine unvollständige API- und DynamoDB-Tabelle mithilfe der folgenden ZIP-Datei [data-transformation-tutorial-console.zip](samples/data-transformation-tutorial-console.zip). Diese unvollständige API hat eine `/pets`-Ressource mit den Methoden `GET` und `POST`.
+ Die `GET`-Methode ruft Daten vom `http://petstore-demo-endpoint.execute-api.com/petstore/pets`-HTTP-Endpunkt ab. Die Ausgabedaten werden gemäß der Zuweisungsvorlage zu [Transformationen mit Zuweisungsvorlagen für REST-APIs in API Gateway](models-mappings.md) transformiert.
+ Die `POST`-Methode ermöglicht dem Benutzer die `POST`-Aktion von Haustierinformationen mithilfe einer Zuweisungsvorlage an eine Amazon-DynamoDB-Tabelle.
Laden Sie [die Vorlage zur App-Erstellung](samples/data-transformation-tutorial-console.zip) für herunter und entpacken Sie sie. CloudFormation Sie verwenden diese Vorlage, um eine DynamoDB-Tabelle zum Posten von Haustierinformationen und einer unvollständigen API zu erstellen. Sie schließen die restlichen Schritte in der API-Gateway-Konsole ab.
**Um eine zu erstellen CloudFormation Stack**
1. Öffnen Sie die CloudFormation Konsole unter [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Wählen Sie **Stack erstellen** und dann **Mit neuen Ressourcen (Standard)** aus.
1. Wählen Sie unter **Vorlage angeben** die Option **Vorlagendatei hochladen** aus.
1. Wählen Sie die Vorlage aus, die Sie heruntergeladen haben.
1. Wählen Sie **Weiter** aus.
1. Geben Sie für **Stack-Name** die Zeichenfolge **data-transformation-tutorial-console** ein und klicken Sie auf **Weiter**.
1. Wählen Sie in **Stack-Optionen konfigurieren** die Option **Weiter** aus.
1. Bestätigen Sie bei **Capabilities**, dass IAM-Ressourcen in Ihrem Konto erstellt werden CloudFormation können.
1. Wählen Sie **Weiter** und anschließend **Absenden** aus.
CloudFormation stellt die in der Vorlage angegebenen Ressourcen bereit. Die Bereitstellung der Ressourcen kann einige Minuten dauern. Wenn der Status Ihres CloudFormation Stacks **CREATE\_COMPLETE** lautet, können Sie mit dem nächsten Schritt fortfahren.
**Um die Antwort der `GET-Integration zu` testen**
1. Wählen Sie auf der Registerkarte **Ressourcen** des CloudFormation Stacks für **data-transformation-tutorial-console** die physische ID Ihrer API aus.
1. Klicken Sie im Hauptnavigationsbereich auf **Ressourcen** und wählen Sie dann die **GET**-Methode in der Ressourcenstruktur aus.
1. Wählen Sie die Registerkarte **Test**. Möglicherweise müssen Sie die rechte Pfeiltaste wählen, um die Registerkarte anzuzeigen.
Das Ergebnis des Tests wird Folgendes zeigen:
```
[
{
"id": 1,
"type": "dog",
"price": 249.99
},
{
"id": 2,
"type": "cat",
"price": 124.99
},
{
"id": 3,
"type": "fish",
"price": 0.99
}
]
```
Sie transformieren diese Ausgabe gemäß der Zuweisungsvorlage in [Transformationen mit Zuweisungsvorlagen für REST-APIs in API Gateway](models-mappings.md).
**Um die GET-Integrationsantwort `zu` transformieren**
1. Klicken Sie auf die Registerkarte **Integrationsantwort**.
Derzeit sind keine Zuweisungsvorlagen definiert, sodass die Integrationsantwort nicht transformiert wird.
1. Klicken Sie unter **Standard - Antwort** auf **Bearbeiten**.
1. Wählen Sie **Vorlagen zuordnen** aus und gehen Sie dann wie folgt vor:
1. Wählen Sie **Add mapping template**.
1. Geben Sie für **Content type** (Inhaltstyp) **application/json** ein.
1. Geben Sie für **Vorlagentext** Folgendes ein:
```
#set($inputRoot = $input.path('$'))
[
#foreach($elem in $inputRoot)
{
"description" : "Item $elem.id is a $elem.type.",
"askingPrice" : $elem.price
}#if($foreach.hasNext),#end
#end
]
```
Wählen Sie **Speichern**.
**Um die `GET-Integrationsantwort` zu testen**
+ Wählen Sie die Registerkarte **Test** und dann **Test** aus
Die Ausgabe des Tests zeigt die transformierte Antwort.
```
[
{
"description" : "Item 1 is a dog.",
"askingPrice" : 249.99
},
{
"description" : "Item 2 is a cat.",
"askingPrice" : 124.99
},
{
"description" : "Item 3 is a fish.",
"askingPrice" : 0.99
}
]
```
**Um Eingabedaten aus der `POST-Methode` zu transformieren**
1. Wählen Sie die **POST**-Methode aus.
1. Wählen Sie die Registerkarte **Integrationsanfrage** aus und klicken Sie dann unter **Einstellungen für Integrationsanforderungen** auf **Bearbeiten**.
Die CloudFormation Vorlage hat einige Felder für Integrationsanfragen gefüllt.
+ Der Integrationstyp ist AWS-Service.
+ Das AWS-Service ist DynamoDB.
+ Die HTTP-Methode ist `POST`.
+ Die Aktion ist `PutItem`.
+ Die Ausführungsrolle, die es API Gateway ermöglicht, ein Element in die DynamoDB-Tabelle aufzunehmen, lautet. `data-transformation-tutorial-console-APIGatewayRole` CloudFormation hat diese Rolle erstellt, damit API Gateway über die Mindestberechtigungen für die Interaktion mit DynamoDB verfügt.
Der Name der DynamoDB-Tabelle wurde nicht angegeben. In den folgenden Schritten geben Sie den Namen an.
1. Für **Text-Passthrough anfordern** wählen Sie **Nie** aus.
Das bedeutet, dass die API Daten ablehnt, für Content-Types die es keine Zuordnungsvorlage gibt.
1. Wählen Sie **Zuordnungsvorlagen** aus.
1. Der **Inhaltstyp** ist auf `application/json` gesetzt. Das bedeutet, dass Inhaltstypen, die application/json dies nicht sind, von der API abgelehnt werden. Weitere Informationen zu Integrations-Passthrough-Verhaltensweisen finden Sie unter [Verhalten der Methodenanforderung für Nutzdaten ohne Zuweisungsvorlagen für REST-APIs in API Gateway](integration-passthrough-behaviors.md).
1. Geben Sie den folgenden Code in den Texteditor ein.
```
{
"TableName":"data-transformation-tutorial-console-ddb",
"Item": {
"id": {
"N": $input.json("$.id")
},
"type": {
"S": $input.json("$.type")
},
"price": {
"N": $input.json("$.price")
}
}
}
```
Diese Vorlage spezifiziert die Tabelle als `data-transformation-tutorial-console-ddb` und legt die Elemente als `id`, `type` und `price` fest. Die Elemente kommen aus dem Hauptteil der `POST`-Methode. Sie können auch ein Datenmodell verwenden, um eine Zuweisungsvorlage zu erstellen. Weitere Informationen finden Sie unter [Validierung für REST APIs in API Gateway anfordern](api-gateway-method-request-validation.md).
1. Betätigen Sie die Schaltfläche **Speichern**, um die Zuweisungsvorlage zu speichern.
**Um eine Methode und eine Integrationsantwort aus der `POST-Methode` hinzuzufügen**
Sie CloudFormation haben eine leere Methode und eine leere Integrationsantwort erstellt. Sie werden diese Antwort bearbeiten, um weitere Informationen bereitzustellen. Weitere Informationen zum Bearbeiten von Antworten finden Sie unter [Beispiele für Parameterzuweisungen für REST-APIs in API Gateway](request-response-data-mappings.md).
1. Klicken Sie auf der Registerkarte **Integrationsantwort** unter **Standard - Antwort** auf **Bearbeiten**.
1. Wählen Sie **Zuordnungsvorlagen** aus und klicken Sie dann auf **Zuordnungsvorlage hinzufügen**.
1. Geben Sie unter **Content-type** den Wert **application/json** ein.
1. Geben Sie im Code-Editor die folgende Ausgabe–Zuweisungsvorlage ein, um eine Ausgabenachricht zu senden:
```
{ "message" : "Your response was recorded at $context.requestTime" }
```
Weitere Informationen zu Kontextvariablen finden Sie unter [Kontextvariablen für Datentransformationen](api-gateway-mapping-template-reference.md#context-variable-reference).
1. Betätigen Sie die Schaltfläche **Speichern**, um die Zuweisungsvorlage zu speichern.
**Testen Sie die `POST-Methode`**
Wählen Sie die Registerkarte **Test**. Möglicherweise müssen Sie die rechte Pfeiltaste wählen, um die Registerkarte anzuzeigen.
1. Geben Sie im Anforderungstext das folgende Beispiel ein.
```
{
"id": "4",
"type" : "dog",
"price": "321"
}
```
1. Wählen Sie **Test** aus.
Die Ausgabe sollte Ihre Erfolgsmeldung enthalten.
Sie können die DynamoDB-Konsole unter öffnen, [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/)um zu überprüfen, ob sich das Beispielelement in Ihrer Tabelle befindet.
**Um ein zu löschen CloudFormation Stack**
1. Öffnen Sie die CloudFormation Konsole unter [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. Wählen Sie Ihren CloudFormation Stack aus.
1. Wählen Sie **Löschen** und bestätigen Sie dann Ihre Auswahl.
## Richten Sie die Datentransformation mit dem ein AWS CLI
In diesem Tutorial erstellen Sie eine unvollständige API- und DynamoDB-Tabelle mithilfe der folgenden ZIP-Datei [data-transformation-tutorial-cli.zip](samples/data-transformation-tutorial-cli.zip). Diese unvollständige API verfügt über eine `/pets`-Ressource mit einer `GET`-Methode, die in den `http://petstore-demo-endpoint.execute-api.com/petstore/pets`-HTTP-Endpunkt integriert ist. Sie erstellen eine `POST`-Methode, um eine Verbindung zu einer DynamoDB-Tabelle herzustellen, und verwenden Zuweisungsvorlagen, um Daten in eine DynamoDB-Tabelle einzugeben.
+ Sie transformieren die Ausgabedaten gemäß der Zuweisungsvorlage zu [Transformationen mit Zuweisungsvorlagen für REST-APIs in API Gateway](models-mappings.md).
+ Sie erstellen eine `POST`-Methode, die es dem Benutzer ermöglicht, mithilfe einer Zuweisungsvorlage die `POST`-Aktion an eine Amazon-DynamoDB-Tabelle durchzuführen.
**Um eine zu erstellen CloudFormation Stack**
Laden Sie [die Vorlage zur App-Erstellung für CloudFormation](samples/data-transformation-tutorial-cli.zip) herunter und entpacken Sie sie.
Um die folgenden Schritte durchzuführen, benötigen Sie die [AWS Command Line Interface (AWS CLI) Version 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
Bei langen Befehlen wird ein Escape-Zeichen (`\`) verwendet, um einen Befehl auf mehrere Zeilen aufzuteilen.
**Anmerkung**
In Windows werden einige Bash-CLI-Befehle, die Sie häufig verwenden (z. B. `zip`), von den integrierten Terminals des Betriebssystems nicht unterstützt. Um eine Windows-integrated Version von Ubuntu und Bash zu erhalten, [installieren Sie das Windows-Subsystem](https://learn.microsoft.com/en-us/windows/wsl/install) für Linux. Die CLI-Beispielbefehle in diesem Handbuch verwenden die Linux-Formatierung. Befehle, die Inline-JSON-Dokumente enthalten, müssen neu formatiert werden, wenn Sie die Windows-CLI verwenden.
1. Verwenden Sie den folgenden Befehl, um den Stack zu erstellen. CloudFormation
```
aws cloudformation create-stack --stack-name data-transformation-tutorial-cli --template-body file://data-transformation-tutorial-cli.zip --capabilities CAPABILITY_NAMED_IAM
```
1. CloudFormation stellt die in der Vorlage angegebenen Ressourcen bereit. Die Bereitstellung der Ressourcen kann einige Minuten dauern. Verwenden Sie den folgenden Befehl, um den Status Ihres CloudFormation Stacks zu überprüfen.
```
aws cloudformation describe-stacks --stack-name data-transformation-tutorial-cli
```
1. Wenn der Status Ihres CloudFormation Stacks lautet`StackStatus: "CREATE_COMPLETE"`, verwenden Sie den folgenden Befehl, um relevante Ausgabewerte für future Schritte abzurufen.
```
aws cloudformation describe-stacks --stack-name data-transformation-tutorial-cli --query "Stacks[*].Outputs[*].{OutputKey: OutputKey, OutputValue: OutputValue, Description: Description}"
```
Die Ausgabewerte sind die folgenden:
+ ApiRole, das ist der Rollenname, der es API Gateway ermöglicht, Elemente in die DynamoDB-Tabelle einzufügen. Für dieses Tutorial ist der Rollenname `data-transformation-tutorial-cli-APIGatewayRole-ABCDEFG`.
+ DDBTableName, das ist der Name der DynamoDB-Tabelle. Für dieses Tutorial ist der Name der Tabelle `data-transformation-tutorial-cli-ddb`.
+ ResourceId, das ist die ID der Pets-Ressource, in der die `POST` Methoden `GET` und verfügbar gemacht werden. Für dieses Tutorial lautet die Ressourcen-ID `efg456`.
+ ApiId, was die ID für die API ist. Für dieses Tutorial lautet die API-ID `abc123`.
**Um die `GET-Methode` vor der Datentransformation zu testen**
+ Geben Sie den folgenden Befehl ein, um die `GET`-Methode zu testen.
```
aws apigateway test-invoke-method --rest-api-id {{abc123}} \
--resource-id {{efg456}} \
--http-method GET
```
Die Ausgabe des Tests wird Folgendes zeigen.
```
[
{
"id": 1,
"type": "dog",
"price": 249.99
},
{
"id": 2,
"type": "cat",
"price": 124.99
},
{
"id": 3,
"type": "fish",
"price": 0.99
}
]
```
Sie transformieren diese Ausgabe gemäß der Zuweisungsvorlage in [Transformationen mit Zuweisungsvorlagen für REST-APIs in API Gateway](models-mappings.md).
**Um die GET-Integrationsantwort `zu` transformieren**
+ Führen Sie den folgenden Befehl aus, um die Integrationsantwort für die `GET`-Methode zu aktualisieren. Ersetzen Sie das {{rest-api-id}} und {{resource-id}} durch Ihre Werte.
Verwenden Sie den folgenden Befehl, um die Integrationsantwort zu erstellen.
```
aws apigateway put-integration-response --rest-api-id {{abc123}} \
--resource-id {{efg456}} \
--http-method GET \
--status-code 200 \
--selection-pattern "" \
--response-templates '{"application/json": "#set($inputRoot = $input.path(\"$\"))\n[\n#foreach($elem in $inputRoot)\n {\n \"description\": \"Item $elem.id is a $elem.type\",\n \"askingPrice\": \"$elem.price\"\n }#if($foreach.hasNext),#end\n\n#end\n]"}'
```
**Um die GET-Methode `zu` testen**
+ Geben Sie den folgenden Befehl ein, um die `GET`-Methode zu testen.
```
aws apigateway test-invoke-method --rest-api-id {{abc123}} \
--resource-id {{efg456}} \
--http-method GET \
```
Die Ausgabe des Tests zeigt die transformierte Antwort.
```
[
{
"description" : "Item 1 is a dog.",
"askingPrice" : 249.99
},
{
"description" : "Item 2 is a cat.",
"askingPrice" : 124.99
},
{
"description" : "Item 3 is a fish.",
"askingPrice" : 0.99
}
]
```
**Um eine `POST-Methode` zu erstellen**
1. Führen Sie den folgenden Befehl aus, um eine neue Methode für die `/pets`-Ressource zu erstellen.
```
aws apigateway put-method --rest-api-id {{abc123}} \
--resource-id {{efg456}} \
--http-method POST \
--authorization-type "NONE" \
```
Mit dieser Methode können Sie Pet-Informationen an die DynamoDB-Tabelle senden, die Sie im Stack erstellt haben. CloudFormation
1. Verwenden Sie den folgenden Befehl, um eine AWS-Service Integration für die `POST` Methode zu erstellen.
```
aws apigateway put-integration --rest-api-id {{abc123}} \
--resource-id {{efg456}} \
--http-method POST \
--type AWS \
--integration-http-method POST \
--uri "arn:aws:apigateway:{{us-east-2}}:dynamodb:action/PutItem" \
--credentials arn:aws:iam::{{111122223333}}:role/{{data-transformation-tutorial-cli-APIGatewayRole-ABCDEFG}} \
--request-templates '{"application/json":"{\"TableName\":\"data-transformation-tutorial-cli-ddb\",\"Item\":{\"id\":{\"N\":$input.json(\"$.id\")},\"type\":{\"S\":$input.json(\"$.type\")},\"price\":{\"N\":$input.json(\"$.price\")} }}"}'
```
1. Verwenden Sie den folgenden Befehl, um eine Methodenantwort für einen erfolgreichen Aufruf der `POST`-Methode zu erstellen.
```
aws apigateway put-method-response --rest-api-id {{abc123}} \
--resource-id {{efg456}} \
--http-method POST \
--status-code 200
```
1. Verwenden Sie den folgenden Befehl, um eine Integrationsantwort für den erfolgreichen Aufruf der `POST`-Methode zu erstellen.
```
aws apigateway put-integration-response --rest-api-id {{abc123}} \
--resource-id {{efg456}} \
--http-method POST \
--status-code 200 \
--selection-pattern "" \
--response-templates '{"application/json": "{\"message\": \"Your response was recorded at $context.requestTime\"}"}'
```
**Um die `POST-Methode` zu testen**
+ Geben Sie den folgenden Befehl ein, um die `POST`-Methode zu testen.
```
aws apigateway test-invoke-method --rest-api-id {{abc123}} \
--resource-id {{efg456}} \
--http-method POST \
--body '{\"id\": \"4\", \"type\": \"dog\", \"price\": \"321\"}'
```
In der Ausgabe wird die Erfolgsmeldung angezeigt.
**Um ein zu löschen CloudFormation Stack**
+ Verwenden Sie den folgenden Befehl, um Ihre CloudFormation Ressourcen zu löschen.
```
aws cloudformation delete-stack --stack-name data-transformation-tutorial-cli
```
## Datentransformation abgeschlossen CloudFormation Vorlage
Das folgende Beispiel ist eine fertige CloudFormation Vorlage, die eine API und eine DynamoDB-Tabelle mit einer `/pets` Ressource mit `GET` und `POST` Methoden erstellt.
+ Die `GET`-Methode ruft Daten vom `http://petstore-demo-endpoint.execute-api.com/petstore/pets`-HTTP-Endpunkt ab. Die Ausgabedaten werden gemäß der Zuweisungsvorlage zu [Transformationen mit Zuweisungsvorlagen für REST-APIs in API Gateway](models-mappings.md) transformiert.
+ Die `POST`-Methode ermöglicht es dem Benutzer, mithilfe einer Zuweisungsvorlage die `POST`-Aktion zu einer DynamoDB-Tabelle durchzuführen.
### Beispiel CloudFormation Vorlage
```
AWSTemplateFormatVersion: 2010-09-09
Description: A completed Amazon API Gateway REST API that uses non-proxy integration to POST to an Amazon DynamoDB table and non-proxy integration to GET transformed pets data.
Parameters:
StageName:
Type: String
Default: v1
Description: Name of API stage.
Resources:
DynamoDBTable:
Type: 'AWS::DynamoDB::Table'
Properties:
TableName: !Sub data-transformation-tutorial-complete
AttributeDefinitions:
- AttributeName: id
AttributeType: N
KeySchema:
- AttributeName: id
KeyType: HASH
ProvisionedThroughput:
ReadCapacityUnits: 5
WriteCapacityUnits: 5
APIGatewayRole:
Type: 'AWS::IAM::Role'
Properties:
AssumeRolePolicyDocument:
Version: 2012-10-17
Statement:
- Action:
- 'sts:AssumeRole'
Effect: Allow
Principal:
Service:
- apigateway.amazonaws.com
Policies:
- PolicyName: APIGatewayDynamoDBPolicy
PolicyDocument:
Version: 2012-10-17
Statement:
- Effect: Allow
Action:
- 'dynamodb:PutItem'
Resource: !GetAtt DynamoDBTable.Arn
Api:
Type: 'AWS::ApiGateway::RestApi'
Properties:
Name: data-transformation-complete-api
ApiKeySourceType: HEADER
PetsResource:
Type: 'AWS::ApiGateway::Resource'
Properties:
RestApiId: !Ref Api
ParentId: !GetAtt Api.RootResourceId
PathPart: 'pets'
PetsMethodGet:
Type: 'AWS::ApiGateway::Method'
Properties:
RestApiId: !Ref Api
ResourceId: !Ref PetsResource
HttpMethod: GET
ApiKeyRequired: false
AuthorizationType: NONE
Integration:
Type: HTTP
Credentials: !GetAtt APIGatewayRole.Arn
IntegrationHttpMethod: GET
Uri: http://petstore-demo-endpoint.execute-api.com/petstore/pets/
PassthroughBehavior: WHEN_NO_TEMPLATES
IntegrationResponses:
- StatusCode: '200'
ResponseTemplates:
application/json: "#set($inputRoot = $input.path(\"$\"))\n[\n#foreach($elem in $inputRoot)\n {\n \"description\": \"Item $elem.id is a $elem.type\",\n \"askingPrice\": \"$elem.price\"\n }#if($foreach.hasNext),#end\n\n#end\n]"
MethodResponses:
- StatusCode: '200'
PetsMethodPost:
Type: 'AWS::ApiGateway::Method'
Properties:
RestApiId: !Ref Api
ResourceId: !Ref PetsResource
HttpMethod: POST
ApiKeyRequired: false
AuthorizationType: NONE
Integration:
Type: AWS
Credentials: !GetAtt APIGatewayRole.Arn
IntegrationHttpMethod: POST
Uri: arn:aws:apigateway:us-west-1:dynamodb:action/PutItem
PassthroughBehavior: NEVER
RequestTemplates:
application/json: "{\"TableName\":\"data-transformation-tutorial-complete\",\"Item\":{\"id\":{\"N\":$input.json(\"$.id\")},\"type\":{\"S\":$input.json(\"$.type\")},\"price\":{\"N\":$input.json(\"$.price\")} }}"
IntegrationResponses:
- StatusCode: 200
ResponseTemplates:
application/json: "{\"message\": \"Your response was recorded at $context.requestTime\"}"
MethodResponses:
- StatusCode: '200'
ApiDeployment:
Type: 'AWS::ApiGateway::Deployment'
DependsOn:
- PetsMethodGet
Properties:
RestApiId: !Ref Api
StageName: !Sub '${StageName}'
Outputs:
ApiId:
Description: API ID for CLI commands
Value: !Ref Api
ResourceId:
Description: /pets resource ID for CLI commands
Value: !Ref PetsResource
ApiRole:
Description: Role ID to allow API Gateway to put and scan items in DynamoDB table
Value: !Ref APIGatewayRole
DDBTableName:
Description: DynamoDB table name
Value: !Ref DynamoDBTable
```