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à.
# Tutorial: modifica la richiesta e la risposta di integrazione per le integrazioni ai servizi AWS
Il seguente tutorial mostra come utilizzare le trasformazioni dei modelli di mappatura per configurare i modelli di mappatura per trasformare le richieste e le risposte di integrazione utilizzando la console e la CLI. AWS
**Topics**
+ [Configurare la trasformazione dei dati utilizzando la console Gateway Amazon API](#mapping-example-console)
+ [Configura la trasformazione dei dati utilizzando la AWS CLI](#mapping-example-cli)
+ [CloudFormation Modello di trasformazione dei dati completato](#api-gateway-data-transformations-full-cfn-stack)
## Configurare la trasformazione dei dati utilizzando la console Gateway Amazon API
[In questo tutorial, creerai un'API incompleta e una tabella DynamoDB utilizzando il seguente file.zip .zip. data-transformation-tutorial-console](samples/data-transformation-tutorial-console.zip) Questa API incompleta dispone di una risorsa `/pets` con i metodi `GET` e `POST`.
+ Il metodo `GET` otterrà i dati dall'endpoint HTTP `http://petstore-demo-endpoint.execute-api.com/petstore/pets`. I dati di output verranno trasformati in base al modello di mappatura in [Trasformazioni dei modelli di mappatura per REST APIs in API Gateway](models-mappings.md).
+ Il metodo `POST` consentirà all'utente di pubblicare (`POST`) le informazioni sugli animali domestici in una tabella Amazon DynamoDB utilizzando un modello di mappatura.
Scarica e decomprimi il modello di creazione [dell'](samples/data-transformation-tutorial-console.zip)app per. CloudFormation Verrà utilizzato questo modello per creare una tabella DynamoDB per pubblicare informazioni sugli animali domestici e un'API incompleta. Il resto della procedura verrà completato nella console Gateway Amazon API.
**Per creare una pila CloudFormation**
1. Apri la CloudFormation console in [https://console.aws.amazon.com/cloudformation.](https://console.aws.amazon.com/cloudformation/)
1. Scegliere **Create stack (Crea stack)**, quindi **With new resources (standard) (Con nuove risorse (standard))**.
1. In **Specificare modello**, scegliere **Carica un file modello**.
1. Selezionare il modello scaricato.
1. Scegli **Next (Successivo)**.
1. Per **Stack name (Nome stack)**, inserire **data-transformation-tutorial-console**, quindi scegliere **Next (Avanti)**.
1. Per **Configure stack options (Configura opzioni di stack)**, scegliere **Next (Successivo)**.
1. Per quanto riguarda **le funzionalità**, riconosci che CloudFormation puoi creare risorse IAM nel tuo account.
1. Scegli **Avanti**, quindi scegli **Invia**.
CloudFormation fornisce le risorse specificate nel modello. Per completare il provisioning delle risorse, potrebbero essere necessari alcuni minuti. Quando lo stato del tuo CloudFormation stack è **CREATE\$1COMPLETE**, sei pronto per passare alla fase successiva.
**Test della risposta di integrazione `GET`**
1. Nella scheda **Risorse** dello CloudFormation stack di**data-transformation-tutorial-console**, seleziona l'ID fisico della tua API.
1. Nel pannello di navigazione principale scegli **Risorse**, quindi seleziona il metodo **GET**.
1. Seleziona la scheda **Test**. Potrebbe essere necessario scegliere il pulsante freccia destra per visualizzare la scheda.
L'output del test mostrerà quanto segue:
```
[
{
"id": 1,
"type": "dog",
"price": 249.99
},
{
"id": 2,
"type": "cat",
"price": 124.99
},
{
"id": 3,
"type": "fish",
"price": 0.99
}
]
```
Questo output verrà trasformato in base al modello di mappatura in [Trasformazioni dei modelli di mappatura per REST APIs in API Gateway](models-mappings.md).
**Trasformazione della risposta di integrazione `GET`**
1. Scegli la scheda **Risposta di integrazione**.
Attualmente non sono definiti modelli di mappatura, quindi la risposta di integrazione non verrà trasformata.
1. Per **Predefinito - Risposta** scegli **Modifica**.
1. Scegli **Modelli di mappatura** e procedi come indicato di seguito:
1. Scegliere **Add mapping template (Aggiungi modello di mappatura)**.
1. Per **Tipo di contenuto** inserisci **application/json**.
1. Per **Corpo del modello** inserisci quanto segue:
```
#set($inputRoot = $input.path('$'))
[
#foreach($elem in $inputRoot)
{
"description" : "Item $elem.id is a $elem.type.",
"askingPrice" : $elem.price
}#if($foreach.hasNext),#end
#end
]
```
Scegli **Save** (Salva).
**Test della risposta di integrazione `GET`**
+ Scegli la scheda **Test**, quindi seleziona **Test**.
L'output del test mostrerà la risposta trasformata.
```
[
{
"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
}
]
```
**Trasformazione dei dati di input dal metodo `POST`**
1. Scegli il metodo **POST**.
1. Scegli la scheda **Richiesta di integrazione**, quindi seleziona **Modifica** per **Impostazioni della richiesta di integrazione**.
Il CloudFormation modello ha compilato alcuni campi di richiesta di integrazione.
+ Il tipo di integrazione è Servizio AWS.
+ Servizio AWS Si tratta di DynamoDB.
+ Il metodo HTTP è `POST`.
+ L'operazione è `PutItem`.
+ Il ruolo di esecuzione che consente ad API Gateway di inserire un elemento nella tabella DynamoDB è. `data-transformation-tutorial-console-APIGatewayRole` CloudFormation ha creato questo ruolo per consentire ad API Gateway di disporre delle autorizzazioni minime per interagire con DynamoDB.
Il nome della tabella DynamoDB non è stato specificato. Il nome verrà specificato nei passaggi seguenti.
1. Per **Richiesta corpo passthrough** seleziona **Mai**.
Ciò significa che l'API rifiuterà i dati con Content-Types che non dispongono di un modello di mappatura.
1. Scegli **Modelli di mappatura**.
1. **Tipo di contenuto** è impostato su `application/json`. Ciò significa che i tipi di contenuto che non lo sono application/json verranno rifiutati dall'API. Per ulteriori informazioni sui comportamenti passthrough di integrazione, consultare [Comportamento della richiesta del metodo per i payload senza modelli di mappatura per REST APIs in API Gateway](integration-passthrough-behaviors.md).
1. Inserire il codice seguente nell'editor di testo.
```
{
"TableName":"data-transformation-tutorial-console-ddb",
"Item": {
"id": {
"N": $input.json("$.id")
},
"type": {
"S": $input.json("$.type")
},
"price": {
"N": $input.json("$.price")
}
}
}
```
Questo modello specifica la tabella come `data-transformation-tutorial-console-ddb` e imposta gli elementi come `id`, `type` e`price`. Gli elementi proverranno dal corpo del metodo `POST`. È anche possibile utilizzare un modello di dati per creare un modello di mappatura. Per ulteriori informazioni, consulta [Richiedi la convalida per REST APIs in API Gateway](api-gateway-method-request-validation.md).
1. Scegliere il pulsante **Salva** per salvare il modello di mappatura.
**Aggiunta di un metodo e una risposta di integrazione dal metodo `POST`**
Hanno CloudFormation creato un metodo vuoto e una risposta di integrazione. Questa risposta verrà modificata per fornire ulteriori informazioni. Per ulteriori informazioni su come modificare le risposte, consultare [Esempi di mappatura dei parametri per REST APIs in API Gateway](request-response-data-mappings.md).
1. Nella scheda **Risposta di integrazione** scegli **Modifica** per **Predefinito - Risposta**.
1. Scegli **Modelli di mappatura**, quindi seleziona **Aggiungi modello di mappatura**.
1. Per **Content-type** immetti **application/json**.
1. Nell'editor di codice, inserire il seguente modello di mappatura di output per inviare un messaggio di output:
```
{ "message" : "Your response was recorded at $context.requestTime" }
```
Per ulteriori informazioni sulle variabili di contesto, consultare [Variabili di contesto per le trasformazioni dei dati](api-gateway-mapping-template-reference.md#context-variable-reference).
1. Scegliere il pulsante **Salva** per salvare il modello di mappatura.
**Test del metodo `POST`**
Seleziona la scheda **Test**. Potrebbe essere necessario scegliere il pulsante freccia destra per visualizzare la scheda.
1. Nel corpo della richiesta, inserire il seguente esempio.
```
{
"id": "4",
"type" : "dog",
"price": "321"
}
```
1. Scegli **Test (Esegui test)**.
L'output dovrebbe mostrare il messaggio di operazione riuscita.
Puoi aprire la console DynamoDB [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/)all'indirizzo per verificare che l'elemento di esempio sia nella tua tabella.
**Per eliminare uno stack CloudFormation**
1. Apri la CloudFormation console in [https://console.aws.amazon.com/cloudformation.](https://console.aws.amazon.com/cloudformation/)
1. Seleziona il tuo stack. CloudFormation
1. Scegli **Elimina** e conferma la tua scelta.
## Configura la trasformazione dei dati utilizzando la AWS CLI
[In questo tutorial, creerai un'API incompleta e una tabella DynamoDB utilizzando il seguente file.zip .zip. data-transformation-tutorial-cli](samples/data-transformation-tutorial-cli.zip) Questa API incompleta dispone di una risorsa `/pets` con un metodo `GET` integrato con l'endpoint HTTP `http://petstore-demo-endpoint.execute-api.com/petstore/pets`. Verrà creato un metodo `POST` per connettersi a una tabella DynamoDB e si useranno modelli di mappatura per inserire dati in una tabella DynamoDB.
+ I dati di output verranno quindi trasformati in base al modello di mappatura in [Trasformazioni dei modelli di mappatura per REST APIs in API Gateway](models-mappings.md).
+ Verrà creato un metodo `POST` per consentire all'utente di pubblicare (`POST`) le informazioni sugli animali domestici in una tabella Amazon DynamoDB utilizzando un modello di mappatura.
**Per creare uno stack CloudFormation**
Scarica e decomprimi [il modello di creazione dell'app](samples/data-transformation-tutorial-cli.zip) per. CloudFormation
Per completare il tutorial seguente, è necessario disporre della [AWS Command Line Interface (AWS CLI) versione 2](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
Per i comandi lunghi viene utilizzato un carattere di escape (`\`) per dividere un comando su più righe.
**Nota**
In Windows, alcuni comandi della CLI Bash utilizzati comunemente (ad esempio, `zip`) non sono supportati dai terminali integrati del sistema operativo. Per ottenere una versione integrata su Windows di Ubuntu e Bash, [installa il sottosistema Windows per Linux](https://learn.microsoft.com/en-us/windows/wsl/install). I comandi della CLI di esempio in questa guida utilizzano la formattazione Linux. Se si utilizza la CLI di Windows, i comandi che includono documenti JSON in linea dovranno essere riformattati.
1. Usa il seguente comando per creare lo CloudFormation stack.
```
aws cloudformation create-stack --stack-name data-transformation-tutorial-cli --template-body file://data-transformation-tutorial-cli.zip --capabilities CAPABILITY_NAMED_IAM
```
1. CloudFormation fornisce le risorse specificate nel modello. Per completare il provisioning delle risorse, potrebbero essere necessari alcuni minuti. Usa il comando seguente per vedere lo stato del tuo CloudFormation stack.
```
aws cloudformation describe-stacks --stack-name data-transformation-tutorial-cli
```
1. Quando lo stato dello CloudFormation stack è`StackStatus: "CREATE_COMPLETE"`, usa il seguente comando per recuperare i valori di output pertinenti per i passaggi futuri.
```
aws cloudformation describe-stacks --stack-name data-transformation-tutorial-cli --query "Stacks[*].Outputs[*].{OutputKey: OutputKey, OutputValue: OutputValue, Description: Description}"
```
Di seguito sono riportati i valori di output:
+ ApiRole, che è il nome del ruolo che consente ad API Gateway di inserire elementi nella tabella DynamoDB. Per questo tutorial, il nome del ruolo è `data-transformation-tutorial-cli-APIGatewayRole-ABCDEFG`.
+ DDBTableNome, che è il nome della tabella DynamoDB. Per questo tutorial il nome della tabella è `data-transformation-tutorial-cli-ddb`.
+ ResourceId, che è l'ID della risorsa pets in cui sono esposti i `POST` metodi `GET` and. Per questo tutorial, l'ID risorsa è `efg456`.
+ ApiId, che è l'ID dell'API. Per questo tutorial, l'ID API è `abc123`.
**Test del metodo `GET` prima della trasformazione dei dati**
+ Utilizzare il seguente comando per eseguire il test del metodo `GET`.
```
aws apigateway test-invoke-method --rest-api-id abc123 \
--resource-id efg456 \
--http-method GET
```
L'output del test riporterà le seguenti informazioni.
```
[
{
"id": 1,
"type": "dog",
"price": 249.99
},
{
"id": 2,
"type": "cat",
"price": 124.99
},
{
"id": 3,
"type": "fish",
"price": 0.99
}
]
```
Questo output verrà trasformato in base al modello di mappatura in [Trasformazioni dei modelli di mappatura per REST APIs in API Gateway](models-mappings.md).
**Trasformazione della risposta di integrazione `GET`**
+ Utilizzare il comando seguente per aggiornare una risposta di integrazione per il metodo `GET`. Sostituisci *rest-api-id* e *resource-id* con i tuoi valori.
Per creare una risposta di integrazione, utilizzare il comando seguente.
```
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]"}'
```
**Test del metodo `GET`**
+ Utilizzare il seguente comando per eseguire il test del metodo `GET`.
```
aws apigateway test-invoke-method --rest-api-id abc123 \
--resource-id efg456 \
--http-method GET \
```
L'output del test mostrerà la risposta trasformata.
```
[
{
"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
}
]
```
**Creazione di un metodo `POST`**
1. Utilizzare il seguente comando per creare un nuovo metodo nella risorsa `/pets`.
```
aws apigateway put-method --rest-api-id abc123 \
--resource-id efg456 \
--http-method POST \
--authorization-type "NONE" \
```
Questo metodo ti consentirà di inviare informazioni sugli animali domestici alla tabella DynamoDB che hai creato nello stack. CloudFormation
1. Utilizzate il seguente comando per creare un' Servizio AWS integrazione sul metodo. `POST`
```
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. Utilizzare il comando seguente per creare una risposta del metodo per una corretta chiamata del metodo `POST`.
```
aws apigateway put-method-response --rest-api-id abc123 \
--resource-id efg456 \
--http-method POST \
--status-code 200
```
1. Utilizzare il comando seguente per creare una risposta dell'integrazione per una corretta chiamata del metodo `POST`.
```
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\"}"}'
```
**Test del metodo `POST`**
+ Utilizzare il seguente comando per eseguire il test del metodo `POST`.
```
aws apigateway test-invoke-method --rest-api-id abc123 \
--resource-id efg456 \
--http-method POST \
--body '{\"id\": \"4\", \"type\": \"dog\", \"price\": \"321\"}'
```
L'output mostrerà il messaggio di operazione riuscita.
**Per eliminare una CloudFormation pila**
+ Usa il seguente comando per eliminare le tue CloudFormation risorse.
```
aws cloudformation delete-stack --stack-name data-transformation-tutorial-cli
```
## CloudFormation Modello di trasformazione dei dati completato
L'esempio seguente è un CloudFormation modello completo, che crea un'API e una tabella DynamoDB con `/pets` una risorsa `GET` con metodi and. `POST`
+ Il metodo `GET` recupererà i dati dall'endpoint HTTP `http://petstore-demo-endpoint.execute-api.com/petstore/pets`. I dati di output verranno trasformati in base al modello di mappatura in [Trasformazioni dei modelli di mappatura per REST APIs in API Gateway](models-mappings.md).
+ Il metodo `POST` consentirà all'utente di pubblicare (`POST`) le informazioni sugli animali domestici in una tabella DynamoDB utilizzando un modello di mappatura.
### Modello di esempio CloudFormation
```
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
```