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à.
# Esempi di API Gateway utilizzando AWS CLI
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando AWS Command Line Interface with API Gateway.
Le *azioni* sono estratti di codice da programmi più grandi e devono essere eseguite nel contesto. Sebbene le azioni mostrino come richiamare le singole funzioni del servizio, è possibile visualizzarle contestualizzate negli scenari correlati.
Ogni esempio include un link al codice sorgente completo, in cui vengono fornite le istruzioni su come configurare ed eseguire il codice nel contesto.
**Topics**
+ [Azioni](#actions)
## Azioni
### `create-api-key`
Il seguente esempio di codice mostra come utilizzare`create-api-key`.
**AWS CLI**
**Come creare una chiave API abilitata per un’API e una fase esistenti**
Comando:
```
aws apigateway create-api-key --name 'Dev API Key' --description 'Used for development' --enabled --stage-keys restApiId='a1b2c3d4e5',stageName='dev'
```
+ Per i dettagli sull'API, consulta [CreateApiKey AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-api-key.html)*Command Reference*.
### `create-authorizer`
Il seguente esempio di codice mostra come utilizzare`create-authorizer`.
**AWS CLI**
**Esempio 1: come creare un sistema di autorizzazione personalizzato di Gateway API basato su token per l’API**
L’esempio `create-authorizer` seguente crea un sistema di autorizzazione basato su token.
```
aws apigateway create-authorizer \
--rest-api-id 1234123412 \
--name 'First_Token_Custom_Authorizer' \
--type TOKEN \
--authorizer-uri 'arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123412341234:function:customAuthFunction/invocations' \
--identity-source 'method.request.header.Authorization' \
--authorizer-result-ttl-in-seconds 300
```
Output:
```
{
"authType": "custom",
"name": "First_Token_Custom_Authorizer",
"authorizerUri": "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123412341234:function:customAuthFunction/invocations",
"authorizerResultTtlInSeconds": 300,
"identitySource": "method.request.header.Authorization",
"type": "TOKEN",
"id": "z40xj0"
}
```
**Esempio 2: come creare un sistema di autorizzazione personalizzato di Gateway API basato su pool di utenti Cognito per l’API**
L’esempio `create-authorizer` seguente crea un sistema di autorizzazione personalizzato per Gateway API basato su pool di utenti Cognito.
```
aws apigateway create-authorizer \
--rest-api-id 1234123412 \
--name 'First_Cognito_Custom_Authorizer' \
--type COGNITO_USER_POOLS \
--provider-arns 'arn:aws:cognito-idp:us-east-1:123412341234:userpool/us-east-1_aWcZeQbuD' \
--identity-source 'method.request.header.Authorization'
```
Output:
```
{
"authType": "cognito_user_pools",
"identitySource": "method.request.header.Authorization",
"name": "First_Cognito_Custom_Authorizer",
"providerARNs": [
"arn:aws:cognito-idp:us-east-1:342398297714:userpool/us-east-1_qWbZzQhzE"
],
"type": "COGNITO_USER_POOLS",
"id": "5yid1t"
}
```
**Esempio 3: come creare un sistema di autorizzazione personalizzato di Gateway API basato su richiesta per l’API**
L’esempio `create-authorizer` seguente crea un sistema di autorizzazione basato su richiesta.
```
aws apigateway create-authorizer \
--rest-api-id 1234123412 \
--name 'First_Request_Custom_Authorizer' \
--type REQUEST \
--authorizer-uri 'arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123412341234:function:customAuthFunction/invocations' \
--identity-source 'method.request.header.Authorization,context.accountId' \
--authorizer-result-ttl-in-seconds 300
```
Output:
```
{
"id": "z40xj0",
"name": "First_Request_Custom_Authorizer",
"type": "REQUEST",
"authType": "custom",
"authorizerUri": "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123412341234:function:customAuthFunction/invocations",
"identitySource": "method.request.header.Authorization,context.accountId",
"authorizerResultTtlInSeconds": 300
}
```
+ Per i dettagli sull'API, consulta [CreateAuthorizer AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-authorizer.html)*Command Reference*.
### `create-base-path-mapping`
Il seguente esempio di codice mostra come utilizzare`create-base-path-mapping`.
**AWS CLI**
**Come creare la mappatura del percorso di base per un nome di dominio personalizzato**
Comando:
```
aws apigateway create-base-path-mapping --domain-name subdomain.domain.tld --rest-api-id 1234123412 --stage prod --base-path v1
```
+ Per i dettagli sull'API, consulta [CreateBasePathMapping AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-base-path-mapping.html)*Command Reference*.
### `create-deployment`
Il seguente esempio di codice mostra come utilizzare`create-deployment`.
**AWS CLI**
**Come implementare le risorse configurate per un’API in una nuova fase**
Comando:
```
aws apigateway create-deployment --rest-api-id 1234123412 --stage-name dev --stage-description 'Development Stage' --description 'First deployment to the dev stage'
```
**Come implementare le risorse configurate per un’API in una fase esistente**
Comando:
```
aws apigateway create-deployment --rest-api-id 1234123412 --stage-name dev --description 'Second deployment to the dev stage'
```
**Come implementare le risorse configurate per un’API in una fase esistente con variabili di fase**
aws apigateway create-deployment -- rest-api-id 1234123412 --stage-name dev --description 'Terza implementazione nella fase di sviluppo' --variables key='value', otherKey='otherValue'
+ Per i dettagli sull'API [CreateDeployment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-deployment.html), vedi *AWS CLI in Command* Reference.
### `create-domain-name-access-association`
Il seguente esempio di codice mostra come utilizzare`create-domain-name-access-association`.
**AWS CLI**
**Come creare un’associazione di accesso al nome di dominio**
L’esempio `create-domain-name-access-association` seguente crea un’associazione di accesso al nome di dominio tra un nome di dominio privato personalizzato e l’endpoint VPC.
```
aws apigateway create-domain-name-access-association \
--domain-name-arn arn:aws:apigateway:us-west-2:111122223333:/domainnames/my.private.domain.tld+abcd1234 \
--access-association-source vpce-abcd1234efg \
--access-association-source-type VPCE
```
Output:
```
{
"domainNameAccessAssociationArn": "arn:aws:apigateway:us-west-2:012345678910:/domainnameaccessassociations/domainname/my.private.domain.tld/vpcesource/vpce-abcd1234efg
"accessAssociationSource": "vpce-abcd1234efg",
"accessAssociationSourceType": "VPCE",
"domainNameArn" : "arn:aws:apigateway:us-west-2:111122223333:/domainnames/private.example.com+abcd1234"
}
```
Per ulteriori informazioni, consulta [Nomi di dominio personalizzati per uso privato APIs in API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-custom-domains.html) nella *Amazon API Gateway Developer Guide*.
+ Per i dettagli sull'API, consulta [CreateDomainNameAccessAssociation AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-domain-name-access-association.html)*Command Reference*.
### `create-domain-name`
Il seguente esempio di codice mostra come utilizzare`create-domain-name`.
**AWS CLI**
**Esempio 1: come creare un nome di dominio pubblico personalizzato**
L’esempio `create-domain-name` seguente crea un nome di dominio pubblico personalizzato.
```
aws apigateway create-domain-name \
--domain-name 'my.domain.tld' \
--certificate-name 'my.domain.tld cert'\
--certificate-arn 'arn:aws:acm:us-east-1:012345678910:certificate/fb1b9770-a305-495d-aefb-27e5e101ff3'
```
Output:
```
{
"domainName": "my.domain.tld",
"certificateName": "my.domain.tld cert",
"certificateArn": "arn:aws:acm:us-east-1:012345678910:certificate/fb1b9770-a305-495d-aefb-27e5e101ff3",
"certificateUploadDate": "2024-10-08T11:29:49-07:00",
"distributionDomainName": "abcd1234.cloudfront.net",
"distributionHostedZoneId": "Z2FDTNDATAQYW2",
"endpointConfiguration": {
"types": [
"EDGE"
]
},
"domainNameStatus": "AVAILABLE",
"securityPolicy": "TLS_1_2"
}
```
Per ulteriori informazioni, consulta la sezione [Nome di dominio personalizzato per REST pubblico APIs in API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-custom-domains.html) nella *Amazon API Gateway Developer Guide*.
**Esempio 2: come creare un nome di dominio privato personalizzato**
L’esempio `create-domain-name` seguente crea un nome di dominio privato personalizzato.
```
aws apigateway create-domain-name \
--domain-name 'my.private.domain.tld' \
--certificate-name 'my.domain.tld cert' \
--certificate-arn 'arn:aws:acm:us-east-1:012345678910:certificate/fb1b9770-a305-495d-aefb-27e5e101ff3' \
--endpoint-configuration '{"types": ["PRIVATE"]}' \
--security-policy 'TLS_1_2' \
--policy file://policy.json
```
Contenuto di `policy.json`:
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": "*",
"Action": "execute-api:Invoke",
"Resource": [
"execute-api:/*"
]
},
{
"Effect": "Deny",
"Principal": "*",
"Action": "execute-api:Invoke",
"Resource": [
"execute-api:/*"
],
"Condition" : {
"StringNotEquals": {
"aws:SourceVpce": "vpce-abcd1234efg"
}
}
}
]
}
```
Output:
```
{
"domainName": "my.private.domain.tld",
"domainNameId": "abcd1234",
"domainNameArn": "arn:aws:apigateway:us-east-1:012345678910:/domainnames/my.private.domain.tld+abcd1234",
"certificateArn": "arn:aws:acm:us-east-1:012345678910:certificate/fb1b9770-a305-495d-aefb-27e5e101ff3",
"certificateUploadDate": "2024-09-10T10:31:20-07:00",
"endpointConfiguration": {
"types": [
"PRIVATE"
]
},
"domainNameStatus": "AVAILABLE",
"securityPolicy": "TLS_1_2",
"policy": "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Principal\":\"*\",\"Action\":\"execute-api:Invoke\",\"Resource\":\"arn:aws:execute-api:us-east-1:012345678910:/domainnames/my.private.domain.tld+abcd1234\"},{\"Effect\":\"Deny\",\"Principal\":\"*\",\"Action\":\"execute-api:Invoke\",\"Resource\":\"arn:aws:execute-api:us-east-1:012345678910:/domainnames/my.private.domain.tld+abcd1234\",\"Condition\":{\"StringNotEquals\":{\"aws:SourceVpc\":\"vpc-1a2b3c4d\"}}}]}"
}
```
Per ulteriori informazioni, consulta la sezione [Nome di dominio personalizzato per REST pubblico APIs in API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-custom-domains.html) nella *Amazon API Gateway Developer Guide*.
+ Per i dettagli sull'API, consulta [CreateDomainName AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-domain-name.html)*Command Reference*.
### `create-model`
Il seguente esempio di codice mostra come utilizzare`create-model`.
**AWS CLI**
**Come creare un modello per un’API**
Comando:
```
aws apigateway create-model --rest-api-id 1234123412 --name 'firstModel' --description 'The First Model' --content-type 'application/json' --schema '{ "$schema": "http://json-schema.org/draft-04/schema#", "title": "firstModel", "type": "object", "properties": { "firstProperty" : { "type": "object", "properties": { "key": { "type": "string" } } } } }'
```
Output:
```
{
"contentType": "application/json",
"description": "The First Model",
"name": "firstModel",
"id": "2rzg0l",
"schema": "{ \"$schema\": \"http://json-schema.org/draft-04/schema#\", \"title\": \"firstModel\", \"type\": \"object\", \"properties\": { \"firstProperty\" : { \"type\": \"object\", \"properties\": { \"key\": { \"type\": \"string\" } } } } }"
}
```
+ Per i dettagli sull'API, consulta [CreateModel AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-model.html)*Command Reference*.
### `create-resource`
Il seguente esempio di codice mostra come utilizzare`create-resource`.
**AWS CLI**
**Come creare una risorsa in un’API**
Comando:
```
aws apigateway create-resource --rest-api-id 1234123412 --parent-id a1b2c3 --path-part 'new-resource'
```
+ Per i dettagli sull'API, consulta [CreateResource AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-resource.html)*Command Reference*.
### `create-rest-api`
Il seguente esempio di codice mostra come utilizzare`create-rest-api`.
**AWS CLI**
**Come creare un’API**
Comando:
```
aws apigateway create-rest-api --name 'My First API' --description 'This is my first API'
```
**Come creare un’API duplicata da un’API esistente**
Comando:
```
aws apigateway create-rest-api --name 'Copy of My First API' --description 'This is a copy of my first API' --clone-from 1234123412
```
+ Per i dettagli sull'API, consulta [CreateRestApi AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-rest-api.html)*Command Reference*.
### `create-stage`
Il seguente esempio di codice mostra come utilizzare`create-stage`.
**AWS CLI**
**Come creare una fase in un’API che conterrà un’implementazione esistente**
Comando:
```
aws apigateway create-stage --rest-api-id 1234123412 --stage-name 'dev' --description 'Development stage' --deployment-id a1b2c3
```
**Come creare una fase in un’API che conterrà un’implementazione esistente e variabili di fase personalizzate**
Comando:
```
aws apigateway create-stage --rest-api-id 1234123412 --stage-name 'dev' --description 'Development stage' --deployment-id a1b2c3 --variables key='value',otherKey='otherValue'
```
+ Per i dettagli sull'API, consulta [CreateStage AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-stage.html)*Command Reference*.
### `create-usage-plan-key`
Il seguente esempio di codice mostra come utilizzare`create-usage-plan-key`.
**AWS CLI**
**Come associare una chiave API esistente a un piano di utilizzo**
Comando:
```
aws apigateway create-usage-plan-key --usage-plan-id a1b2c3 --key-type "API_KEY" --key-id 4vq3yryqm5
```
+ Per i dettagli sull'API, consulta [CreateUsagePlanKey AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-usage-plan-key.html)*Command Reference*.
### `create-usage-plan`
Il seguente esempio di codice mostra come utilizzare`create-usage-plan`.
**AWS CLI**
**Come creare un piano di utilizzo con limiti di quota e di velocità di elaborazione delle richieste che viene reimpostato a inizio mese**
Comando:
```
aws apigateway create-usage-plan --name "New Usage Plan" --description "A new usage plan" --throttle burstLimit=10,rateLimit=5 --quota limit=500,offset=0,period=MONTH
```
+ Per i dettagli sull'API, consulta [CreateUsagePlan AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-usage-plan.html)*Command Reference*.
### `delete-api-key`
Il seguente esempio di codice mostra come utilizzare`delete-api-key`.
**AWS CLI**
**Come eliminare una chiave API**
Comando:
```
aws apigateway delete-api-key --api-key 8bklk8bl1k3sB38D9B3l0enyWT8c09B30lkq0blk
```
+ Per i dettagli sull'API, consulta [DeleteApiKey AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-api-key.html)*Command Reference*.
### `delete-authorizer`
Il seguente esempio di codice mostra come utilizzare`delete-authorizer`.
**AWS CLI**
**Come eliminare un sistema di autorizzazione personalizzato in un’API**
Comando:
```
aws apigateway delete-authorizer --rest-api-id 1234123412 --authorizer-id 7gkfbo
```
+ Per i dettagli sull'API, consulta [DeleteAuthorizer AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-authorizer.html)*Command Reference*.
### `delete-base-path-mapping`
Il seguente esempio di codice mostra come utilizzare`delete-base-path-mapping`.
**AWS CLI**
**Come eliminare una mappatura del percorso di base per un nome di dominio personalizzato**
Comando:
```
aws apigateway delete-base-path-mapping --domain-name 'api.domain.tld' --base-path 'dev'
```
+ Per i dettagli sull'API, consulta [DeleteBasePathMapping AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-base-path-mapping.html)*Command Reference*.
### `delete-client-certificate`
Il seguente esempio di codice mostra come utilizzare`delete-client-certificate`.
**AWS CLI**
**Come eliminare un certificato client**
Comando:
```
aws apigateway delete-client-certificate --client-certificate-id a1b2c3
```
+ Per i dettagli sull'API, consulta [DeleteClientCertificate AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-client-certificate.html)*Command Reference*.
### `delete-deployment`
Il seguente esempio di codice mostra come utilizzare`delete-deployment`.
**AWS CLI**
**Come eliminare un’implementazione in un’API**
Comando:
```
aws apigateway delete-deployment --rest-api-id 1234123412 --deployment-id a1b2c3
```
+ Per i dettagli sull'API, consulta [DeleteDeployment AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-deployment.html)*Command Reference*.
### `delete-domain-name-access-association`
Il seguente esempio di codice mostra come utilizzare`delete-domain-name-access-association`.
**AWS CLI**
**Come eliminare un’associazione di accesso al nome di dominio**
L’esempio `delete-domain-name-access-association` seguente elimina un’associazione di accesso al nome di dominio tra un nome di dominio privato personalizzato e l’endpoint VPC.
```
aws apigateway delete-domain-name-access-association \
--domain-name-access-association-arn arn:aws:apigateway:us-west-2:012345678910:/domainnameaccessassociations/domainname/my.private.domain.tld/vpcesource/vpce-abcd1234efg
```
Questo comando non produce alcun output.
Per ulteriori informazioni, consulta [Nomi di dominio personalizzati per uso privato APIs in API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-custom-domains.html) nella *Amazon API Gateway Developer Guide*.
+ Per i dettagli sull'API, consulta [DeleteDomainNameAccessAssociation AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-domain-name-access-association.html)*Command Reference*.
### `delete-domain-name`
Il seguente esempio di codice mostra come utilizzare`delete-domain-name`.
**AWS CLI**
**Come eliminare un nome di dominio personalizzato**
Comando:
```
aws apigateway delete-domain-name --domain-name 'api.domain.tld'
```
+ Per i dettagli sull'API, consulta [DeleteDomainName AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-domain-name.html)*Command Reference*.
### `delete-integration-response`
Il seguente esempio di codice mostra come utilizzare`delete-integration-response`.
**AWS CLI**
**Come eliminare una risposta di integrazione per una risorsa, un metodo e un codice di stato specificati in un’API**
Comando:
```
aws apigateway delete-integration-response --rest-api-id 1234123412 --resource-id a1b2c3 --http-method GET --status-code 200
```
+ Per i dettagli sull'API, consulta [DeleteIntegrationResponse AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-integration-response.html)*Command Reference*.
### `delete-integration`
Il seguente esempio di codice mostra come utilizzare`delete-integration`.
**AWS CLI**
**Come eliminare un’integrazione per una risorsa e un metodo specificati in un’API**
Comando:
```
aws apigateway delete-integration --rest-api-id 1234123412 --resource-id a1b2c3 --http-method GET
```
+ Per i dettagli sull'API, consulta [DeleteIntegration AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-integration.html)*Command Reference*.
### `delete-method-response`
Il seguente esempio di codice mostra come utilizzare`delete-method-response`.
**AWS CLI**
**Come eliminare una risposta del metodo per la risorsa, il metodo e il codice di stato specificati in un’API**
Comando:
```
aws apigateway delete-method-response --rest-api-id 1234123412 --resource-id a1b2c3 --http-method GET --status-code 200
```
+ Per i dettagli sull'API, consulta [DeleteMethodResponse AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-method-response.html)*Command Reference*.
### `delete-method`
Il seguente esempio di codice mostra come utilizzare`delete-method`.
**AWS CLI**
**Come eliminare un metodo per la risorsa specificata in un’API**
Comando:
```
aws apigateway delete-method --rest-api-id 1234123412 --resource-id a1b2c3 --http-method GET
```
+ Per i dettagli sull'API, consulta [DeleteMethod AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-method.html)*Command Reference*.
### `delete-model`
Il seguente esempio di codice mostra come utilizzare`delete-model`.
**AWS CLI**
**Come eliminare un modello nell’API specificata**
Comando:
```
aws apigateway delete-model --rest-api-id 1234123412 --model-name 'customModel'
```
+ Per i dettagli sull'API, consulta [DeleteModel AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-model.html)*Command Reference*.
### `delete-resource`
Il seguente esempio di codice mostra come utilizzare`delete-resource`.
**AWS CLI**
**Come eliminare una risorsa in un’API**
Comando:
```
aws apigateway delete-resource --rest-api-id 1234123412 --resource-id a1b2c3
```
+ Per i dettagli sull'API, consulta [DeleteResource AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-resource.html)*Command Reference*.
### `delete-rest-api`
Il seguente esempio di codice mostra come utilizzare`delete-rest-api`.
**AWS CLI**
**Come eliminare un’API**
Comando:
```
aws apigateway delete-rest-api --rest-api-id 1234123412
```
+ Per i dettagli sull'API, consulta [DeleteRestApi AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-rest-api.html)*Command Reference*.
### `delete-stage`
Il seguente esempio di codice mostra come utilizzare`delete-stage`.
**AWS CLI**
**Come eliminare una fase in un’API**
Comando:
```
aws apigateway delete-stage --rest-api-id 1234123412 --stage-name 'dev'
```
+ Per i dettagli sull'API, consulta [DeleteStage AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-stage.html)*Command Reference*.
### `delete-usage-plan-key`
Il seguente esempio di codice mostra come utilizzare`delete-usage-plan-key`.
**AWS CLI**
**Come rimuovere una chiave API da un piano di utilizzo**
Comando:
```
aws apigateway delete-usage-plan-key --usage-plan-id a1b2c3 --key-id 1NbjQzMReAkeEQPNAW8r3dXsU2rDD7fc7f2Sipnu
```
+ Per i dettagli sull'API, consulta [DeleteUsagePlanKey AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-usage-plan-key.html)*Command Reference*.
### `delete-usage-plan`
Il seguente esempio di codice mostra come utilizzare`delete-usage-plan`.
**AWS CLI**
**Come eliminare un piano di utilizzo**
Comando:
```
aws apigateway delete-usage-plan --usage-plan-id a1b2c3
```
+ Per i dettagli sull'API, consulta [DeleteUsagePlan AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-usage-plan.html)*Command Reference*.
### `flush-stage-authorizers-cache`
Il seguente esempio di codice mostra come utilizzare`flush-stage-authorizers-cache`.
**AWS CLI**
**Come scaricare l’intera cache del sistema di autorizzazione in una fase**
Comando:
```
aws apigateway flush-stage-authorizers-cache --rest-api-id 1234123412 --stage-name dev
```
+ Per i dettagli sull'API, consulta [FlushStageAuthorizersCache AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/flush-stage-authorizers-cache.html)*Command Reference*.
### `flush-stage-cache`
Il seguente esempio di codice mostra come utilizzare`flush-stage-cache`.
**AWS CLI**
**Come scaricare la cache per una fase dell’API**
L’esempio `flush-stage-cache` seguente scarica la cache di una fase.
```
aws apigateway flush-stage-cache \
--rest-api-id 1234123412 \
--stage-name dev
```
Questo comando non produce alcun output.
Per ulteriori informazioni, consulta [Scaricare la cache della fase API in Gateway API](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-caching.html#flush-api-caching) nella *Guida per gli sviluppatori di Gateway Amazon API*.
+ Per i dettagli sull'API, consulta [FlushStageCache AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/flush-stage-cache.html)*Command Reference*.
### `generate-client-certificate`
Il seguente esempio di codice mostra come utilizzare`generate-client-certificate`.
**AWS CLI**
**Come creare un certificato SSL lato client**
Comando:
```
aws apigateway generate-client-certificate --description 'My First Client Certificate'
```
+ Per i dettagli sull'API, consulta [GenerateClientCertificate AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/generate-client-certificate.html)*Command Reference*.
### `get-account`
Il seguente esempio di codice mostra come utilizzare`get-account`.
**AWS CLI**
**Come ottenere le impostazioni dell’account Gateway API**
Comando:
```
aws apigateway get-account
```
Output:
```
{
"cloudwatchRoleArn": "arn:aws:iam::123412341234:role/APIGatewayToCloudWatchLogsRole",
"throttleSettings": {
"rateLimit": 500.0,
"burstLimit": 1000
}
}
```
+ Per i dettagli sull'API, consulta [GetAccount AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-account.html)*Command Reference*.
### `get-api-key`
Il seguente esempio di codice mostra come utilizzare`get-api-key`.
**AWS CLI**
**Come recuperare le informazioni su una chiave API specifica**
Comando:
```
aws apigateway get-api-key --api-key 8bklk8bl1k3sB38D9B3l0enyWT8c09B30lkq0blk
```
Output:
```
{
"description": "My first key",
"enabled": true,
"stageKeys": [
"a1b2c3d4e5/dev",
"e5d4c3b2a1/dev"
],
"lastUpdatedDate": 1456184515,
"createdDate": 1456184452,
"id": "8bklk8bl1k3sB38D9B3l0enyWT8c09B30lkq0blk",
"name": "My key"
}
```
+ Per i dettagli sull'API, consulta [GetApiKey AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-api-key.html)*Command Reference*.
### `get-api-keys`
Il seguente esempio di codice mostra come utilizzare`get-api-keys`.
**AWS CLI**
**Come ottenere l’elenco delle chiavi API**
Comando:
```
aws apigateway get-api-keys
```
Output:
```
{
"items": [
{
"description": "My first key",
"enabled": true,
"stageKeys": [
"a1b2c3d4e5/dev",
"e5d4c3b2a1/dev"
],
"lastUpdatedDate": 1456184515,
"createdDate": 1456184452,
"id": "8bklk8bl1k3sB38D9B3l0enyWT8c09B30lkq0blk",
"name": "My key"
}
]
}
```
+ Per i dettagli sull'API, consulta [GetApiKeys AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-api-keys.html)*Command Reference*.
### `get-authorizer`
Il seguente esempio di codice mostra come utilizzare`get-authorizer`.
**AWS CLI**
**Come ottenere le impostazioni del sistema di autorizzazione per API di Gateway API**
Comando:
```
aws apigateway get-authorizer --rest-api-id 1234123412 --authorizer-id gfi4n3
```
Output:
```
{
"authorizerResultTtlInSeconds": 300,
"name": "MyAuthorizer",
"type": "TOKEN",
"identitySource": "method.request.header.Authorization",
"authorizerUri": "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123412341234:function:authorizer_function/invocations",
"id": "gfi4n3"
}
```
+ Per i dettagli sull'API, consulta [GetAuthorizer AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-authorizer.html)*Command Reference*.
### `get-authorizers`
Il seguente esempio di codice mostra come utilizzare`get-authorizers`.
**AWS CLI**
**Come ottenere l’elenco dei sistemi di autorizzazione per una REST API**
Comando:
```
aws apigateway get-authorizers --rest-api-id 1234123412
```
Output:
```
{
"items": [
{
"name": "MyAuthorizer",
"authorizerUri": "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123412341234:function:My_Authorizer_Function/invocations",
"authorizerResultTtlInSeconds": 300,
"identitySource": "method.request.header.Authorization",
"type": "TOKEN",
"id": "gfi4n3"
}
]
}
```
+ Per i dettagli sull'API, consulta [GetAuthorizers AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-authorizers.html)*Command Reference*.
### `get-base-path-mapping`
Il seguente esempio di codice mostra come utilizzare`get-base-path-mapping`.
**AWS CLI**
**Come ottenere la mappatura del percorso di base per un nome di dominio personalizzato**
Comando:
```
aws apigateway get-base-path-mapping --domain-name subdomain.domain.tld --base-path v1
```
Output:
```
{
"basePath": "v1",
"restApiId": "1234w4321e",
"stage": "api"
}
```
+ Per i dettagli sull'API, consulta [GetBasePathMapping AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-base-path-mapping.html)*Command Reference*.
### `get-base-path-mappings`
Il seguente esempio di codice mostra come utilizzare`get-base-path-mappings`.
**AWS CLI**
**Come ottenere le mappature del percorso di base per un nome di dominio personalizzato**
Comando:
```
aws apigateway get-base-path-mappings --domain-name subdomain.domain.tld
```
Output:
```
{
"items": [
{
"basePath": "(none)",
"restApiId": "1234w4321e",
"stage": "dev"
},
{
"basePath": "v1",
"restApiId": "1234w4321e",
"stage": "api"
}
]
}
```
+ Per i dettagli sull'API, consulta [GetBasePathMappings AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-base-path-mappings.html)*Command Reference*.
### `get-client-certificate`
Il seguente esempio di codice mostra come utilizzare`get-client-certificate`.
**AWS CLI**
**Come ottenere un certificato client**
Comando:
```
aws apigateway get-client-certificate --client-certificate-id a1b2c3
```
+ Per i dettagli sull'API, consulta [GetClientCertificate AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-client-certificate.html)*Command Reference*.
### `get-client-certificates`
Il seguente esempio di codice mostra come utilizzare`get-client-certificates`.
**AWS CLI**
**Come ottenere un elenco di certificati client**
Comando:
```
aws apigateway get-client-certificates
```
Output:
```
{
"items": [
{
"pemEncodedCertificate": "-----BEGIN CERTIFICATE----- -----END CERTIFICATE-----",
"clientCertificateId": "a1b2c3",
"expirationDate": 1483556561,
"description": "My Client Certificate",
"createdDate": 1452020561
}
]
}
```
+ Per i dettagli sull'API, consulta [GetClientCertificates AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-client-certificates.html)*Command Reference*.
### `get-deployment`
Il seguente esempio di codice mostra come utilizzare`get-deployment`.
**AWS CLI**
**Come ottenere informazioni su un’implementazione**
Comando:
```
aws apigateway get-deployment --rest-api-id 1234123412 --deployment-id ztt4m2
```
Output:
```
{
"description": "myDeployment",
"id": "ztt4m2",
"createdDate": 1455218022
}
```
+ Per i dettagli sull'API, consulta [GetDeployment AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-deployment.html)*Command Reference*.
### `get-deployments`
Il seguente esempio di codice mostra come utilizzare`get-deployments`.
**AWS CLI**
**Come ottenere un elenco di implementazioni per una REST API**
Comando:
```
aws apigateway get-deployments --rest-api-id 1234123412
```
Output:
```
{
"items": [
{
"createdDate": 1453797217,
"id": "0a2b4c",
"description": "Deployed my API for the first time"
}
]
}
```
+ Per i dettagli sull'API, consulta [GetDeployments AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-deployments.html)*Command Reference*.
### `get-domain-name-access-associations`
Il seguente esempio di codice mostra come utilizzare`get-domain-name-access-associations`.
**AWS CLI**
**Esempio 1: come elencare tutte le associazioni di accesso ai nomi di dominio**
L’esempio `get-domain-name-access-associations` seguente mostra come elencare tutte le associazioni di accesso ai nomi di dominio.
```
aws apigateway get-domain-name-access-associations
```
Output:
```
{
"items": [
{
"domainNameAccessAssociationArn": "arn:aws:apigateway:us-west-2:012345678910:/domainnameaccessassociations/domainname/my.private.domain.tld/vpcesource/vpce-abcd1234efg
"accessAssociationSource": "vpce-abcd1234efg",
"accessAssociationSourceType": "VPCE",
"domainNameArn" : "arn:aws:apigateway:us-west-2:111122223333:/domainnames/private.example.com+abcd1234"
}
]
}
```
Per ulteriori informazioni, consulta [Nomi di dominio personalizzati per uso privato APIs in API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-custom-domains.html) nella *Amazon API Gateway Developer Guide*.
**Esempio 2: per elencare tutte le associazioni di accesso ai nomi di dominio di proprietà di questo AWS account**
L'`get-domain-name-access-associations`esempio seguente elenca tutte le associazioni di accesso ai nomi di dominio di proprietà dell' AWS account corrente.
```
aws apigateway get-domain-name-access-associations \
--resource-owner SELF
```
Output:
```
{
"items": [
{
"domainNameAccessAssociationArn": "arn:aws:apigateway:us-west-2:012345678910:/domainnameaccessassociations/domainname/my.private.domain.tld/vpcesource/vpce-abcd1234efg
"accessAssociationSource": "vpce-abcd1234efg",
"accessAssociationSourceType": "VPCE",
"domainNameArn" : "arn:aws:apigateway:us-west-2:111122223333:/domainnames/private.example.com+abcd1234"
}
]
}
```
Per ulteriori informazioni, consulta [Nomi di dominio personalizzati per uso privato APIs in API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-custom-domains.html) nella *Amazon API Gateway Developer Guide*.
+ Per i dettagli sull'API, consulta [GetDomainNameAccessAssociations AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-domain-name-access-associations.html)*Command Reference*.
### `get-domain-name`
Il seguente esempio di codice mostra come utilizzare`get-domain-name`.
**AWS CLI**
**Esempio 1: come ottenere informazioni su un nome di dominio pubblico personalizzato**
L’esempio `get-domain-name` seguente ottiene informazioni su un nome di dominio pubblico personalizzato.
```
aws apigateway get-domain-name \
--domain-name api.domain.tld
```
Output:
```
{
"domainName": "api.domain.tld",
"distributionDomainName": "d1a2f3a4c5o6d.cloudfront.net",
"certificateName": "uploadedCertificate",
"certificateUploadDate": 1462565487
}
```
Per ulteriori informazioni, consulta la sezione [Nome di dominio personalizzato per REST pubblico APIs in API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-custom-domains.html) nella *Amazon API Gateway Developer Guide*.
**Esempio 2: come ottenere informazioni su un nome di dominio privato personalizzato**
L’esempio `get-domain-name` seguente ottiene informazioni su un nome di dominio privato personalizzato.
```
aws apigateway get-domain-name \
--domain-name api.private.domain.tld \
--domain-name-id abcd1234
```
Output:
```
{
"domainName": "my.private.domain.tld",
"domainNameId": "abcd1234",
"domainNameArn": "arn:aws:apigateway:us-east-1:012345678910:/domainnames/my.private.domain.tld+abcd1234",
"certificateArn": "arn:aws:acm:us-east-1:012345678910:certificate/fb1b9770-a305-495d-aefb-27e5e101ff3",
"certificateUploadDate": "2024-09-10T10:31:20-07:00",
"endpointConfiguration": {
"types": [
"PRIVATE"
]
},
"domainNameStatus": "AVAILABLE",
"securityPolicy": "TLS_1_2",
"policy": "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Principal\":\"*\",\"Action\":\"execute-api:Invoke\",\"Resource\":\"arn:aws:execute-api:us-east-1:012345678910:/domainnames/my.private.domain.tld+abcd1234\"},{\"Effect\":\"Deny\",\"Principal\":\"*\",\"Action\":\"execute-api:Invoke\",\"Resource\":\"arn:aws:execute-api:us-east-1:012345678910:/domainnames/my.private.domain.tld+abcd1234\",\"Condition\":{\"StringNotEquals\":{\"aws:SourceVpc\":\"vpc-1a2b3c4d\"}}}]}"
}
```
Per ulteriori informazioni, consulta la sezione [Nome di dominio personalizzato per REST pubblico APIs in API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-custom-domains.html) nella *Amazon API Gateway Developer Guide*.
+ Per i dettagli sull'API, consulta [GetDomainName AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-domain-name.html)*Command Reference*.
### `get-domain-names`
Il seguente esempio di codice mostra come utilizzare`get-domain-names`.
**AWS CLI**
**Esempio 1: come ottenere un elenco di nomi di dominio personalizzati**
Il comando `get-domain-names` seguente ottiene un elenco di nomi di dominio.
```
aws apigateway get-domain-names
```
Output:
```
{
"items": [
{
"distributionDomainName": "d9511k3l09bkd.cloudfront.net",
"certificateUploadDate": 1452812505,
"certificateName": "my_custom_domain-certificate",
"domainName": "subdomain.domain.tld"
}
]
}
```
Per ulteriori informazioni, consulta [Nomi di dominio personalizzati per uso privato APIs in API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-custom-domains.html) nella *Amazon API Gateway Developer Guide*.
**Esempio 2: per ottenere un elenco di nomi di dominio personalizzati di proprietà di questo AWS account**
Il `get-domain-names` comando seguente ottiene un elenco di nomi di dominio di proprietà di questo AWS account.
```
aws apigateway get-domain-names \
--resource-owner SELF
```
Output:
```
{
"items": [
{
"domainName": "my.domain.tld",
"domainNameArn": "arn:aws:apigateway:us-east-1::/domainnames/my.private.domain.tld",
"certificateUploadDate": "2024-08-15T17:02:55-07:00",
"regionalDomainName": "d-abcd1234.execute-api.us-east-1.amazonaws.com",
"regionalHostedZoneId": "Z1UJRXOUMOOFQ8",
"regionalCertificateArn": "arn:aws:acm:us-east-1:012345678910:certificate/fb1b9770-a305-495d-aefb-27e5e101ff3",
"endpointConfiguration": {
"types": [
"REGIONAL"
]
},
"domainNameStatus": "AVAILABLE",
"securityPolicy": "TLS_1_2"
},
{
"domainName": "my.private.domain.tld",
"domainNameId": "abcd1234",
"domainNameArn": "arn:aws:apigateway:us-east-1:012345678910:/domainnames/my.private.domain.tld+abcd1234",
"certificateArn": "arn:aws:acm:us-east-1:012345678910:certificate/fb1b9770-a305-495d-aefb-27e5e101ff3",
"certificateUploadDate": "2024-11-26T11:44:40-08:00",
"endpointConfiguration": {
"types": [
"PRIVATE"
]
},
"domainNameStatus": "AVAILABLE",
"securityPolicy": "TLS_1_2"
}
]
}
```
Per ulteriori informazioni, consulta [Nomi di dominio personalizzati per uso privato APIs in API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-custom-domains.html) nella *Amazon API Gateway Developer Guide*.
**Esempio 3: per ottenere un elenco di nomi di dominio personalizzati di proprietà di altri AWS account con cui puoi creare un'associazione di accesso ai nomi di dominio.**
Il `get-domain-names` comando seguente ottiene un elenco di nomi di dominio di proprietà di altri AWS account a cui si ha accesso per creare un'associazione di accesso ai nomi di dominio.
```
aws apigateway get-domain-names \
--resource-owner OTHER_ACCOUNTS
```
Output:
```
{
"items": [
{
"domainName": "my.private.domain.tld",
"domainNameId": "abcd1234",
"domainNameArn": "arn:aws:apigateway:us-east-1:012345678910:/domainnames/my.private.domain.tld+abcd1234"
}
]
}
```
Per ulteriori informazioni, consulta [Nomi di dominio personalizzati per uso privato APIs in API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-custom-domains.html) nella *Amazon API Gateway Developer Guide*.
+ Per i dettagli sull'API, consulta [GetDomainNames AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-domain-names.html)*Command Reference*.
### `get-export`
Il seguente esempio di codice mostra come utilizzare`get-export`.
**AWS CLI**
**Come ottenere il modello Swagger JSON per una fase**
Comando:
```
aws apigateway get-export --rest-api-id a1b2c3d4e5 --stage-name dev --export-type swagger /path/to/filename.json
```
**Per ottenere il modello JSON Swagger \$1 API Gateway Extensions per una fase**
Comando:
```
aws apigateway get-export --parameters extensions='integrations' --rest-api-id a1b2c3d4e5 --stage-name dev --export-type swagger /path/to/filename.json
```
**Come ottenere il modello Swagger JSON e le estensioni di Postman per una fase**
Comando:
```
aws apigateway get-export --parameters extensions='postman' --rest-api-id a1b2c3d4e5 --stage-name dev --export-type swagger /path/to/filename.json
```
+ *Per i dettagli sull'API, consulta Command [GetExport](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-export.html)Reference AWS CLI .*
### `get-integration-response`
Il seguente esempio di codice mostra come utilizzare`get-integration-response`.
**AWS CLI**
**Come ottenere la configurazione della risposta di integrazione per un metodo HTTP definito nella risorsa di una REST API**
Comando:
```
aws apigateway get-integration-response --rest-api-id 1234123412 --resource-id y9h6rt --http-method GET --status-code 200
```
Output:
```
{
"statusCode": "200",
"responseTemplates": {
"application/json": null
}
}
```
+ Per i dettagli sull'API, consulta [GetIntegrationResponse AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-integration-response.html)*Command Reference*.
### `get-integration`
Il seguente esempio di codice mostra come utilizzare`get-integration`.
**AWS CLI**
**Come ottenere la configurazione dell’integrazione per un metodo HTTP definito nella risorsa di una REST API**
Comando:
```
aws apigateway get-integration --rest-api-id 1234123412 --resource-id y9h6rt --http-method GET
```
Output:
```
{
"httpMethod": "POST",
"integrationResponses": {
"200": {
"responseTemplates": {
"application/json": null
},
"statusCode": "200"
}
},
"cacheKeyParameters": [],
"type": "AWS",
"uri": "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123412341234:function:My_Function/invocations",
"cacheNamespace": "y9h6rt"
}
```
+ Per i dettagli sull'API, consulta [GetIntegration AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-integration.html)*Command Reference*.
### `get-method-response`
Il seguente esempio di codice mostra come utilizzare`get-method-response`.
**AWS CLI**
**Come ottenere la configurazione della risorsa di risposta del metodo per un metodo HTTP definito nella risorsa di una REST API**
Comando:
```
aws apigateway get-method-response --rest-api-id 1234123412 --resource-id y9h6rt --http-method GET --status-code 200
```
Output:
```
{
"responseModels": {
"application/json": "Empty"
},
"statusCode": "200"
}
```
+ Per i dettagli sull'API, consulta [GetMethodResponse AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-method-response.html)*Command Reference*.
### `get-method`
Il seguente esempio di codice mostra come utilizzare`get-method`.
**AWS CLI**
**Come ottenere la configurazione della risorsa del metodo per un metodo HTTP definito nella risorsa di una REST API**
Comando:
```
aws apigateway get-method --rest-api-id 1234123412 --resource-id y9h6rt --http-method GET
```
Output:
```
{
"apiKeyRequired": false,
"httpMethod": "GET",
"methodIntegration": {
"integrationResponses": {
"200": {
"responseTemplates": {
"application/json": null
},
"statusCode": "200"
}
},
"cacheKeyParameters": [],
"uri": "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123412341234:function:My_Function/invocations",
"httpMethod": "POST",
"cacheNamespace": "y9h6rt",
"type": "AWS"
},
"requestParameters": {},
"methodResponses": {
"200": {
"responseModels": {
"application/json": "Empty"
},
"statusCode": "200"
}
},
"authorizationType": "NONE"
}
```
+ Per i dettagli sull'API, consulta [GetMethod AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-method.html)*Command Reference*.
### `get-model-template`
Il seguente esempio di codice mostra come utilizzare`get-model-template`.
**AWS CLI**
**Come ottenere il modello di mappatura per un modello definito in una REST API**
Comando:
```
aws apigateway get-model-template --rest-api-id 1234123412 --model-name Empty
```
Output:
```
{
"value": "#set($inputRoot = $input.path('$'))\n{ }"
}
```
+ Per i dettagli sull'API, consulta [GetModelTemplate AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-model-template.html)*Command Reference*.
### `get-model`
Il seguente esempio di codice mostra come utilizzare`get-model`.
**AWS CLI**
**Come ottenere la configurazione per un modello definito in una REST API**
Comando:
```
aws apigateway get-model --rest-api-id 1234123412 --model-name Empty
```
Output:
```
{
"contentType": "application/json",
"description": "This is a default empty schema model",
"name": "Empty",
"id": "etd5w5",
"schema": "{\n \"$schema\": \"http://json-schema.org/draft-04/schema#\",\n \"title\" : \"Empty Schema\",\n \"type\" : \"object\"\n}"
}
```
+ Per i dettagli sull'API, consulta [GetModel AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-model.html)*Command Reference*.
### `get-models`
Il seguente esempio di codice mostra come utilizzare`get-models`.
**AWS CLI**
**Come ottenere un elenco di modelli per una REST API**
Comando:
```
aws apigateway get-models --rest-api-id 1234123412
```
Output:
```
{
"items": [
{
"description": "This is a default error schema model",
"schema": "{\n \"$schema\" : \"http://json-schema.org/draft-04/schema#\",\n \"title\" : \"Error Schema\",\n \"type\" : \"object\",\n \"properties\" : {\n \"message\" : { \"type\" : \"string\" }\n }\n}",
"contentType": "application/json",
"id": "7tpbze",
"name": "Error"
},
{
"description": "This is a default empty schema model",
"schema": "{\n \"$schema\": \"http://json-schema.org/draft-04/schema#\",\n \"title\" : \"Empty Schema\",\n \"type\" : \"object\"\n}",
"contentType": "application/json",
"id": "etd5w5",
"name": "Empty"
}
]
}
```
+ Per i dettagli sull'API, consulta [GetModels AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-models.html)*Command Reference*.
### `get-resource`
Il seguente esempio di codice mostra come utilizzare`get-resource`.
**AWS CLI**
**Come ottenere informazioni su una risorsa**
Comando:
```
aws apigateway get-resource --rest-api-id 1234123412 --resource-id zwo0y3
```
Output:
```
{
"path": "/path",
"pathPart": "path",
"id": "zwo0y3",
"parentId": "uyokt6ij2g"
}
```
+ Per i dettagli sull'API, consulta [GetResource AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-resource.html)*Command Reference*.
### `get-resources`
Il seguente esempio di codice mostra come utilizzare`get-resources`.
**AWS CLI**
**Come ottenere un elenco di risorse per una REST API**
Comando:
```
aws apigateway get-resources --rest-api-id 1234123412
```
Output:
```
{
"items": [
{
"path": "/resource/subresource",
"resourceMethods": {
"POST": {}
},
"id": "024ace",
"pathPart": "subresource",
"parentId": "ai5b02"
}
]
}
```
+ Per i dettagli sull'API, consulta [GetResources AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-resources.html)*Command Reference*.
### `get-rest-api`
Il seguente esempio di codice mostra come utilizzare`get-rest-api`.
**AWS CLI**
**Come ottenere informazioni su un’API**
Comando:
```
aws apigateway get-rest-api --rest-api-id 1234123412
```
Output:
```
{
"name": "myAPI",
"id": "o1y243m4f5",
"createdDate": 1453416433
}
```
+ Per i dettagli sull'API, consulta [GetRestApi AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-rest-api.html)*Command Reference*.
### `get-rest-apis`
Il seguente esempio di codice mostra come utilizzare`get-rest-apis`.
**AWS CLI**
**Per ottenere un elenco di REST APIs**
Comando:
```
aws apigateway get-rest-apis
```
Output:
```
{
"items": [
{
"createdDate": 1438884790,
"id": "12s44z21rb",
"name": "My First API"
}
]
}
```
+ Per i dettagli sull'API, consulta [GetRestApis AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-rest-apis.html)*Command Reference*.
### `get-sdk`
Il seguente esempio di codice mostra come utilizzare`get-sdk`.
**AWS CLI**
**Come ottenere l’SDK Android per una fase della REST API**
Comando:
```
aws apigateway get-sdk --rest-api-id 1234123412 --stage-name dev --sdk-type android --parameters groupId='com.mycompany',invokerPackage='com.mycompany.clientsdk',artifactId='Mycompany-client',artifactVersion='1.0.0' /path/to/android_sdk.zip
```
Output:
```
{
"contentType": "application/octet-stream",
"contentDisposition": "attachment; filename=\"android_2016-02-22_23-52Z.zip\""
}
```
**Come ottenere l’SDK iOS per una fase della REST API**
Comando:
```
aws apigateway get-sdk --rest-api-id 1234123412 --stage-name dev --sdk-type objectivec --parameters classPrefix='myprefix' /path/to/iOS_sdk.zip
```
Output:
```
{
"contentType": "application/octet-stream",
"contentDisposition": "attachment; filename=\"objectivec_2016-02-22_23-52Z.zip\""
}
```
**Come ottenere l’SDK Javascript per una fase della REST API**
Comando:
```
aws apigateway get-sdk --rest-api-id 1234123412 --stage-name dev --sdk-type javascript /path/to/javascript_sdk.zip
```
Output:
```
{
"contentType": "application/octet-stream",
"contentDisposition": "attachment; filename=\"javascript_2016-02-22_23-52Z.zip\""
}
```
+ Per i dettagli sull'API, consulta [GetSdk AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-sdk.html)*Command Reference*.
### `get-stage`
Il seguente esempio di codice mostra come utilizzare`get-stage`.
**AWS CLI**
**Come ottenere informazioni su una fase di un’API**
Comando:
```
aws apigateway get-stage --rest-api-id 1234123412 --stage-name dev
```
Output:
```
{
"stageName": "dev",
"cacheClusterSize": "0.5",
"cacheClusterEnabled": false,
"cacheClusterStatus": "NOT_AVAILABLE",
"deploymentId": "rbh1fj",
"lastUpdatedDate": 1466802961,
"createdDate": 1460682074,
"methodSettings": {
"*/*": {
"cacheTtlInSeconds": 300,
"loggingLevel": "INFO",
"dataTraceEnabled": false,
"metricsEnabled": true,
"unauthorizedCacheControlHeaderStrategy": "SUCCEED_WITH_RESPONSE_HEADER",
"throttlingRateLimit": 500.0,
"cacheDataEncrypted": false,
"cachingEnabled": false,
"throttlingBurstLimit": 1000,
"requireAuthorizationForCacheControl": true
},
"~1resource/GET": {
"cacheTtlInSeconds": 300,
"loggingLevel": "INFO",
"dataTraceEnabled": false,
"metricsEnabled": true,
"unauthorizedCacheControlHeaderStrategy": "SUCCEED_WITH_RESPONSE_HEADER",
"throttlingRateLimit": 500.0,
"cacheDataEncrypted": false,
"cachingEnabled": false,
"throttlingBurstLimit": 1000,
"requireAuthorizationForCacheControl": true
}
}
}
```
+ Per i dettagli sull'API, consulta [GetStage AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-stage.html)*Command Reference*.
### `get-stages`
Il seguente esempio di codice mostra come utilizzare`get-stages`.
**AWS CLI**
**Come ottenere un elenco di fasi per una REST API**
Comando:
```
aws apigateway get-stages --rest-api-id 1234123412
```
Output:
```
{
"item": [
{
"stageName": "dev",
"cacheClusterSize": "0.5",
"cacheClusterEnabled": true,
"cacheClusterStatus": "AVAILABLE",
"deploymentId": "123h64",
"lastUpdatedDate": 1456185138,
"createdDate": 1453589092,
"methodSettings": {
"~1resource~1subresource/POST": {
"cacheTtlInSeconds": 300,
"loggingLevel": "INFO",
"dataTraceEnabled": true,
"metricsEnabled": true,
"throttlingRateLimit": 500.0,
"cacheDataEncrypted": false,
"cachingEnabled": false,
"throttlingBurstLimit": 1000
}
}
}
]
}
```
+ Per i dettagli sull'API, consulta [GetStages AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-stages.html)*Command Reference*.
### `get-usage-plan-key`
Il seguente esempio di codice mostra come utilizzare`get-usage-plan-key`.
**AWS CLI**
**Come ottenere i dettagli di una chiave API associata a un piano di utilizzo**
Comando:
```
aws apigateway get-usage-plan-key --usage-plan-id a1b2c3 --key-id 1NbjQzMReAkeEQPNAW8r3dXsU2rDD7fc7f2Sipnu
```
+ Per i dettagli sull'API, consulta [GetUsagePlanKey AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-usage-plan-key.html)*Command Reference*.
### `get-usage-plan-keys`
Il seguente esempio di codice mostra come utilizzare`get-usage-plan-keys`.
**AWS CLI**
**Come ottenere l’elenco delle chiavi API associate a un piano di utilizzo**
Comando:
```
aws apigateway get-usage-plan-keys --usage-plan-id a1b2c3
```
+ Per i dettagli sull'API, consulta [GetUsagePlanKeys AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-usage-plan-keys.html)*Command Reference*.
### `get-usage-plan`
Il seguente esempio di codice mostra come utilizzare`get-usage-plan`.
**AWS CLI**
**Come ottenere i dettagli di un piano di utilizzo**
Comando:
```
aws apigateway get-usage-plan --usage-plan-id a1b2c3
```
+ Per i dettagli sull'API, consulta [GetUsagePlan AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-usage-plan.html)*Command Reference*.
### `get-usage-plans`
Il seguente esempio di codice mostra come utilizzare`get-usage-plans`.
**AWS CLI**
**Come ottenere i dettagli di tutti i piani di utilizzo**
Comando:
```
aws apigateway get-usage-plans
```
+ Per i dettagli sull'API, consulta [GetUsagePlans AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-usage-plans.html)*Command Reference*.
### `get-usage`
Il seguente esempio di codice mostra come utilizzare`get-usage`.
**AWS CLI**
**Come ottenere i dettagli sull’utilizzo per un piano di utilizzo**
Comando:
```
aws apigateway get-usage --usage-plan-id a1b2c3 --start-date "2016-08-16" --end-date "2016-08-17"
```
+ Per i dettagli sull'API, consulta [GetUsage AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-usage.html)*Command Reference*.
### `import-rest-api`
Il seguente esempio di codice mostra come utilizzare`import-rest-api`.
**AWS CLI**
**Come importare un modello Swagger e creare un’API**
Comando:
```
aws apigateway import-rest-api --body 'file:///path/to/API_Swagger_template.json'
```
+ Per i dettagli sull'API, consulta [ImportRestApi AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/import-rest-api.html)*Command Reference*.
### `put-integration-response`
Il seguente esempio di codice mostra come utilizzare`put-integration-response`.
**AWS CLI**
**Come creare una risposta di integrazione come risposta predefinita con un modello di mappatura definito**
Comando:
```
aws apigateway put-integration-response --rest-api-id 1234123412 --resource-id a1b2c3 --http-method GET --status-code 200 --selection-pattern "" --response-templates '{"application/json": "{\"json\": \"template\"}"}'
```
**Come creare una risposta di integrazione con un’espressione regolare impostata su 400 e un valore di intestazione definito staticamente**
Comando:
```
aws apigateway put-integration-response --rest-api-id 1234123412 --resource-id a1b2c3 --http-method GET --status-code 400 --selection-pattern 400 --response-parameters '{"method.response.header.custom-header": "'"'"'custom-value'"'"'"}'
```
+ Per i dettagli sull'API, consulta [PutIntegrationResponse AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/put-integration-response.html)*Command Reference*.
### `put-integration`
Il seguente esempio di codice mostra come utilizzare`put-integration`.
**AWS CLI**
**Come creare una richiesta di integrazione MOCK**
Comando:
```
aws apigateway put-integration --rest-api-id 1234123412 --resource-id a1b2c3 --http-method GET --type MOCK --request-templates '{ "application/json": "{\"statusCode\": 200}" }'
```
**Come creare una richiesta di integrazione HTTP**
Comando:
```
aws apigateway put-integration --rest-api-id 1234123412 --resource-id a1b2c3 --http-method GET --type HTTP --integration-http-method GET --uri 'https://domain.tld/path'
```
**Per creare una richiesta di AWS integrazione con un endpoint della funzione Lambda**
Comando:
```
aws apigateway put-integration --rest-api-id 1234123412 --resource-id a1b2c3 --http-method GET --type AWS --integration-http-method POST --uri 'arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123412341234:function:function_name/invocations'
```
+ Per i dettagli sull'API, consulta *AWS CLI Command [PutIntegration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/put-integration.html)Reference*.
### `put-method-response`
Il seguente esempio di codice mostra come utilizzare`put-method-response`.
**AWS CLI**
**Come creare una risposta del metodo con il codice di stato specificato con un’intestazione di risposta del metodo personalizzata**
Comando:
```
aws apigateway put-method-response --rest-api-id 1234123412 --resource-id a1b2c3 --http-method GET --status-code 400 --response-parameters "method.response.header.custom-header=false"
```
+ Per i dettagli sull'API, consulta [PutMethodResponse AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/put-method-response.html)*Command Reference*.
### `put-method`
Il seguente esempio di codice mostra come utilizzare`put-method`.
**AWS CLI**
**Come creare un metodo per una risorsa in un’API senza autorizzazione, senza chiave API e con un’intestazione di richiesta del metodo personalizzata**
Comando:
```
aws apigateway put-method --rest-api-id 1234123412 --resource-id a1b2c3 --http-method PUT --authorization-type "NONE" --no-api-key-required --request-parameters "method.request.header.custom-header=false"
```
+ Per i dettagli sull'API, consulta [PutMethod AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/put-method.html)*Command Reference*.
### `put-rest-api`
Il seguente esempio di codice mostra come utilizzare`put-rest-api`.
**AWS CLI**
**Come sovrascrivere un’API esistente utilizzando un modello Swagger**
Comando:
```
aws apigateway put-rest-api --rest-api-id 1234123412 --mode overwrite --body 'fileb:///path/to/API_Swagger_template.json'
```
**Come unire un modello Swagger a un’API esistente**
Comando:
```
aws apigateway put-rest-api --rest-api-id 1234123412 --mode merge --body 'fileb:///path/to/API_Swagger_template.json'
```
+ Per i dettagli sull'API, consulta [PutRestApi AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/put-rest-api.html)*Command Reference*.
### `reject-domain-name-access-association`
Il seguente esempio di codice mostra come utilizzare`reject-domain-name-access-association`.
**AWS CLI**
**Come rifiutare un’associazione di accesso al nome di dominio**
L’esempio `reject-domain-name-access-association` seguente rifiuta un’associazione di accesso al nome di dominio tra un nome di dominio privato personalizzato e l’endpoint VPC.
```
aws apigateway reject-domain-name-access-association \
--domain-name-access-association-arn arn:aws:apigateway:us-west-2:012345678910:/domainnameaccessassociations/domainname/my.private.domain.tld/vpcesource/vpce-abcd1234efg \
--domain-name-arn arn:aws:apigateway:us-east-1:012345678910:/domainnames/my.private.domain.tld+abcd1234
```
Questo comando non produce alcun output.
Per ulteriori informazioni, consulta [Nomi di dominio personalizzati per uso privato APIs in API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-custom-domains.html) nella *Amazon API Gateway Developer Guide*.
+ Per i dettagli sull'API, consulta [RejectDomainNameAccessAssociation AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/reject-domain-name-access-association.html)*Command Reference*.
### `test-invoke-authorizer`
Il seguente esempio di codice mostra come utilizzare`test-invoke-authorizer`.
**AWS CLI**
**Come testare l’invocazione di una richiesta a un sistema di autorizzazione personalizzato che includa l’intestazione e il valore richiesti**
Comando:
```
aws apigateway test-invoke-authorizer --rest-api-id 1234123412 --authorizer-id 5yid1t --headers Authorization='Value'
```
+ Per i dettagli sull'API, consulta [TestInvokeAuthorizer AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/test-invoke-authorizer.html)*Command Reference*.
### `test-invoke-method`
Il seguente esempio di codice mostra come utilizzare`test-invoke-method`.
**AWS CLI**
**Come testare l’invocazione della risorsa root in un’API eseguendo una richiesta GET**
Comando:
```
aws apigateway test-invoke-method --rest-api-id 1234123412 --resource-id avl5sg8fw8 --http-method GET --path-with-query-string '/'
```
**Come testare l’invocazione di una risorsa secondaria in un’API eseguendo una richiesta GET con un valore di parametro di percorso specificato**
Comando:
```
aws apigateway test-invoke-method --rest-api-id 1234123412 --resource-id 3gapai --http-method GET --path-with-query-string '/pets/1'
```
+ Per i dettagli sull'API, consulta [TestInvokeMethod AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/test-invoke-method.html)*Command Reference*.
### `update-account`
Il seguente esempio di codice mostra come utilizzare`update-account`.
**AWS CLI**
**Per modificare l'ARN del ruolo IAM per la registrazione nei registri CloudWatch **
Comando:
```
aws apigateway update-account --patch-operations op='replace',path='/cloudwatchRoleArn',value='arn:aws:iam::123412341234:role/APIGatewayToCloudWatchLogs'
```
Output:
```
{
"cloudwatchRoleArn": "arn:aws:iam::123412341234:role/APIGatewayToCloudWatchLogs",
"throttleSettings": {
"rateLimit": 1000.0,
"burstLimit": 2000
}
}
```
+ *Per i dettagli sull'API, consulta Command [UpdateAccount](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-account.html)Reference AWS CLI .*
### `update-api-key`
Il seguente esempio di codice mostra come utilizzare`update-api-key`.
**AWS CLI**
**Come modificare il nome di una chiave API**
Comando:
```
aws apigateway update-api-key --api-key sNvjQDMReA1eEQPNAW8r37XsU2rDD7fc7m2SiMnu --patch-operations op='replace',path='/name',value='newName'
```
Output:
```
{
"description": "currentDescription",
"enabled": true,
"stageKeys": [
"41t2j324r5/dev"
],
"lastUpdatedDate": 1470086052,
"createdDate": 1445460347,
"id": "sNvjQDMReA1vEQPNzW8r3dXsU2rrD7fcjm2SiMnu",
"name": "newName"
}
```
**Come disabilitare la chiave API**
Comando:
```
aws apigateway update-api-key --api-key sNvjQDMReA1eEQPNAW8r37XsU2rDD7fc7m2SiMnu --patch-operations op='replace',path='/enabled',value='false'
```
Output:
```
{
"description": "currentDescription",
"enabled": false,
"stageKeys": [
"41t2j324r5/dev"
],
"lastUpdatedDate": 1470086052,
"createdDate": 1445460347,
"id": "sNvjQDMReA1vEQPNzW8r3dXsU2rrD7fcjm2SiMnu",
"name": "newName"
}
```
+ Per i dettagli sull'API, consulta [UpdateApiKey AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-api-key.html)*Command Reference*.
### `update-authorizer`
Il seguente esempio di codice mostra come utilizzare`update-authorizer`.
**AWS CLI**
**Come modificare il nome del sistema di autorizzazione personalizzato**
Comando:
```
aws apigateway update-authorizer --rest-api-id 1234123412 --authorizer-id gfi4n3 --patch-operations op='replace',path='/name',value='testAuthorizer'
```
Output:
```
{
"authType": "custom",
"name": "testAuthorizer",
"authorizerUri": "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123412341234:function:customAuthorizer/invocations",
"authorizerResultTtlInSeconds": 300,
"identitySource": "method.request.header.Authorization",
"type": "TOKEN",
"id": "gfi4n3"
}
```
**Come modificare la funzione Lambda invocata dal sistema di autorizzazione personalizzato**
Comando:
```
aws apigateway update-authorizer --rest-api-id 1234123412 --authorizer-id gfi4n3 --patch-operations op='replace',path='/authorizerUri',value='arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123412341234:function:newAuthorizer/invocations'
```
Output:
```
{
"authType": "custom",
"name": "testAuthorizer",
"authorizerUri": "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123412341234:function:newAuthorizer/invocations",
"authorizerResultTtlInSeconds": 300,
"identitySource": "method.request.header.Authorization",
"type": "TOKEN",
"id": "gfi4n3"
}
```
+ Per i dettagli sull'API, consulta [UpdateAuthorizer AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-authorizer.html)*Command Reference*.
### `update-base-path-mapping`
Il seguente esempio di codice mostra come utilizzare`update-base-path-mapping`.
**AWS CLI**
**Come modificare il percorso di base per un nome di dominio personalizzato**
Comando:
```
aws apigateway update-base-path-mapping --domain-name api.domain.tld --base-path prod --patch-operations op='replace',path='/basePath',value='v1'
```
Output:
```
{
"basePath": "v1",
"restApiId": "1234123412",
"stage": "api"
}
```
+ Per i dettagli sull'API, consulta [UpdateBasePathMapping AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-base-path-mapping.html)*Command Reference*.
### `update-client-certificate`
Il seguente esempio di codice mostra come utilizzare`update-client-certificate`.
**AWS CLI**
**Come aggiornare la descrizione di un certificato client**
Comando:
```
aws apigateway update-client-certificate --client-certificate-id a1b2c3 --patch-operations op='replace',path='/description',value='My new description'
```
+ Per i dettagli sull'API, consulta [UpdateClientCertificate AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-client-certificate.html)*Command Reference*.
### `update-deployment`
Il seguente esempio di codice mostra come utilizzare`update-deployment`.
**AWS CLI**
**Come modificare la descrizione di un’implementazione**
Comando:
```
aws apigateway update-deployment --rest-api-id 1234123412 --deployment-id ztt4m2 --patch-operations op='replace',path='/description',value='newDescription'
```
Output:
```
{
"description": "newDescription",
"id": "ztt4m2",
"createdDate": 1455218022
}
```
+ Per i dettagli sull'API, consulta [UpdateDeployment AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-deployment.html)*Command Reference*.
### `update-domain-name`
Il seguente esempio di codice mostra come utilizzare`update-domain-name`.
**AWS CLI**
**Come modificare il nome del certificato per un nome di dominio personalizzato**
L’esempio `update-domain-name` seguente modifica il nome del certificato per un dominio personalizzato.
```
aws apigateway update-domain-name \
--domain-name api.domain.tld \
--patch-operations op='replace',path='/certificateArn',value='arn:aws:acm:us-west-2:111122223333:certificate/CERTEXAMPLE123EXAMPLE'
```
Output:
```
{
"domainName": "api.domain.tld",
"distributionDomainName": "d123456789012.cloudfront.net",
"certificateArn": "arn:aws:acm:us-west-2:111122223333:certificate/CERTEXAMPLE123EXAMPLE",
"certificateUploadDate": 1462565487
}
```
Per ulteriori informazioni consulta [Nomi di dominio personalizzati per REST API pubbliche in Gateway API](https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-custom-domains.html) nella *Guida per gli sviluppatori di Gateway Amazon API*.
+ Per i dettagli sull'API, consulta [UpdateDomainName AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-domain-name.html)*Command Reference*.
### `update-integration-response`
Il seguente esempio di codice mostra come utilizzare`update-integration-response`.
**AWS CLI**
**Come modificare l’intestazione di una risposta di integrazione in modo da avere una mappatura statica di “\$1”**
Comando:
```
aws apigateway update-integration-response --rest-api-id 1234123412 --resource-id 3gapai --http-method GET --status-code 200 --patch-operations op='replace',path='/responseParameters/method.response.header.Access-Control-Allow-Origin',value='"'"'*'"'"'
```
Output:
```
{
"statusCode": "200",
"responseParameters": {
"method.response.header.Access-Control-Allow-Origin": "'*'"
}
}
```
**Come rimuovere l’intestazione di una risposta di integrazione**
Comando:
```
aws apigateway update-integration-response --rest-api-id 1234123412 --resource-id 3gapai --http-method GET --status-code 200 --patch-operations op='remove',path='/responseParameters/method.response.header.Access-Control-Allow-Origin'
```
+ Per i dettagli sull'API, consulta [UpdateIntegrationResponse AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-integration-response.html)*Command Reference*.
### `update-integration`
Il seguente esempio di codice mostra come utilizzare`update-integration`.
**AWS CLI**
**Come aggiungere il modello di mappatura “Content-Type: application/json” configurato con Passthrough di input**
Comando:
```
aws apigateway update-integration \
--rest-api-id a1b2c3d4e5 \
--resource-id a1b2c3 \
--http-method POST \
--patch-operations "op='add',path='/requestTemplates/application~1json'"
```
**Come aggiornare (sostituire) il modello di mappatura “Content-Type: application/json” configurato con un modello personalizzato**
Comando:
```
aws apigateway update-integration \
--rest-api-id a1b2c3d4e5 \
--resource-id a1b2c3 \
--http-method POST \
--patch-operations "op='replace',path='/requestTemplates/application~1json',value='{"example": "json"}'"
```
**Come aggiornare (sostituire) un modello personalizzato associato a “Content-Type: application/json” con Passthrough di input**
Comando:
```
aws apigateway update-integration \
--rest-api-id a1b2c3d4e5 \
--resource-id a1b2c3 \
--http-method POST \
--patch-operations "op='replace',path='requestTemplates/application~1json'"
```
**Come rimuovere il modello di mappatura “Content-Type: application/json”**
Comando:
```
aws apigateway update-integration \
--rest-api-id a1b2c3d4e5 \
--resource-id a1b2c3 \
--http-method POST \
--patch-operations "op='remove',path='/requestTemplates/application~1json'"
```
+ Per i dettagli sull'API, consulta [UpdateIntegration AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-integration.html)*Command Reference*.
### `update-method-response`
Il seguente esempio di codice mostra come utilizzare`update-method-response`.
**AWS CLI**
**Come creare una nuova intestazione di risposta del metodo per la risposta 200 in un metodo e definirla come non obbligatoria (per impostazione predefinita)**
Comando:
```
aws apigateway update-method-response --rest-api-id 1234123412 --resource-id a1b2c3 --http-method GET --status-code 200 --patch-operations op="add",path="/responseParameters/method.response.header.custom-header",value="false"
```
**Come eliminare un modello di risposta per la risposta 200 in un metodo**
Comando:
```
aws apigateway update-method-response --rest-api-id 1234123412 --resource-id a1b2c3 --http-method GET --status-code 200 --patch-operations op="remove",path="/responseModels/application~1json"
```
+ Per i dettagli sull'API, consulta [UpdateMethodResponse AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-method-response.html)*Command Reference*.
### `update-method`
Il seguente esempio di codice mostra come utilizzare`update-method`.
**AWS CLI**
**Esempio 1: come modificare un metodo per richiedere una chiave API**
L’esempio `update-method` seguente modifica il metodo per richiedere una chiave API.
```
aws apigateway update-method \
--rest-api-id 1234123412 \
--resource-id a1b2c3 \
--http-method GET \
--patch-operations op="replace",path="/apiKeyRequired",value="true"
```
Output:
```
{
"httpMethod": "GET",
"authorizationType": "NONE",
"apiKeyRequired": true,
"methodResponses": {
"200": {
"statusCode": "200",
"responseModels": {}
}
},
"methodIntegration": {
"type": "AWS",
"httpMethod": "POST",
"uri": "arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:123456789111:function:hello-world/invocations",
"passthroughBehavior": "WHEN_NO_MATCH",
"contentHandling": "CONVERT_TO_TEXT",
"timeoutInMillis": 29000,
"cacheNamespace": "h7i8j9",
"cacheKeyParameters": [],
"integrationResponses": {
"200": {
"statusCode": "200",
"responseTemplates": {}
}
}
}
}
```
**Esempio 2: come modificare un metodo per richiedere l’autorizzazione IAM**
L’esempio `update-method` seguente modifica il metodo per richiedere l’autorizzazione IAM.
```
aws apigateway update-method \
--rest-api-id 1234123412 \
--resource-id a1b2c3 \
--http-method GET \
--patch-operations op="replace",path="/authorizationType",value="AWS_IAM"
```
Output:
```
{
"httpMethod": "GET",
"authorizationType": "AWS_IAM",
"apiKeyRequired": false,
"methodResponses": {
"200": {
"statusCode": "200",
"responseModels": {}
}
},
"methodIntegration": {
"type": "AWS",
"httpMethod": "POST",
"uri": "arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:123456789111:function:hello-world/invocations",
"passthroughBehavior": "WHEN_NO_MATCH",
"contentHandling": "CONVERT_TO_TEXT",
"timeoutInMillis": 29000,
"cacheNamespace": "h7i8j9",
"cacheKeyParameters": [],
"integrationResponses": {
"200": {
"statusCode": "200",
"responseTemplates": {}
}
}
}
}
```
**Esempio 3: come modificare un metodo per richiedere l’autorizzazione Lambda**
L’esempio `update-method` seguente modifica il metodo per richiedere l’autorizzazione Lambda.
```
aws apigateway update-method --rest-api-id 1234123412 \
--resource-id a1b2c3 \
--http-method GET \
--patch-operations op="replace",path="/authorizationType",value="CUSTOM" op="replace",path="/authorizerId",value="e4f5g6"
```
Output:
```
{
"httpMethod": "GET",
"authorizationType": "CUSTOM",
"authorizerId" : "e4f5g6",
"apiKeyRequired": false,
"methodResponses": {
"200": {
"statusCode": "200",
"responseModels": {}
}
},
"methodIntegration": {
"type": "AWS",
"httpMethod": "POST",
"uri": "arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:123456789111:function:hello-world/invocations",
"passthroughBehavior": "WHEN_NO_MATCH",
"contentHandling": "CONVERT_TO_TEXT",
"timeoutInMillis": 29000,
"cacheNamespace": "h7i8j9",
"cacheKeyParameters": [],
"integrationResponses": {
"200": {
"statusCode": "200",
"responseTemplates": {}
}
}
}
}
```
Per ulteriori informazioni, consulta [Creazione, configurazione e test dei piani di utilizzo mediante la CLI e la REST API di API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-create-usage-plans-with-rest-api.html) e [Controllo e gestione degli accessi alle REST API in Gateway API](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-control-access-to-api.html) nella *Guida per gli sviluppatori di Gateway Amazon API*.
+ Per i dettagli sull'API, consulta [UpdateMethod AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-method.html)*Command Reference*.
### `update-model`
Il seguente esempio di codice mostra come utilizzare`update-model`.
**AWS CLI**
**Come modificare la descrizione di un modello in un’API**
Comando:
```
aws apigateway update-model --rest-api-id 1234123412 --model-name 'Empty' --patch-operations op=replace,path=/description,value='New Description'
```
**Come modificare lo schema di un modello in un’API**
Comando:
```
aws apigateway update-model --rest-api-id 1234123412 --model-name 'Empty' --patch-operations op=replace,path=/schema,value='"{ \"$schema\": \"http://json-schema.org/draft-04/schema#\", \"title\" : \"Empty Schema\", \"type\" : \"object\" }"'
```
+ Per i dettagli sull'API, consulta [UpdateModel AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-model.html)*Command Reference*.
### `update-resource`
Il seguente esempio di codice mostra come utilizzare`update-resource`.
**AWS CLI**
**Come spostare una risorsa e posizionarla in una risorsa principale diversa in un’API**
Comando:
```
aws apigateway update-resource --rest-api-id 1234123412 --resource-id 1a2b3c --patch-operations op=replace,path=/parentId,value='3c2b1a'
```
Output:
```
{
"path": "/resource",
"pathPart": "resource",
"id": "1a2b3c",
"parentId": "3c2b1a"
}
```
**Come rinominare una risorsa (pathPart) in un’API**
Comando:
```
aws apigateway update-resource --rest-api-id 1234123412 --resource-id 1a2b3c --patch-operations op=replace,path=/pathPart,value=newresourcename
```
Output:
```
{
"path": "/newresourcename",
"pathPart": "newresourcename",
"id": "1a2b3c",
"parentId": "3c2b1a"
}
```
+ Per i dettagli sull'API, consulta [UpdateResource AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-resource.html)*Command Reference*.
### `update-rest-api`
Il seguente esempio di codice mostra come utilizzare`update-rest-api`.
**AWS CLI**
**Come modificare il nome di un’API**
Comando:
```
aws apigateway update-rest-api --rest-api-id 1234123412 --patch-operations op=replace,path=/name,value='New Name'
```
**Come modificare la descrizione di un’API**
Comando:
```
aws apigateway update-rest-api --rest-api-id 1234123412 --patch-operations op=replace,path=/description,value='New Description'
```
+ Per i dettagli sull'API, consulta [UpdateRestApi AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-rest-api.html)*Command Reference*.
### `update-stage`
Il seguente esempio di codice mostra come utilizzare`update-stage`.
**AWS CLI**
**Esempio 1: come sostituire le impostazioni della fase per una risorsa e un metodo**
L'`update-stage`esempio seguente sovrascrive le impostazioni dello stage e disattiva la request/response registrazione completa per una risorsa e un metodo specifici.
```
aws apigateway update-stage \
--rest-api-id 1234123412 \
--stage-name 'dev' \
--patch-operations op=replace,path=/~1resourceName/GET/logging/dataTrace,value=false
```
Output:
```
{
"deploymentId": "5ubd17",
"stageName": "dev",
"cacheClusterEnabled": false,
"cacheClusterStatus": "NOT_AVAILABLE",
"methodSettings": {
"~1resourceName/GET": {
"metricsEnabled": false,
"dataTraceEnabled": false,
"throttlingBurstLimit": 5000,
"throttlingRateLimit": 10000.0,
"cachingEnabled": false,
"cacheTtlInSeconds": 300,
"cacheDataEncrypted": false,
"requireAuthorizationForCacheControl": true,
"unauthorizedCacheControlHeaderStrategy": "SUCCEED_WITH_RESPONSE_HEADER"
}
},
"tracingEnabled": false,
"createdDate": "2022-07-18T10:11:18-07:00",
"lastUpdatedDate": "2022-07-18T10:19:04-07:00"
}
```
Per ulteriori informazioni consulta [Configurazione di una fase per una REST API in Gateway API](https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-stages.html) nella *Guida per gli sviluppatori di Gateway Amazon API*.
**Esempio 2: come aggiornare le impostazioni della fase per tutte le risorse e tutti i metodi di una fase API**
L'`update-stage`esempio seguente attiva la request/response registrazione completa per tutte le risorse e i metodi di una fase API.
```
aws apigateway update-stage \
--rest-api-id 1234123412 \
--stage-name 'dev' \
--patch-operations 'op=replace,path=/*/*/logging/dataTrace,value=true'
```
Output:
```
{
"deploymentId": "5ubd17",
"stageName": "dev",
"cacheClusterEnabled": false,
"cacheClusterStatus": "NOT_AVAILABLE",
"methodSettings": {
"*/*": {
"metricsEnabled": false,
"dataTraceEnabled": true,
"throttlingBurstLimit": 5000,
"throttlingRateLimit": 10000.0,
"cachingEnabled": false,
"cacheTtlInSeconds": 300,
"cacheDataEncrypted": false,
"requireAuthorizationForCacheControl": true,
"unauthorizedCacheControlHeaderStrategy": "SUCCEED_WITH_RESPONSE_HEADER"
}
},
"tracingEnabled": false,
"createdDate": "2022-07-18T10:11:18-07:00",
"lastUpdatedDate": "2022-07-18T10:31:04-07:00"
}
```
Per ulteriori informazioni consulta [Configurazione di una fase per una REST API in Gateway API](https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-stages.html) nella *Guida per gli sviluppatori di Gateway Amazon API*.
+ Per i dettagli sull'API, consulta [UpdateStage AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-stage.html)*Command Reference.*
### `update-usage-plan`
Il seguente esempio di codice mostra come utilizzare`update-usage-plan`.
**AWS CLI**
**Come modificare il periodo definito in un piano di utilizzo**
Comando:
```
aws apigateway update-usage-plan --usage-plan-id a1b2c3 --patch-operations op="replace",path="/quota/period",value="MONTH"
```
**Come modificare il limite di quota definito in un piano di utilizzo**
Comando:
```
aws apigateway update-usage-plan --usage-plan-id a1b2c3 --patch-operations op="replace",path="/quota/limit",value="500"
```
**Come modificare il limite di velocità di elaborazione delle richieste definito in un piano di utilizzo**
Comando:
```
aws apigateway update-usage-plan --usage-plan-id a1b2c3 --patch-operations op="replace",path="/throttle/rateLimit",value="10"
```
**Come modificare il limite di burst di elaborazione delle richieste definito in un piano di utilizzo**
Comando:
```
aws apigateway update-usage-plan --usage-plan-id a1b2c3 --patch-operations op="replace",path="/throttle/burstLimit",value="20"
```
+ Per i dettagli sull'API, consulta [UpdateUsagePlan AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-usage-plan.html)*Command Reference*.
### `update-usage`
Il seguente esempio di codice mostra come utilizzare`update-usage`.
**AWS CLI**
**Come modificare temporaneamente la quota su una chiave API per il periodo corrente definito nel piano di utilizzo**
Comando:
```
aws apigateway update-usage --usage-plan-id a1b2c3 --key-id 1NbjQzMReAkeEQPNAW8r3dXsU2rDD7fc7f2Sipnu --patch-operations op="replace",path="/remaining",value="50"
```
+ Per i dettagli sull'API, consulta [UpdateUsage AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-usage.html)*Command Reference*.
### `update-vpc-link`
Il seguente esempio di codice mostra come utilizzare`update-vpc-link`.
**AWS CLI**
**Esempio 1: aggiornare il nome di un link VPC esistente**
L'`update-vpc-link`esempio seguente aggiorna il nome del link VPC specificato.
```
aws apigateway update-vpc-link \
--vpc-link-id ab3de6 \
--patch-operations op=replace,path=/name,value=my-vpc-link
```
Output:
```
{
"id": "ab3de6",
"name": "my-vpc-link",
"targetArns": [
"arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/net/my-lb/12a456s89aaa12345"
],
"status": "AVAILABLE",
"statusMessage": "Your vpc link is ready for use",
"tags": {}
}
```
Per ulteriori informazioni, consulta [Aggiornamento del collegamento VPC esistente](https://docs.aws.amazon.com/cli/latest/reference/apigateway/update-vpc-link.html) nel riferimento ai comandi *AWS CLI*.
**Esempio 2: aggiornare il nome e la descrizione di un link VPC esistente**
L'`update-vpc-link`esempio seguente aggiorna il nome del link VPC specificato.
```
aws apigateway update-vpc-link \
--vpc-link-id ab3de6 \
--patch-operations op=replace,path=/name,value=my-vpc-link op=replace,path=/description,value="My custom description"
```
Output:
```
{
"id": "ab3de6",
"name": "my-vpc-link",
"description": "My custom description",
"targetArns": [
"arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/net/my-lb/12a456s89aaa12345"
],
"status": "AVAILABLE",
"statusMessage": "Your vpc link is ready for use",
"tags": {}
}
```
Per ulteriori informazioni, consulta [Aggiornamento del collegamento VPC esistente](https://docs.aws.amazon.com/cli/latest/reference/apigateway/update-vpc-link.html) nel riferimento ai comandi *AWS CLI*.
+ Per i dettagli sull'API, consulta *AWS CLI Command [UpdateVpcLink](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-vpc-link.html)Reference*.