# Exemplos da API Gateway usando a AWS CLI
Os exemplos de código a seguir mostram como realizar ações e implementar cenários comuns usando o AWS Command Line Interface com o API Gateway.
*Ações* são trechos de código de programas maiores e devem ser executadas em contexto. Embora as ações mostrem como chamar perfis de serviço individuais, você pode ver as ações no contexto em seus cenários relacionados.
Cada exemplo inclui um link para o código-fonte completo, em que você pode encontrar instruções sobre como configurar e executar o código.
**Topics**
+ [Ações](#actions)
## Ações
### `create-api-key`
O código de exemplo a seguir mostra como usar `create-api-key`.
**AWS CLI**
**Para criar uma chave de API habilitada para uma API e um estágio existentes**
Comando:
```
aws apigateway create-api-key --name 'Dev API Key' --description 'Used for development' --enabled --stage-keys restApiId='a1b2c3d4e5',stageName='dev'
```
+ Para ver detalhes da API, consulte [CreateApiKey](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-api-key.html) na *Referência de comandos da AWS CLI*.
### `create-authorizer`
O código de exemplo a seguir mostra como usar `create-authorizer`.
**AWS CLI**
**Exemplo 1: criar um autorizador personalizado do API Gateway baseado em token para a API**
O exemplo `create-authorizer` a seguir cria um autorizador baseado em 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
```
Resultado:
```
{
"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"
}
```
**Exemplo 2: criar um autorizador personalizado do API Gateway baseado em grupos de usuários do Cognito para a API**
O exemplo `create-authorizer` a seguir cria um autorizador personalizado do API Gateway baseado em grupos de usuários do 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'
```
Resultado:
```
{
"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"
}
```
**Exemplo 3: criar um autorizador personalizado do API Gateway baseado em solicitações para a API**
O exemplo `create-authorizer` a seguir cria um autorizador baseado em solicitações.
```
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
```
Resultado:
```
{
"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
}
```
+ Para ver detalhes da API, consulte [CreateAuthorizer](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-authorizer.html) na *Referência de comandos da AWS CLI*.
### `create-base-path-mapping`
O código de exemplo a seguir mostra como usar `create-base-path-mapping`.
**AWS CLI**
**Para criar o mapeamento de caminho base para um nome de domínio personalizado**
Comando:
```
aws apigateway create-base-path-mapping --domain-name subdomain.domain.tld --rest-api-id 1234123412 --stage prod --base-path v1
```
+ Para ver detalhes da API, consulte [CreateBasePathMapping](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-base-path-mapping.html) na *Referência de comandos da AWS CLI*.
### `create-deployment`
O código de exemplo a seguir mostra como usar `create-deployment`.
**AWS CLI**
**Como implantar os recursos configurados de uma API em um novo estágio**
Comando:
```
aws apigateway create-deployment --rest-api-id 1234123412 --stage-name dev --stage-description 'Development Stage' --description 'First deployment to the dev stage'
```
**Como implantar os recursos configurados de uma API em um estágio existente**
Comando:
```
aws apigateway create-deployment --rest-api-id 1234123412 --stage-name dev --description 'Second deployment to the dev stage'
```
**Como implantar os recursos configurados de uma API em um estágio existente com variáveis de estágio**
aws apigateway create-deployment --rest-api-id 1234123412 --stage-name dev --description 'Terceira implantação no estágio de desenvolvimento' --variables key='value',otherKey='otherValue'
+ Consulte detalhes da API em [CreateDeployment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-deployment.html) na *Referência de comandos da AWS CLI*.
### `create-domain-name-access-association`
O código de exemplo a seguir mostra como usar `create-domain-name-access-association`.
**AWS CLI**
**Como criar uma associação de acesso ao nome de domínio**
O exemplo de `create-domain-name-access-association` a seguir cria uma associação de acesso ao nome de domínio entre um nome de domínio personalizado privado e um endpoint da 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
```
Resultado:
```
{
"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"
}
```
Consulte mais informações em [Custom domain names for private APIs in API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-custom-domains.html) no *Guia do desenvolvedor do Amazon API Gateway*.
+ Consulte detalhes da API em [CreateDomainNameAccessAssociation](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-domain-name-access-association.html) na *Referência de comandos da AWS CLI*.
### `create-domain-name`
O código de exemplo a seguir mostra como usar `create-domain-name`.
**AWS CLI**
**Exemplo 1: como criar um nome de domínio personalizado público**
O exemplo de `create-domain-name` a seguir cria um domínio personalizado público.
```
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'
```
Resultado:
```
{
"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"
}
```
Consulte mais informações em [Nome de domínio personalizado para APIs REST no API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-custom-domains.html) no *Guia do desenvolvedor do Amazon API Gateway*.
**Exemplo 2: como criar um nome de domínio personalizado privado**
O exemplo de `create-domain-name` a seguir cria um domínio personalizado privado.
```
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
```
Conteúdo de `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"
}
}
}
]
}
```
Resultado:
```
{
"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\"}}}]}"
}
```
Consulte mais informações em [Nome de domínio personalizado para APIs REST no API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-custom-domains.html) no *Guia do desenvolvedor do Amazon API Gateway*.
+ Para ver detalhes da API, consulte [CreateDomainName](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-domain-name.html) na *Referência de comandos da AWS CLI*.
### `create-model`
O código de exemplo a seguir mostra como usar `create-model`.
**AWS CLI**
**Para criar um modelo para uma 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" } } } } }'
```
Resultado:
```
{
"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\" } } } } }"
}
```
+ Para ver detalhes da API, consulte [CreateModel](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-model.html) na *Referência de comandos da AWS CLI*.
### `create-resource`
O código de exemplo a seguir mostra como usar `create-resource`.
**AWS CLI**
**Como criar um recurso em uma API**
Comando:
```
aws apigateway create-resource --rest-api-id 1234123412 --parent-id a1b2c3 --path-part 'new-resource'
```
+ Consulte detalhes da API em [CreateResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-resource.html) na *Referência de comandos da AWS CLI*.
### `create-rest-api`
O código de exemplo a seguir mostra como usar `create-rest-api`.
**AWS CLI**
**Como criar uma API**
Comando:
```
aws apigateway create-rest-api --name 'My First API' --description 'This is my first API'
```
**Como criar uma API duplicada a partir de uma API existente**
Comando:
```
aws apigateway create-rest-api --name 'Copy of My First API' --description 'This is a copy of my first API' --clone-from 1234123412
```
+ Consulte detalhes da API em [CreateRestApi](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-rest-api.html) na *Referência de comandos da AWS CLI*.
### `create-stage`
O código de exemplo a seguir mostra como usar `create-stage`.
**AWS CLI**
**Para criar um estágio em uma API que conterá uma implantação existente**
Comando:
```
aws apigateway create-stage --rest-api-id 1234123412 --stage-name 'dev' --description 'Development stage' --deployment-id a1b2c3
```
**Para criar um estágio em uma API que conterá uma implantação existente e variáveis de estágio personalizadas**
Comando:
```
aws apigateway create-stage --rest-api-id 1234123412 --stage-name 'dev' --description 'Development stage' --deployment-id a1b2c3 --variables key='value',otherKey='otherValue'
```
+ Para ver detalhes da API, consulte [CreateStage](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-stage.html) na *Referência de comandos da AWS CLI*.
### `create-usage-plan-key`
O código de exemplo a seguir mostra como usar `create-usage-plan-key`.
**AWS CLI**
**Associar uma chave de API existente a um plano de uso**
Comando:
```
aws apigateway create-usage-plan-key --usage-plan-id a1b2c3 --key-type "API_KEY" --key-id 4vq3yryqm5
```
+ Para ver detalhes da API, consulte [CreateUsagePlanKey](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-usage-plan-key.html) na *Referência de comandos da AWS CLI*.
### `create-usage-plan`
O código de exemplo a seguir mostra como usar `create-usage-plan`.
**AWS CLI**
**Para criar um plano de uso com limites de cota e controle de utilização que são redefinidos no início do mês**
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
```
+ Para ver detalhes da API, consulte [CreateUsagePlan](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/create-usage-plan.html) na *Referência de comandos da AWS CLI*.
### `delete-api-key`
O código de exemplo a seguir mostra como usar `delete-api-key`.
**AWS CLI**
**Para excluir uma chave de API**
Comando:
```
aws apigateway delete-api-key --api-key 8bklk8bl1k3sB38D9B3l0enyWT8c09B30lkq0blk
```
+ Para ver detalhes da API, consulte [DeleteApiKey](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-api-key.html) na *Referência de comandos da AWS CLI*.
### `delete-authorizer`
O código de exemplo a seguir mostra como usar `delete-authorizer`.
**AWS CLI**
**Para excluir um autorizador personalizado em uma API**
Comando:
```
aws apigateway delete-authorizer --rest-api-id 1234123412 --authorizer-id 7gkfbo
```
+ Para ver detalhes da API, consulte [DeleteAuthorizer](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-authorizer.html) na *Referência de comandos da AWS CLI*.
### `delete-base-path-mapping`
O código de exemplo a seguir mostra como usar `delete-base-path-mapping`.
**AWS CLI**
**Para excluir um mapeamento de caminho base para um nome de domínio personalizado**
Comando:
```
aws apigateway delete-base-path-mapping --domain-name 'api.domain.tld' --base-path 'dev'
```
+ Para ver detalhes da API, consulte [DeleteBasePathMapping](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-base-path-mapping.html) na *Referência de comandos da AWS CLI*.
### `delete-client-certificate`
O código de exemplo a seguir mostra como usar `delete-client-certificate`.
**AWS CLI**
**Para excluir um certificado de cliente**
Comando:
```
aws apigateway delete-client-certificate --client-certificate-id a1b2c3
```
+ Para ver detalhes da API, consulte [DeleteClientCertificate](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-client-certificate.html) na *Referência de comandos da AWS CLI*.
### `delete-deployment`
O código de exemplo a seguir mostra como usar `delete-deployment`.
**AWS CLI**
**Como excluir uma implantação em uma API**
Comando:
```
aws apigateway delete-deployment --rest-api-id 1234123412 --deployment-id a1b2c3
```
+ Consulte detalhes da API em [DeleteDeployment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-deployment.html) na *Referência de comandos da AWS CLI*.
### `delete-domain-name-access-association`
O código de exemplo a seguir mostra como usar `delete-domain-name-access-association`.
**AWS CLI**
**Como excluir uma associação de acesso ao nome de domínio**
O exemplo de `delete-domain-name-access-association` a seguir exclui uma associação de acesso ao nome de domínio entre um nome de domínio personalizado privado e um endpoint da 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
```
Este comando não produz saída.
Consulte mais informações em [Custom domain names for private APIs in API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-custom-domains.html) no *Guia do desenvolvedor do Amazon API Gateway*.
+ Consulte detalhes da API em [DeleteDomainNameAccessAssociation](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-domain-name-access-association.html) na *Referência de comandos da AWS CLI*.
### `delete-domain-name`
O código de exemplo a seguir mostra como usar `delete-domain-name`.
**AWS CLI**
**Para excluir um nome de domínio personalizado**
Comando:
```
aws apigateway delete-domain-name --domain-name 'api.domain.tld'
```
+ Para ver detalhes da API, consulte [DeleteDomainName](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-domain-name.html) na *Referência de comandos da AWS CLI*.
### `delete-integration-response`
O código de exemplo a seguir mostra como usar `delete-integration-response`.
**AWS CLI**
**Para excluir uma resposta de integração para um determinado recurso, método e código de status em uma API**
Comando:
```
aws apigateway delete-integration-response --rest-api-id 1234123412 --resource-id a1b2c3 --http-method GET --status-code 200
```
+ Para ver detalhes da API, consulte [DeleteIntegrationResponse](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-integration-response.html) na *Referência de comandos da AWS CLI*.
### `delete-integration`
O código de exemplo a seguir mostra como usar `delete-integration`.
**AWS CLI**
**Para excluir uma integração para um determinado recurso e método em uma API**
Comando:
```
aws apigateway delete-integration --rest-api-id 1234123412 --resource-id a1b2c3 --http-method GET
```
+ Para ver detalhes da API, consulte [DeleteIntegration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-integration.html) na *Referência de comandos da AWS CLI*.
### `delete-method-response`
O código de exemplo a seguir mostra como usar `delete-method-response`.
**AWS CLI**
**Para excluir uma resposta de método para um determinado recurso, método e código de status em uma API**
Comando:
```
aws apigateway delete-method-response --rest-api-id 1234123412 --resource-id a1b2c3 --http-method GET --status-code 200
```
+ Para ver detalhes da API, consulte [DeleteMethodResponse](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-method-response.html) na *Referência de comandos da AWS CLI*.
### `delete-method`
O código de exemplo a seguir mostra como usar `delete-method`.
**AWS CLI**
**Para excluir um método para um determinado recurso em uma API**
Comando:
```
aws apigateway delete-method --rest-api-id 1234123412 --resource-id a1b2c3 --http-method GET
```
+ Para ver detalhes da API, consulte [DeleteMethod](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-method.html) na *Referência de comandos da AWS CLI*.
### `delete-model`
O código de exemplo a seguir mostra como usar `delete-model`.
**AWS CLI**
**Para excluir um modelo na API fornecida**
Comando:
```
aws apigateway delete-model --rest-api-id 1234123412 --model-name 'customModel'
```
+ Para ver detalhes da API, consulte [DeleteModel](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-model.html) na *Referência de comandos da AWS CLI*.
### `delete-resource`
O código de exemplo a seguir mostra como usar `delete-resource`.
**AWS CLI**
**Para excluir um recurso em uma API**
Comando:
```
aws apigateway delete-resource --rest-api-id 1234123412 --resource-id a1b2c3
```
+ Para ver detalhes da API, consulte [DeleteResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-resource.html) na *Referência de comandos da AWS CLI*.
### `delete-rest-api`
O código de exemplo a seguir mostra como usar `delete-rest-api`.
**AWS CLI**
**Como excluir uma API**
Comando:
```
aws apigateway delete-rest-api --rest-api-id 1234123412
```
+ Consulte detalhes da API em [DeleteRestApi](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-rest-api.html) na *Referência de comandos da AWS CLI*.
### `delete-stage`
O código de exemplo a seguir mostra como usar `delete-stage`.
**AWS CLI**
**Para excluir um estágio em uma API**
Comando:
```
aws apigateway delete-stage --rest-api-id 1234123412 --stage-name 'dev'
```
+ Para ver detalhes da API, consulte [DeleteStage](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-stage.html) na *Referência de comandos da AWS CLI*.
### `delete-usage-plan-key`
O código de exemplo a seguir mostra como usar `delete-usage-plan-key`.
**AWS CLI**
**Para remover uma chave de API de um plano de uso**
Comando:
```
aws apigateway delete-usage-plan-key --usage-plan-id a1b2c3 --key-id 1NbjQzMReAkeEQPNAW8r3dXsU2rDD7fc7f2Sipnu
```
+ Para ver detalhes da API, consulte [DeleteUsagePlanKey](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-usage-plan-key.html) na *Referência de comandos da AWS CLI*.
### `delete-usage-plan`
O código de exemplo a seguir mostra como usar `delete-usage-plan`.
**AWS CLI**
**Para excluir um plano de uso**
Comando:
```
aws apigateway delete-usage-plan --usage-plan-id a1b2c3
```
+ Para ver detalhes da API, consulte [DeleteUsagePlan](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/delete-usage-plan.html) na *Referência de comandos da AWS CLI*.
### `flush-stage-authorizers-cache`
O código de exemplo a seguir mostra como usar `flush-stage-authorizers-cache`.
**AWS CLI**
**Para limpar todas as entradas do cache do autorizador em um estágio**
Comando:
```
aws apigateway flush-stage-authorizers-cache --rest-api-id 1234123412 --stage-name dev
```
+ Para ver detalhes da API, consulte [FlushStageAuthorizersCache](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/flush-stage-authorizers-cache.html) na *Referência de comandos da AWS CLI*.
### `flush-stage-cache`
O código de exemplo a seguir mostra como usar `flush-stage-cache`.
**AWS CLI**
**Para limpar o cache de um estágio da API**
O exemplo de `flush-stage-cache` a seguir libera o cache de um estágio.
```
aws apigateway flush-stage-cache \
--rest-api-id 1234123412 \
--stage-name dev
```
Este comando não produz saída.
Consulte mais informações em [Liberar o cache de estágio de APIs no API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-caching.html#flush-api-caching) no *Guia do desenvolvedor do Amazon API Gateway*.
+ Para ver detalhes da API, consulte [FlushStageCache](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/flush-stage-cache.html) na *Referência de comandos da AWS CLI*.
### `generate-client-certificate`
O código de exemplo a seguir mostra como usar `generate-client-certificate`.
**AWS CLI**
**Para criar um certificado SSL no lado do cliente**
Comando:
```
aws apigateway generate-client-certificate --description 'My First Client Certificate'
```
+ Para ver detalhes da API, consulte [GenerateClientCertificate](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/generate-client-certificate.html) na *Referência de comandos da AWS CLI*.
### `get-account`
O código de exemplo a seguir mostra como usar `get-account`.
**AWS CLI**
**Para obter as configurações da conta do API Gateway**
Comando:
```
aws apigateway get-account
```
Resultado:
```
{
"cloudwatchRoleArn": "arn:aws:iam::123412341234:role/APIGatewayToCloudWatchLogsRole",
"throttleSettings": {
"rateLimit": 500.0,
"burstLimit": 1000
}
}
```
+ Para ver detalhes da API, consulte [GetAccount](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-account.html) na *Referência de comandos da AWS CLI*.
### `get-api-key`
O código de exemplo a seguir mostra como usar `get-api-key`.
**AWS CLI**
**Para obter informações sobre um uma chave de API específica**
Comando:
```
aws apigateway get-api-key --api-key 8bklk8bl1k3sB38D9B3l0enyWT8c09B30lkq0blk
```
Resultado:
```
{
"description": "My first key",
"enabled": true,
"stageKeys": [
"a1b2c3d4e5/dev",
"e5d4c3b2a1/dev"
],
"lastUpdatedDate": 1456184515,
"createdDate": 1456184452,
"id": "8bklk8bl1k3sB38D9B3l0enyWT8c09B30lkq0blk",
"name": "My key"
}
```
+ Para ver detalhes da API, consulte [GetApiKey](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-api-key.html) na *Referência de comandos da AWS CLI*.
### `get-api-keys`
O código de exemplo a seguir mostra como usar `get-api-keys`.
**AWS CLI**
**Para obter a lista de chaves de API**
Comando:
```
aws apigateway get-api-keys
```
Resultado:
```
{
"items": [
{
"description": "My first key",
"enabled": true,
"stageKeys": [
"a1b2c3d4e5/dev",
"e5d4c3b2a1/dev"
],
"lastUpdatedDate": 1456184515,
"createdDate": 1456184452,
"id": "8bklk8bl1k3sB38D9B3l0enyWT8c09B30lkq0blk",
"name": "My key"
}
]
}
```
+ Para ver detalhes da API, consulte [GetApiKeys](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-api-keys.html) na *Referência de comandos da AWS CLI*.
### `get-authorizer`
O código de exemplo a seguir mostra como usar `get-authorizer`.
**AWS CLI**
**Para obter as configurações do API Gateway por autorizador da API**
Comando:
```
aws apigateway get-authorizer --rest-api-id 1234123412 --authorizer-id gfi4n3
```
Resultado:
```
{
"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"
}
```
+ Para ver detalhes da API, consulte [GetAuthorizer](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-authorizer.html) na *Referência de comandos da AWS CLI*.
### `get-authorizers`
O código de exemplo a seguir mostra como usar `get-authorizers`.
**AWS CLI**
**Para obter a lista de autorizadores de uma API REST**
Comando:
```
aws apigateway get-authorizers --rest-api-id 1234123412
```
Resultado:
```
{
"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"
}
]
}
```
+ Para ver detalhes da API, consulte [GetAuthorizers](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-authorizers.html) na *Referência de comandos da AWS CLI*.
### `get-base-path-mapping`
O código de exemplo a seguir mostra como usar `get-base-path-mapping`.
**AWS CLI**
**Como obter o mapeamento de caminho base para um nome de domínio personalizado**
Comando:
```
aws apigateway get-base-path-mapping --domain-name subdomain.domain.tld --base-path v1
```
Resultado:
```
{
"basePath": "v1",
"restApiId": "1234w4321e",
"stage": "api"
}
```
+ Consulte detalhes da API em [GetBasePathMapping](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-base-path-mapping.html) na *Referência de comandos da AWS CLI*.
### `get-base-path-mappings`
O código de exemplo a seguir mostra como usar `get-base-path-mappings`.
**AWS CLI**
**Para obter os mapeamentos de caminho base para um nome de domínio personalizado**
Comando:
```
aws apigateway get-base-path-mappings --domain-name subdomain.domain.tld
```
Resultado:
```
{
"items": [
{
"basePath": "(none)",
"restApiId": "1234w4321e",
"stage": "dev"
},
{
"basePath": "v1",
"restApiId": "1234w4321e",
"stage": "api"
}
]
}
```
+ Para ver detalhes da API, consulte [GetBasePathMappings](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-base-path-mappings.html) na *Referência de comandos da AWS CLI*.
### `get-client-certificate`
O código de exemplo a seguir mostra como usar `get-client-certificate`.
**AWS CLI**
**Para obter um certificado de cliente**
Comando:
```
aws apigateway get-client-certificate --client-certificate-id a1b2c3
```
+ Para ver detalhes da API, consulte [GetClientCertificate](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-client-certificate.html) na *Referência de comandos da AWS CLI*.
### `get-client-certificates`
O código de exemplo a seguir mostra como usar `get-client-certificates`.
**AWS CLI**
**Para obter uma lista de certificados de clientes**
Comando:
```
aws apigateway get-client-certificates
```
Resultado:
```
{
"items": [
{
"pemEncodedCertificate": "-----BEGIN CERTIFICATE----- -----END CERTIFICATE-----",
"clientCertificateId": "a1b2c3",
"expirationDate": 1483556561,
"description": "My Client Certificate",
"createdDate": 1452020561
}
]
}
```
+ Para ver detalhes da API, consulte [GetClientCertificates](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-client-certificates.html) na *Referência de comandos da AWS CLI*.
### `get-deployment`
O código de exemplo a seguir mostra como usar `get-deployment`.
**AWS CLI**
**Para obter informações sobre uma implantação**
Comando:
```
aws apigateway get-deployment --rest-api-id 1234123412 --deployment-id ztt4m2
```
Resultado:
```
{
"description": "myDeployment",
"id": "ztt4m2",
"createdDate": 1455218022
}
```
+ Para ver detalhes da API, consulte [GetDeployment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-deployment.html) na *Referência de comandos da AWS CLI*.
### `get-deployments`
O código de exemplo a seguir mostra como usar `get-deployments`.
**AWS CLI**
**Para obter uma lista de implantações para uma API REST**
Comando:
```
aws apigateway get-deployments --rest-api-id 1234123412
```
Resultado:
```
{
"items": [
{
"createdDate": 1453797217,
"id": "0a2b4c",
"description": "Deployed my API for the first time"
}
]
}
```
+ Para ver detalhes da API, consulte [GetDeployments](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-deployments.html) na *Referência de comandos da AWS CLI*.
### `get-domain-name-access-associations`
O código de exemplo a seguir mostra como usar `get-domain-name-access-associations`.
**AWS CLI**
**Exemplo 1: como listar todas as associações de acesso a nomes de domínio**
O exemplo de `get-domain-name-access-associations` a seguir lista todas as associações de acesso a nomes de domínio.
```
aws apigateway get-domain-name-access-associations
```
Resultado:
```
{
"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"
}
]
}
```
Consulte mais informações em [Custom domain names for private APIs in API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-custom-domains.html) no *Guia do desenvolvedor do Amazon API Gateway*.
**Exemplo 2: como listar todas as associações de acesso a nomes de domínio pertencentes a esta conta da AWS**
O exemplo de `get-domain-name-access-associations` a seguir lista todas as associações de acesso a nomes de domínio pertencentes à conta da AWS atual.
```
aws apigateway get-domain-name-access-associations \
--resource-owner SELF
```
Resultado:
```
{
"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"
}
]
}
```
Consulte mais informações em [Custom domain names for private APIs in API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-custom-domains.html) no *Guia do desenvolvedor do Amazon API Gateway*.
+ Consulte detalhes da API em [GetDomainNameAccessAssociations](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-domain-name-access-associations.html) na *Referência de comandos da AWS CLI*.
### `get-domain-name`
O código de exemplo a seguir mostra como usar `get-domain-name`.
**AWS CLI**
**Exemplo 1: como obter informações sobre um nome de domínio público personalizado**
O exemplo de `get-domain-name` a seguir obtém informações sobre um nome de domínio público personalizado.
```
aws apigateway get-domain-name \
--domain-name api.domain.tld
```
Resultado:
```
{
"domainName": "api.domain.tld",
"distributionDomainName": "d1a2f3a4c5o6d.cloudfront.net",
"certificateName": "uploadedCertificate",
"certificateUploadDate": 1462565487
}
```
Consulte mais informações em [Nome de domínio personalizado para APIs REST no API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-custom-domains.html) no *Guia do desenvolvedor do Amazon API Gateway*.
**Exemplo 2: como obter informações sobre um nome de domínio privado personalizado**
O exemplo de `get-domain-name` a seguir obtém informações sobre um nome de domínio privado personalizado.
```
aws apigateway get-domain-name \
--domain-name api.private.domain.tld \
--domain-name-id abcd1234
```
Resultado:
```
{
"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\"}}}]}"
}
```
Consulte mais informações em [Nome de domínio personalizado para APIs REST no API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-custom-domains.html) no *Guia do desenvolvedor do Amazon API Gateway*.
+ Para ver detalhes da API, consulte [GetDomainName](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-domain-name.html) na *Referência de comandos da AWS CLI*.
### `get-domain-names`
O código de exemplo a seguir mostra como usar `get-domain-names`.
**AWS CLI**
**Exemplo 1: como obter uma lista de nomes de domínio personalizados**
O comando `get-domain-names` a seguir obtém uma lista de nomes de domínio.
```
aws apigateway get-domain-names
```
Resultado:
```
{
"items": [
{
"distributionDomainName": "d9511k3l09bkd.cloudfront.net",
"certificateUploadDate": 1452812505,
"certificateName": "my_custom_domain-certificate",
"domainName": "subdomain.domain.tld"
}
]
}
```
Consulte mais informações em [Custom domain names for private APIs in API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-custom-domains.html) no *Guia do desenvolvedor do Amazon API Gateway*.
**Exemplo 2: como obter uma lista de nomes de domínio personalizados pertencentes a esta conta da AWS**
O comando `get-domain-names` a seguir obtém uma lista de nomes de domínio pertencentes a esta conta da AWS.
```
aws apigateway get-domain-names \
--resource-owner SELF
```
Resultado:
```
{
"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"
}
]
}
```
Consulte mais informações em [Custom domain names for private APIs in API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-custom-domains.html) no *Guia do desenvolvedor do Amazon API Gateway*.
**Exemplo 3: como obter uma lista de nomes de domínio personalizados pertencentes a outras contas da AWS com as quais você pode criar uma associação de acesso a nomes de domínio**
O comando `get-domain-names` a seguir obtém uma lista de nomes de domínio pertencentes a outras contas da AWS com as quais você tem permissão para criar uma associação de acesso a nomes de domínio.
```
aws apigateway get-domain-names \
--resource-owner OTHER_ACCOUNTS
```
Resultado:
```
{
"items": [
{
"domainName": "my.private.domain.tld",
"domainNameId": "abcd1234",
"domainNameArn": "arn:aws:apigateway:us-east-1:012345678910:/domainnames/my.private.domain.tld+abcd1234"
}
]
}
```
Consulte mais informações em [Custom domain names for private APIs in API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-custom-domains.html) no *Guia do desenvolvedor do Amazon API Gateway*.
+ Para ver detalhes da API, consulte [GetDomainNames](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-domain-names.html) na *Referência de comandos da AWS CLI*.
### `get-export`
O código de exemplo a seguir mostra como usar `get-export`.
**AWS CLI**
**Para obter o modelo do Swagger JSON de um estágio**
Comando:
```
aws apigateway get-export --rest-api-id a1b2c3d4e5 --stage-name dev --export-type swagger /path/to/filename.json
```
**Como obter o modelo Swagger JSON \$1 extensões do API Gateway para um estágio**
Comando:
```
aws apigateway get-export --parameters extensions='integrations' --rest-api-id a1b2c3d4e5 --stage-name dev --export-type swagger /path/to/filename.json
```
**Para obter o modelo Swagger JSON \$1 Postman Extensions para um estágio**
Comando:
```
aws apigateway get-export --parameters extensions='postman' --rest-api-id a1b2c3d4e5 --stage-name dev --export-type swagger /path/to/filename.json
```
+ Para ver detalhes da API, consulte [GetExport](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-export.html) na *Referência de comandos da AWS CLI*.
### `get-integration-response`
O código de exemplo a seguir mostra como usar `get-integration-response`.
**AWS CLI**
**Para obter a configuração da resposta de integração para um método HTTP definido no recurso da API REST**
Comando:
```
aws apigateway get-integration-response --rest-api-id 1234123412 --resource-id y9h6rt --http-method GET --status-code 200
```
Resultado:
```
{
"statusCode": "200",
"responseTemplates": {
"application/json": null
}
}
```
+ Para ver detalhes da API, consulte [GetIntegrationResponse](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-integration-response.html) na *Referência de comandos da AWS CLI*.
### `get-integration`
O código de exemplo a seguir mostra como usar `get-integration`.
**AWS CLI**
**Para obter a configuração de integração para um método HTTP definido no recurso da API REST**
Comando:
```
aws apigateway get-integration --rest-api-id 1234123412 --resource-id y9h6rt --http-method GET
```
Resultado:
```
{
"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"
}
```
+ Para ver detalhes da API, consulte [GetIntegration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-integration.html) na *Referência de comandos da AWS CLI*.
### `get-method-response`
O código de exemplo a seguir mostra como usar `get-method-response`.
**AWS CLI**
**Para obter a configuração do recurso de resposta do método para um método HTTP definido no recurso da API REST**
Comando:
```
aws apigateway get-method-response --rest-api-id 1234123412 --resource-id y9h6rt --http-method GET --status-code 200
```
Resultado:
```
{
"responseModels": {
"application/json": "Empty"
},
"statusCode": "200"
}
```
+ Para ver detalhes da API, consulte [GetMethodResponse](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-method-response.html) na *Referência de comandos da AWS CLI*.
### `get-method`
O código de exemplo a seguir mostra como usar `get-method`.
**AWS CLI**
**Para obter a configuração do recurso de método para um método HTTP definido no recurso da API REST**
Comando:
```
aws apigateway get-method --rest-api-id 1234123412 --resource-id y9h6rt --http-method GET
```
Resultado:
```
{
"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"
}
```
+ Para ver detalhes da API, consulte [GetMethod](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-method.html) na *Referência de comandos da AWS CLI*.
### `get-model-template`
O código de exemplo a seguir mostra como usar `get-model-template`.
**AWS CLI**
**Para obter o modelo de mapeamento para um modelo definido em uma API REST**
Comando:
```
aws apigateway get-model-template --rest-api-id 1234123412 --model-name Empty
```
Resultado:
```
{
"value": "#set($inputRoot = $input.path('$'))\n{ }"
}
```
+ Para ver detalhes da API, consulte [GetModelTemplate](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-model-template.html) na *Referência de comandos da AWS CLI*.
### `get-model`
O código de exemplo a seguir mostra como usar `get-model`.
**AWS CLI**
**Para obter a configuração de um modelo definido em uma API REST**
Comando:
```
aws apigateway get-model --rest-api-id 1234123412 --model-name Empty
```
Resultado:
```
{
"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}"
}
```
+ Para ver detalhes da API, consulte [GetModel](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-model.html) na *Referência de comandos da AWS CLI*.
### `get-models`
O código de exemplo a seguir mostra como usar `get-models`.
**AWS CLI**
**Para obter uma lista de modelos de uma API REST**
Comando:
```
aws apigateway get-models --rest-api-id 1234123412
```
Resultado:
```
{
"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"
}
]
}
```
+ Para ver detalhes da API, consulte [GetModels](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-models.html) na *Referência de comandos da AWS CLI*.
### `get-resource`
O código de exemplo a seguir mostra como usar `get-resource`.
**AWS CLI**
**Para obter informações sobre um recurso**
Comando:
```
aws apigateway get-resource --rest-api-id 1234123412 --resource-id zwo0y3
```
Resultado:
```
{
"path": "/path",
"pathPart": "path",
"id": "zwo0y3",
"parentId": "uyokt6ij2g"
}
```
+ Para ver detalhes da API, consulte [GetResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-resource.html) na *Referência de comandos da AWS CLI*.
### `get-resources`
O código de exemplo a seguir mostra como usar `get-resources`.
**AWS CLI**
**Como obter uma lista de recursos para uma API REST**
Comando:
```
aws apigateway get-resources --rest-api-id 1234123412
```
Resultado:
```
{
"items": [
{
"path": "/resource/subresource",
"resourceMethods": {
"POST": {}
},
"id": "024ace",
"pathPart": "subresource",
"parentId": "ai5b02"
}
]
}
```
+ Consulte detalhes da API em [GetResources](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-resources.html) na *Referência de comandos da AWS CLI*.
### `get-rest-api`
O código de exemplo a seguir mostra como usar `get-rest-api`.
**AWS CLI**
**Para obter informações sobre uma API**
Comando:
```
aws apigateway get-rest-api --rest-api-id 1234123412
```
Resultado:
```
{
"name": "myAPI",
"id": "o1y243m4f5",
"createdDate": 1453416433
}
```
+ Para ver detalhes da API, consulte [GetRestApi](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-rest-api.html) na *Referência de comandos da AWS CLI*.
### `get-rest-apis`
O código de exemplo a seguir mostra como usar `get-rest-apis`.
**AWS CLI**
**Como obter uma lista de APIs REST**
Comando:
```
aws apigateway get-rest-apis
```
Resultado:
```
{
"items": [
{
"createdDate": 1438884790,
"id": "12s44z21rb",
"name": "My First API"
}
]
}
```
+ Consulte detalhes da API em [GetRestApis](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-rest-apis.html) na *Referência de comandos da AWS CLI*.
### `get-sdk`
O código de exemplo a seguir mostra como usar `get-sdk`.
**AWS CLI**
**Para obter o SDK para Android de um estágio da API REST**
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
```
Resultado:
```
{
"contentType": "application/octet-stream",
"contentDisposition": "attachment; filename=\"android_2016-02-22_23-52Z.zip\""
}
```
**Para obter o SDK para iOS de um estágio da API REST**
Comando:
```
aws apigateway get-sdk --rest-api-id 1234123412 --stage-name dev --sdk-type objectivec --parameters classPrefix='myprefix' /path/to/iOS_sdk.zip
```
Resultado:
```
{
"contentType": "application/octet-stream",
"contentDisposition": "attachment; filename=\"objectivec_2016-02-22_23-52Z.zip\""
}
```
**Para obter o SDK para Javascript de um estágio da API REST**
Comando:
```
aws apigateway get-sdk --rest-api-id 1234123412 --stage-name dev --sdk-type javascript /path/to/javascript_sdk.zip
```
Resultado:
```
{
"contentType": "application/octet-stream",
"contentDisposition": "attachment; filename=\"javascript_2016-02-22_23-52Z.zip\""
}
```
+ Para ver detalhes da API, consulte [GetSdk](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-sdk.html) na *Referência de comandos da AWS CLI*.
### `get-stage`
O código de exemplo a seguir mostra como usar `get-stage`.
**AWS CLI**
**Para obter informações sobre o estágio de uma API**
Comando:
```
aws apigateway get-stage --rest-api-id 1234123412 --stage-name dev
```
Resultado:
```
{
"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
}
}
}
```
+ Para ver detalhes da API, consulte [GetStage](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-stage.html) na *Referência de comandos da AWS CLI*.
### `get-stages`
O código de exemplo a seguir mostra como usar `get-stages`.
**AWS CLI**
**Para obter a lista de estágios de uma API REST**
Comando:
```
aws apigateway get-stages --rest-api-id 1234123412
```
Resultado:
```
{
"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
}
}
}
]
}
```
+ Para ver detalhes da API, consulte [GetStages](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-stages.html) na *Referência de comandos da AWS CLI*.
### `get-usage-plan-key`
O código de exemplo a seguir mostra como usar `get-usage-plan-key`.
**AWS CLI**
**Para obter os detalhes de uma chave de API associada a um plano de uso**
Comando:
```
aws apigateway get-usage-plan-key --usage-plan-id a1b2c3 --key-id 1NbjQzMReAkeEQPNAW8r3dXsU2rDD7fc7f2Sipnu
```
+ Para ver detalhes da API, consulte [GetUsagePlanKey](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-usage-plan-key.html) na *Referência de comandos da AWS CLI*.
### `get-usage-plan-keys`
O código de exemplo a seguir mostra como usar `get-usage-plan-keys`.
**AWS CLI**
**Para obter a lista de chaves de API associadas a um plano de uso**
Comando:
```
aws apigateway get-usage-plan-keys --usage-plan-id a1b2c3
```
+ Para ver detalhes da API, consulte [GetUsagePlanKeys](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-usage-plan-keys.html) na *Referência de comandos da AWS CLI*.
### `get-usage-plan`
O código de exemplo a seguir mostra como usar `get-usage-plan`.
**AWS CLI**
**Para obter os detalhes de um plano de uso**
Comando:
```
aws apigateway get-usage-plan --usage-plan-id a1b2c3
```
+ Para ver detalhes da API, consulte [GetUsagePlan](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-usage-plan.html) na *Referência de comandos da AWS CLI*.
### `get-usage-plans`
O código de exemplo a seguir mostra como usar `get-usage-plans`.
**AWS CLI**
**Para obter os detalhes de todos os planos de uso**
Comando:
```
aws apigateway get-usage-plans
```
+ Para ver detalhes da API, consulte [GetUsagePlans](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-usage-plans.html) na *Referência de comandos da AWS CLI*.
### `get-usage`
O código de exemplo a seguir mostra como usar `get-usage`.
**AWS CLI**
**Para obter os detalhes de uso de um plano de uso**
Comando:
```
aws apigateway get-usage --usage-plan-id a1b2c3 --start-date "2016-08-16" --end-date "2016-08-17"
```
+ Para ver detalhes da API, consulte [GetUsage](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/get-usage.html) na *Referência de comandos da AWS CLI*.
### `import-rest-api`
O código de exemplo a seguir mostra como usar `import-rest-api`.
**AWS CLI**
**Para importar um modelo do Swagger e criar uma API**
Comando:
```
aws apigateway import-rest-api --body 'file:///path/to/API_Swagger_template.json'
```
+ Para ver detalhes da API, consulte [ImportRestApi](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/import-rest-api.html) na *Referência de comandos da AWS CLI*.
### `put-integration-response`
O código de exemplo a seguir mostra como usar `put-integration-response`.
**AWS CLI**
**Como criar uma resposta de integração como a resposta padrão com um modelo de mapeamento definido**
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\"}"}'
```
**Como criar uma resposta de integração com um regex de 400 e um valor de cabeçalho definido de forma estática**
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'"'"'"}'
```
+ Consulte detalhes da API em [PutIntegrationResponse](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/put-integration-response.html) na *Referência de comandos da AWS CLI*.
### `put-integration`
O código de exemplo a seguir mostra como usar `put-integration`.
**AWS CLI**
**Como criar uma solicitação de integração MOCK**
Comando:
```
aws apigateway put-integration --rest-api-id 1234123412 --resource-id a1b2c3 --http-method GET --type MOCK --request-templates '{ "application/json": "{\"statusCode\": 200}" }'
```
**Como criar uma solicitação de integração 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'
```
**Como criar uma solicitação de integração da AWS com um endpoint da função do 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'
```
+ Consulte detalhes da API em [PutIntegration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/put-integration.html) na *Referência de comandos da AWS CLI*.
### `put-method-response`
O código de exemplo a seguir mostra como usar `put-method-response`.
**AWS CLI**
**Como criar uma resposta de método de acordo com o código de status especificado com um cabeçalho de resposta de método personalizado**
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"
```
+ Consulte detalhes da API em [PutMethodResponse](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/put-method-response.html) na *Referência de comandos da AWS CLI*.
### `put-method`
O código de exemplo a seguir mostra como usar `put-method`.
**AWS CLI**
**Como criar um método para um recurso em uma API sem autorização, sem chave de API e com um cabeçalho de solicitação de método personalizado**
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"
```
+ Consulte detalhes da API em [PutMethod](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/put-method.html) na *Referência de comandos da AWS CLI*.
### `put-rest-api`
O código de exemplo a seguir mostra como usar `put-rest-api`.
**AWS CLI**
**Para substituir uma API existente usando um modelo Swagger**
Comando:
```
aws apigateway put-rest-api --rest-api-id 1234123412 --mode overwrite --body 'fileb:///path/to/API_Swagger_template.json'
```
**Para mesclar um modelo do Swagger em uma API existente**
Comando:
```
aws apigateway put-rest-api --rest-api-id 1234123412 --mode merge --body 'fileb:///path/to/API_Swagger_template.json'
```
+ Para ver detalhes da API, consulte [PutRestApi](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/put-rest-api.html) na *Referência de comandos da AWS CLI*.
### `reject-domain-name-access-association`
O código de exemplo a seguir mostra como usar `reject-domain-name-access-association`.
**AWS CLI**
**Como rejeitar uma associação de acesso ao nome de domínio**
O exemplo de `reject-domain-name-access-association` a seguir rejeita uma associação de acesso ao nome de domínio entre um nome de domínio personalizado privado e um endpoint da 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
```
Este comando não produz saída.
Consulte mais informações em [Custom domain names for private APIs in API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-private-custom-domains.html) no *Guia do desenvolvedor do Amazon API Gateway*.
+ Consulte detalhes da API em [RejectDomainNameAccessAssociation](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/reject-domain-name-access-association.html) na *Referência de comandos da AWS CLI*.
### `test-invoke-authorizer`
O código de exemplo a seguir mostra como usar `test-invoke-authorizer`.
**AWS CLI**
**Para testar a invocação de uma solicitação para um autorizador personalizado, incluindo o cabeçalho e o valor necessários**
Comando:
```
aws apigateway test-invoke-authorizer --rest-api-id 1234123412 --authorizer-id 5yid1t --headers Authorization='Value'
```
+ Para ver detalhes da API, consulte [TestInvokeAuthorizer](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/test-invoke-authorizer.html) na *Referência de comandos da AWS CLI*.
### `test-invoke-method`
O código de exemplo a seguir mostra como usar `test-invoke-method`.
**AWS CLI**
**Para testar a invocação do recurso raiz em uma API fazendo uma solicitação GET**
Comando:
```
aws apigateway test-invoke-method --rest-api-id 1234123412 --resource-id avl5sg8fw8 --http-method GET --path-with-query-string '/'
```
**Para testar a invocação de um sub-recurso em uma API fazendo uma solicitação GET com um valor de parâmetro de caminho especificado**
Comando:
```
aws apigateway test-invoke-method --rest-api-id 1234123412 --resource-id 3gapai --http-method GET --path-with-query-string '/pets/1'
```
+ Para ver detalhes da API, consulte [TestInvokeMethod](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/test-invoke-method.html) na *Referência de comandos da AWS CLI*.
### `update-account`
O código de exemplo a seguir mostra como usar `update-account`.
**AWS CLI**
**Para alterar o ARN do perfil do IAM para registro em log no CloudWatch Logs**
Comando:
```
aws apigateway update-account --patch-operations op='replace',path='/cloudwatchRoleArn',value='arn:aws:iam::123412341234:role/APIGatewayToCloudWatchLogs'
```
Resultado:
```
{
"cloudwatchRoleArn": "arn:aws:iam::123412341234:role/APIGatewayToCloudWatchLogs",
"throttleSettings": {
"rateLimit": 1000.0,
"burstLimit": 2000
}
}
```
+ Para ver detalhes da API, consulte [UpdateAccount](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-account.html) na *Referência de comandos da AWS CLI*.
### `update-api-key`
O código de exemplo a seguir mostra como usar `update-api-key`.
**AWS CLI**
**Para alterar o nome de uma chave de API**
Comando:
```
aws apigateway update-api-key --api-key sNvjQDMReA1eEQPNAW8r37XsU2rDD7fc7m2SiMnu --patch-operations op='replace',path='/name',value='newName'
```
Resultado:
```
{
"description": "currentDescription",
"enabled": true,
"stageKeys": [
"41t2j324r5/dev"
],
"lastUpdatedDate": 1470086052,
"createdDate": 1445460347,
"id": "sNvjQDMReA1vEQPNzW8r3dXsU2rrD7fcjm2SiMnu",
"name": "newName"
}
```
**Para desativar a chave de API**
Comando:
```
aws apigateway update-api-key --api-key sNvjQDMReA1eEQPNAW8r37XsU2rDD7fc7m2SiMnu --patch-operations op='replace',path='/enabled',value='false'
```
Resultado:
```
{
"description": "currentDescription",
"enabled": false,
"stageKeys": [
"41t2j324r5/dev"
],
"lastUpdatedDate": 1470086052,
"createdDate": 1445460347,
"id": "sNvjQDMReA1vEQPNzW8r3dXsU2rrD7fcjm2SiMnu",
"name": "newName"
}
```
+ Para ver detalhes da API, consulte [UpdateApiKey](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-api-key.html) na *Referência de comandos da AWS CLI*.
### `update-authorizer`
O código de exemplo a seguir mostra como usar `update-authorizer`.
**AWS CLI**
**Para alterar o nome do autorizador personalizado**
Comando:
```
aws apigateway update-authorizer --rest-api-id 1234123412 --authorizer-id gfi4n3 --patch-operations op='replace',path='/name',value='testAuthorizer'
```
Resultado:
```
{
"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"
}
```
**Para alterar a função do Lambda que é invocada pelo autorizador personalizado**
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'
```
Resultado:
```
{
"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"
}
```
+ Para ver detalhes da API, consulte [UpdateAuthorizer](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-authorizer.html) na *Referência de comandos da AWS CLI*.
### `update-base-path-mapping`
O código de exemplo a seguir mostra como usar `update-base-path-mapping`.
**AWS CLI**
**Como alterar o caminho base de um nome de domínio personalizado**
Comando:
```
aws apigateway update-base-path-mapping --domain-name api.domain.tld --base-path prod --patch-operations op='replace',path='/basePath',value='v1'
```
Resultado:
```
{
"basePath": "v1",
"restApiId": "1234123412",
"stage": "api"
}
```
+ Consulte detalhes da API em [UpdateBasePathMapping](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-base-path-mapping.html) na *Referência de comandos da AWS CLI*.
### `update-client-certificate`
O código de exemplo a seguir mostra como usar `update-client-certificate`.
**AWS CLI**
**Para atualizar a descrição de um certificado de cliente**
Comando:
```
aws apigateway update-client-certificate --client-certificate-id a1b2c3 --patch-operations op='replace',path='/description',value='My new description'
```
+ Para ver detalhes da API, consulte [UpdateClientCertificate](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-client-certificate.html) na *Referência de comandos da AWS CLI*.
### `update-deployment`
O código de exemplo a seguir mostra como usar `update-deployment`.
**AWS CLI**
**Para alterar a descrição de uma implantação**
Comando:
```
aws apigateway update-deployment --rest-api-id 1234123412 --deployment-id ztt4m2 --patch-operations op='replace',path='/description',value='newDescription'
```
Resultado:
```
{
"description": "newDescription",
"id": "ztt4m2",
"createdDate": 1455218022
}
```
+ Para ver detalhes da API, consulte [UpdateDeployment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-deployment.html) na *Referência de comandos da AWS CLI*.
### `update-domain-name`
O código de exemplo a seguir mostra como usar `update-domain-name`.
**AWS CLI**
**Para alterar o nome do certificado para um nome de domínio personalizado**
O exemplo `update-domain-name` a seguir cria o nome de certificado para um domínio personalizado.
```
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'
```
Resultado:
```
{
"domainName": "api.domain.tld",
"distributionDomainName": "d123456789012.cloudfront.net",
"certificateArn": "arn:aws:acm:us-west-2:111122223333:certificate/CERTEXAMPLE123EXAMPLE",
"certificateUploadDate": 1462565487
}
```
Para obter mais informações, consulte [Configurar um nome de domínio personalizado para uma API no API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-custom-domains.html) no *Guia do desenvolvedor do Amazon API Gateway*.
+ Para ver detalhes da API, consulte [UpdateDomainName](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-domain-name.html) na *Referência de comandos da AWS CLI*.
### `update-integration-response`
O código de exemplo a seguir mostra como usar `update-integration-response`.
**AWS CLI**
**Para alterar um cabeçalho de resposta de integração para ter um mapeamento estático de '\$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='"'"'*'"'"'
```
Resultado:
```
{
"statusCode": "200",
"responseParameters": {
"method.response.header.Access-Control-Allow-Origin": "'*'"
}
}
```
**Para remover um cabeçalho de resposta de integração**
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'
```
+ Para ver detalhes da API, consulte [UpdateIntegrationResponse](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-integration-response.html) na *Referência de comandos da AWS CLI*.
### `update-integration`
O código de exemplo a seguir mostra como usar `update-integration`.
**AWS CLI**
**Para adicionar o modelo de mapeamento “Content-Type: application/json” configurado com passagem de entrada**
Comando:
```
aws apigateway update-integration \
--rest-api-id a1b2c3d4e5 \
--resource-id a1b2c3 \
--http-method POST \
--patch-operations "op='add',path='/requestTemplates/application~1json'"
```
**Para atualizar (substituir) o modelo de mapeamento “Content-Type: application/json” configurado por um modelo personalizado**
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"}'"
```
**Para atualizar (substituir) um modelo personalizado associado a “Content-Type: application/json” com Passthrough de entrada**
Comando:
```
aws apigateway update-integration \
--rest-api-id a1b2c3d4e5 \
--resource-id a1b2c3 \
--http-method POST \
--patch-operations "op='replace',path='requestTemplates/application~1json'"
```
**Para remover o modelo de mapeamento “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'"
```
+ Para ver detalhes da API, consulte [UpdateIntegration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-integration.html) na *Referência de comandos da AWS CLI*.
### `update-method-response`
O código de exemplo a seguir mostra como usar `update-method-response`.
**AWS CLI**
**Para criar um novo cabeçalho de resposta do método para a resposta 200 em um método e defini-lo como não obrigatório (padrão)**
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"
```
**Para excluir um modelo de resposta para a resposta 200 em um método**
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"
```
+ Para ver detalhes da API, consulte [UpdateMethodResponse](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-method-response.html) na *Referência de comandos da AWS CLI*.
### `update-method`
O código de exemplo a seguir mostra como usar `update-method`.
**AWS CLI**
**Exemplo 1: modificar um método para exigir uma chave de API**
O exemplo `update-method` a seguir modifica o método para exigir uma chave de API.
```
aws apigateway update-method \
--rest-api-id 1234123412 \
--resource-id a1b2c3 \
--http-method GET \
--patch-operations op="replace",path="/apiKeyRequired",value="true"
```
Resultado:
```
{
"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": {}
}
}
}
}
```
**Exemplo 2: modificar um método para exigir autorização do IAM**
O exemplo `update-method` a seguir modifica o método para exigir autorização do IAM.
```
aws apigateway update-method \
--rest-api-id 1234123412 \
--resource-id a1b2c3 \
--http-method GET \
--patch-operations op="replace",path="/authorizationType",value="AWS_IAM"
```
Resultado:
```
{
"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": {}
}
}
}
}
```
**Exemplo 3: modificar um método para exigir autorização do Lambda**
O exemplo `update-method` a seguir modifica o método para a autorização do Lambda necessária.
```
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"
```
Resultado:
```
{
"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": {}
}
}
}
}
```
Para obter mais informações, consulte [Criar, configurar e testar planos de uso usando a CLI do API Gateway e a API REST](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-create-usage-plans-with-rest-api.html) e [Como controlar e gerenciar o acesso a uma API REST no API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-control-access-to-api.html) no *Guia do desenvolvedor do Amazon API Gateway*.
+ Para ver detalhes da API, consulte [UpdateMethod](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-method.html) na *Referência de comandos da AWS CLI*.
### `update-model`
O código de exemplo a seguir mostra como usar `update-model`.
**AWS CLI**
**Para alterar a descrição de um modelo em uma API**
Comando:
```
aws apigateway update-model --rest-api-id 1234123412 --model-name 'Empty' --patch-operations op=replace,path=/description,value='New Description'
```
**Para alterar o esquema de um modelo em uma 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\" }"'
```
+ Para ver detalhes da API, consulte [UpdateModel](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-model.html) na *Referência de comandos da AWS CLI*.
### `update-resource`
O código de exemplo a seguir mostra como usar `update-resource`.
**AWS CLI**
**Para mover um recurso e colocá-lo em um recurso principal diferente em uma API**
Comando:
```
aws apigateway update-resource --rest-api-id 1234123412 --resource-id 1a2b3c --patch-operations op=replace,path=/parentId,value='3c2b1a'
```
Resultado:
```
{
"path": "/resource",
"pathPart": "resource",
"id": "1a2b3c",
"parentId": "3c2b1a"
}
```
**Para renomear um recurso (pathPart) em uma API**
Comando:
```
aws apigateway update-resource --rest-api-id 1234123412 --resource-id 1a2b3c --patch-operations op=replace,path=/pathPart,value=newresourcename
```
Resultado:
```
{
"path": "/newresourcename",
"pathPart": "newresourcename",
"id": "1a2b3c",
"parentId": "3c2b1a"
}
```
+ Para ver detalhes da API, consulte [UpdateResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-resource.html) na *Referência de comandos da AWS CLI*.
### `update-rest-api`
O código de exemplo a seguir mostra como usar `update-rest-api`.
**AWS CLI**
**Para alterar o nome de uma API**
Comando:
```
aws apigateway update-rest-api --rest-api-id 1234123412 --patch-operations op=replace,path=/name,value='New Name'
```
**Para alterar a descrição de uma API**
Comando:
```
aws apigateway update-rest-api --rest-api-id 1234123412 --patch-operations op=replace,path=/description,value='New Description'
```
+ Para ver detalhes da API, consulte [UpdateRestApi](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-rest-api.html) na *Referência de comandos da AWS CLI*.
### `update-stage`
O código de exemplo a seguir mostra como usar `update-stage`.
**AWS CLI**
**Exemplo 1: substituir as configurações do estágio de um recurso e método**
O exemplo `update-stage` a seguir substitui as configurações do estágio e desativa o registro em log completo de solicitação/resposta para um recurso e método específicos.
```
aws apigateway update-stage \
--rest-api-id 1234123412 \
--stage-name 'dev' \
--patch-operations op=replace,path=/~1resourceName/GET/logging/dataTrace,value=false
```
Resultado:
```
{
"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"
}
```
Para obter mais informações, consulte [Como configurar um estágio em uma API REST](https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-stages.html) no *Guia do desenvolvedor do Amazon API Gateway*.
**Exemplo 2: atualizar as configurações do estágio para todos os recursos e métodos de um estágio de API**
O exemplo `update-stage` a seguir ativa o registro em log completo de solicitações/respostas para todos os recursos e métodos de um estágio de API.
```
aws apigateway update-stage \
--rest-api-id 1234123412 \
--stage-name 'dev' \
--patch-operations 'op=replace,path=/*/*/logging/dataTrace,value=true'
```
Resultado:
```
{
"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"
}
```
Para obter mais informações, consulte [Como configurar um estágio em uma API REST](https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-stages.html) no *Guia do desenvolvedor do Amazon API Gateway*.
+ Para ver detalhes da API, consulte [UpdateStage](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-stage.html) na *Referência de comandos da AWS CLI*.
### `update-usage-plan`
O código de exemplo a seguir mostra como usar `update-usage-plan`.
**AWS CLI**
**Para alterar o período definido em um plano de uso**
Comando:
```
aws apigateway update-usage-plan --usage-plan-id a1b2c3 --patch-operations op="replace",path="/quota/period",value="MONTH"
```
**Para alterar o limite de cota definido em um plano de uso**
Comando:
```
aws apigateway update-usage-plan --usage-plan-id a1b2c3 --patch-operations op="replace",path="/quota/limit",value="500"
```
**Para alterar o limite da taxa de controle de utilização definido em um plano de uso**
Comando:
```
aws apigateway update-usage-plan --usage-plan-id a1b2c3 --patch-operations op="replace",path="/throttle/rateLimit",value="10"
```
**Para alterar o limite de pico de controle de utilização definido em um plano de uso**
Comando:
```
aws apigateway update-usage-plan --usage-plan-id a1b2c3 --patch-operations op="replace",path="/throttle/burstLimit",value="20"
```
+ Para ver detalhes da API, consulte [UpdateUsagePlan](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-usage-plan.html) na *Referência de comandos da AWS CLI*.
### `update-usage`
O código de exemplo a seguir mostra como usar `update-usage`.
**AWS CLI**
**Para modificar temporariamente a cota em uma chave de API para o período atual definido no plano de uso**
Comando:
```
aws apigateway update-usage --usage-plan-id a1b2c3 --key-id 1NbjQzMReAkeEQPNAW8r3dXsU2rDD7fc7f2Sipnu --patch-operations op="replace",path="/remaining",value="50"
```
+ Para ver detalhes da API, consulte [UpdateUsage](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-usage.html) na *Referência de comandos da AWS CLI*.
### `update-vpc-link`
O código de exemplo a seguir mostra como usar `update-vpc-link`.
**AWS CLI**
**Exemplo 1: atualizar o nome de um link existente da VPC**
O exemplo de `update-vpc-link` a seguir atualiza o nome do link especificado da VPC.
```
aws apigateway update-vpc-link \
--vpc-link-id ab3de6 \
--patch-operations op=replace,path=/name,value=my-vpc-link
```
Resultado:
```
{
"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": {}
}
```
Para ter mais informações, consulte [update-vpc-link](https://docs.aws.amazon.com/cli/latest/reference/apigateway/update-vpc-link.html) na *Referência de comandos da AWS CLI*.
**Exemplo 2: atualizar o nome e a descrição de um link existente da VPC**
O exemplo de `update-vpc-link` a seguir atualiza o nome do link especificado da VPC.
```
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"
```
Resultado:
```
{
"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": {}
}
```
Para ter mais informações, consulte [update-vpc-link](https://docs.aws.amazon.com/cli/latest/reference/apigateway/update-vpc-link.html) na *Referência de comandos da AWS CLI*.
+ Para ver detalhes da API, consulte [UpdateVpcLink](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigateway/update-vpc-link.html) na *Referência de comandos da AWS CLI*.