# Exemplos de HTTP do API Gateway e API de WebSocket usando a AWS CLI
<a name="cli_apigatewayv2_code_examples"></a>

Os exemplos de código a seguir mostram como realizar ações e implementar cenários comuns usando o AWS Command Line Interface com HTTP do API Gateway e API de WebSocket.

*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
<a name="actions"></a>

### `create-api-mapping`
<a name="apigatewayv2_CreateApiMapping_cli_topic"></a>

O código de exemplo a seguir mostra como usar `create-api-mapping`.

**AWS CLI**  
**Para criar um mapeamento de API para uma API**  
O exemplo `create-api-mapping` a seguir mapeia o estágio `test` de uma API para o caminho `/myApi` do nome de domínio personalizado `regional.example.com`.  

```
aws apigatewayv2 create-api-mapping \
    --domain-name regional.example.com \
    --api-mapping-key myApi \
    --api-id a1b2c3d4 \
    --stage test
```
Resultado:  

```
{
    "ApiId": "a1b2c3d4",
    "ApiMappingId": "0qzs2sy7bh",
    "ApiMappingKey": "myApi"
    "Stage": "test"
}
```
Para obter mais informações, consulte [Configurar um nome de domínio personalizado regional no API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-regional-api-custom-domain-create.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [CreateApiMapping](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/create-api-mapping.html) na *Referência de comandos da AWS CLI*. 

### `create-api`
<a name="apigatewayv2_CreateApi_cli_topic"></a>

O código de exemplo a seguir mostra como usar `create-api`.

**AWS CLI**  
**Para criar uma API HTTP**  
O exemplo `create-api` a seguir cria uma API HTTP usando a criação rápida. É possível usar a criação rápida para criar uma API com uma integração do AWS Lambda ou HTTP, uma rota padrão genérica e um estágio padrão configurado para implantar alterações automaticamente. O comando a seguir usa criação rápida para criar uma API HTTP que se integra com uma função do Lambda.  

```
aws apigatewayv2 create-api \
    --name my-http-api \
    --protocol-type HTTP \
    --target arn:aws:lambda:us-west-2:123456789012:function:my-lambda-function
```
Resultado:  

```
{
    "ApiEndpoint": "https://a1b2c3d4.execute-api.us-west-2.amazonaws.com",
    "ApiId": "a1b2c3d4",
    "ApiKeySelectionExpression": "$request.header.x-api-key",
    "CreatedDate": "2020-04-08T19:05:45+00:00",
    "Name": "my-http-api",
    "ProtocolType": "HTTP",
    "RouteSelectionExpression": "$request.method $request.path"
}
```
Para obter mais informações, consulte [Desenvolver uma API HTTP no API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
**Para criar uma API de WebSocket**  
O exemplo `create-api` a seguir cria uma API de WebSocket com o nome especificado.  

```
aws apigatewayv2 create-api \
    --name "myWebSocketApi" \
    --protocol-type WEBSOCKET \
    --route-selection-expression '$request.body.action'
```
Resultado:  

```
{
    "ApiKeySelectionExpression": "$request.header.x-api-key",
    "Name": "myWebSocketApi",
    "CreatedDate": "2018-11-15T06:23:51Z",
    "ProtocolType": "WEBSOCKET",
    "RouteSelectionExpression": "'$request.body.action'",
    "ApiId": "aabbccddee"
}
```
Para obter mais informações, consulte [Criar uma API de WebSocket no API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-websocket-api-create-empty-api.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [CreateApi](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/create-api.html) na *Referência de comandos da AWS CLI*. 

### `create-authorizer`
<a name="apigatewayv2_CreateAuthorizer_cli_topic"></a>

O código de exemplo a seguir mostra como usar `create-authorizer`.

**AWS CLI**  
**Para criar um autorizador JWT para uma API HTTP**  
O exemplo `create-authorizer` a seguir cria um autorizador JWT que usa o Amazon Cognito como um provedor de identidade.  

```
aws apigatewayv2 create-authorizer \
    --name my-jwt-authorizer \
    --api-id a1b2c3d4 \
    --authorizer-type JWT \
    --identity-source '$request.header.Authorization' \
    --jwt-configuration Audience=123456abc,Issuer=https://cognito-idp.us-west-2.amazonaws.com/us-west-2_abc123
```
Resultado:  

```
{
    "AuthorizerId": "a1b2c3",
    "AuthorizerType": "JWT",
    "IdentitySource": [
        "$request.header.Authorization"
    ],
    "JwtConfiguration": {
        "Audience": [
            "123456abc"
        ],
        "Issuer": "https://cognito-idp.us-west-2.amazonaws.com/us-west-2_abc123"
    },
    "Name": "my-jwt-authorizer"
}
```
Para obter mais informações, consulte [Controlar o acesso a APIs HTTP com autorizadores JWT](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-jwt-authorizer.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [CreateAuthorizer](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/create-authorizer.html) na *Referência de comandos da AWS CLI*. 

### `create-deployment`
<a name="apigatewayv2_CreateDeployment_cli_topic"></a>

O código de exemplo a seguir mostra como usar `create-deployment`.

**AWS CLI**  
**Para criar uma implantação para uma API**  
O exemplo `create-deployment` a seguir cria uma implantação para uma API e a associa ao estágio `dev` da API.  

```
aws apigatewayv2 create-deployment \
    --api-id a1b2c3d4 \
    --stage-name dev
```
Resultado:  

```
{
    "AutoDeployed": false,
    "CreatedDate": "2020-04-06T23:38:08Z",
    "DeploymentId": "53lz9l",
    "DeploymentStatus": "DEPLOYED"
}
```
Para obter mais informações, consulte [Implantação da API](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-basic-concept.html#apigateway-definition-api-deployment) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Consulte detalhes da API em [CreateDeployment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/create-deployment.html) na *Referência de comandos da AWS CLI*. 

### `create-domain-name`
<a name="apigatewayv2_CreateDomainName_cli_topic"></a>

O código de exemplo a seguir mostra como usar `create-domain-name`.

**AWS CLI**  
**Para criar um nome de domínio personalizado**  
O exemplo `create-domain-name` a seguir cria um domínio personalizado regional para uma API.  

```
aws apigatewayv2 create-domain-name \
    --domain-name regional.example.com \
    --domain-name-configurations CertificateArn=arn:aws:acm:us-west-2:123456789012:certificate/123456789012-1234-1234-1234-12345678
```
Resultado:  

```
{
    "ApiMappingSelectionExpression": "$request.basepath",
    "DomainName": "regional.example.com",
    "DomainNameConfigurations": [
        {
            "ApiGatewayDomainName": "d-id.execute-api.us-west-2.amazonaws.com",
            "CertificateArn": "arn:aws:acm:us-west-2:123456789012:certificate/123456789012-1234-1234-1234-12345678",
            "EndpointType": "REGIONAL",
            "HostedZoneId": "123456789111",
            "SecurityPolicy": "TLS_1_2",
            "DomainNameStatus": "AVAILABLE"
        }
    ]
}
```
Para obter mais informações, consulte [Configurar um nome de domínio personalizado regional no API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-regional-api-custom-domain-create.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/apigatewayv2/create-domain-name.html) na *Referência de comandos da AWS CLI*. 

### `create-integration`
<a name="apigatewayv2_CreateIntegration_cli_topic"></a>

O código de exemplo a seguir mostra como usar `create-integration`.

**AWS CLI**  
**Para criar uma integração com a API de WebSocket**  
O exemplo `create-integration` a seguir cria uma integração simulada para uma API de WebSocket.  

```
aws apigatewayv2 create-integration \
    --api-id aabbccddee \
    --passthrough-behavior WHEN_NO_MATCH \
    --timeout-in-millis 29000 \
    --connection-type INTERNET \
    --integration-type MOCK
```
Resultado:  

```
{
    "ConnectionType": "INTERNET",
    "IntegrationId": "0abcdef",
    "IntegrationResponseSelectionExpression": "${integration.response.statuscode}",
    "IntegrationType": "MOCK",
    "PassthroughBehavior": "WHEN_NO_MATCH",
    "PayloadFormatVersion": "1.0",
    "TimeoutInMillis": 29000
}
```
Para obter mais informações, consulte [Configurar uma solicitação de integração da API de WebSocket no API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-websocket-api-integration-requests.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
**Para criar uma integração da API HTTP**  
O exemplo `create-integration` a seguir cria uma integração do AWS Lambda para uma API HTTP.  

```
aws apigatewayv2 create-integration \
    --api-id a1b2c3d4 \
    --integration-type AWS_PROXY \
    --integration-uri arn:aws:lambda:us-west-2:123456789012:function:my-function \
    --payload-format-version 2.0
```
Resultado:  

```
{
    "ConnectionType": "INTERNET",
    "IntegrationId": "0abcdef",
    "IntegrationMethod": "POST",
    "IntegrationType": "AWS_PROXY",
    "IntegrationUri": "arn:aws:lambda:us-west-2:123456789012:function:my-function",
    "PayloadFormatVersion": "2.0",
    "TimeoutInMillis": 30000
}
```
Para obter mais informações, consulte [Configurar o integrações para APIs HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [CreateIntegration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/create-integration.html) na *Referência de comandos da AWS CLI*. 

### `create-route`
<a name="apigatewayv2_CreateRoute_cli_topic"></a>

O código de exemplo a seguir mostra como usar `create-route`.

**AWS CLI**  
**Para criar uma rota \$1default para uma API de WebSocket ou HTTP**  
O exemplo `create-route` a seguir cria uma rota `$default` para uma API de WebSocket ou HTTP.  

```
aws apigatewayv2 create-route \
    --api-id aabbccddee \
    --route-key '$default'
```
Resultado:  

```
{
    "ApiKeyRequired": false,
    "AuthorizationType": "NONE",
    "RouteKey": "$default",
    "RouteId": "1122334"
}
```
Para obter mais informações, consulte [Trabalhar com rotas para APIs de WebSocket](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-websocket-api-add-route.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
**Para criar uma rota para uma API HTTP**  
O exemplo `create-route` a seguir cria uma rota chamada `signup` que aceita solicitações POST.  

```
aws apigatewayv2 create-route \
    --api-id aabbccddee \
    --route-key 'POST /signup'
```
Resultado:  

```
{
    "ApiKeyRequired": false,
    "AuthorizationType": "NONE",
    "RouteKey": "POST /signup",
    "RouteId": "1122334"
}
```
Para obter mais informações, consulte [Trabalhar com rotas para APIs HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-routes.html) no *Guia do desenvolvedor do Amazon API Gateway*  
+  Para ver detalhes da API, consulte [CreateRoute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/create-route.html) na *Referência de comandos da AWS CLI*. 

### `create-routing-rule`
<a name="apigatewayv2_CreateRoutingRule_cli_topic"></a>

O código de exemplo a seguir mostra como usar `create-routing-rule`.

**AWS CLI**  
**Como criar uma regra de roteamento**  
O exemplo `create-routing-rule` a seguir cria uma regra de roteamento com uma prioridade de `50`.  

```
aws apigatewayv2 create-routing-rule \
    --domain-name 'regional.example.com' \
    --priority 50 \
    --conditions '[ \
        { \
            "MatchBasePaths": { \
                "AnyOf": [ \
                    "PetStoreShopper" \
                ] \
            } \
        } \
    ]' \
    --actions '[ \
        { \
            "InvokeApi": { \
                "ApiId": "abcd1234", \
                "Stage": "prod" \
            } \
        } \
    ]'
```
Resultado:  

```
{
    "Actions": [
        {
            "InvokeApi": {
                "ApiId": "abcd1234",
                "Stage": "prod",
                "StripBasePath": false
            }
        }
    ],
    "Conditions": [
        {
            "MatchBasePaths": {
                "AnyOf": [
                    "PetStoreShopper"
                ]
            }
        }
    ],
    "Priority": 50,
    "RoutingRuleArn": "arn:aws:apigateway:us-east-2:123456789012:/domainnames/regional.example.com/routingrules/aaa111",
    "RoutingRuleId": "aaa111"
}
```
Para ter mais informações, consulte [Regras de roteamento para associar estágios da API a um nome de domínio personalizado para APIs REST](https://docs.aws.amazon.com/apigateway/latest/developerguide/rest-api-routing-rules.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [CreateRoutingRule](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/create-routing-rule.html) na *Referência de comandos da AWS CLI*. 

### `create-stage`
<a name="apigatewayv2_CreateStage_cli_topic"></a>

O código de exemplo a seguir mostra como usar `create-stage`.

**AWS CLI**  
**Para criar um estágio**  
O exemplo `create-stage` a seguir cria um estágio chamado dev para uma API.  

```
aws apigatewayv2 create-stage \
    --api-id a1b2c3d4 \
    --stage-name dev
```
Resultado:  

```
{
    "CreatedDate": "2020-04-06T23:23:46Z",
    "DefaultRouteSettings": {
        "DetailedMetricsEnabled": false
    },
    "LastUpdatedDate": "2020-04-06T23:23:46Z",
    "RouteSettings": {},
    "StageName": "dev",
    "StageVariables": {},
    "Tags": {}
}
```
Para obter mais informações, consulte [Trabalhar com estágios para APIs HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-stages.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [CreateStage](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/create-stage.html) na *Referência de comandos da AWS CLI*. 

### `create-vpc-link`
<a name="apigatewayv2_CreateVpcLink_cli_topic"></a>

O código de exemplo a seguir mostra como usar `create-vpc-link`.

**AWS CLI**  
**Para criar um link da VPC para uma API HTTP**  
O exemplo `create-vpc-link` a seguir cria um link da VPC para APIs HTTP.  

```
aws apigatewayv2 create-vpc-link \
    --name MyVpcLink \
    --subnet-ids subnet-aaaa subnet-bbbb \
    --security-group-ids sg1234 sg5678
```
Resultado:  

```
{
    "CreatedDate": "2020-04-07T00:11:46Z",
    "Name": "MyVpcLink",
    "SecurityGroupIds": [
        "sg1234",
        "sg5678"
    ],
    "SubnetIds": [
        "subnet-aaaa",
        "subnet-bbbb"
    ],
    "Tags": {},
    "VpcLinkId": "abcd123",
    "VpcLinkStatus": "PENDING",
    "VpcLinkStatusMessage": "VPC link is provisioning ENIs",
    "VpcLinkVersion": "V2"
}
```
Para obter mais informações, consulte [Trabalhar com links da VPC para APIs HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-vpc-links.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [CreateVpcLink](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/create-vpc-link.html) na *Referência de comandos da AWS CLI*. 

### `delete-access-log-settings`
<a name="apigatewayv2_DeleteAccessLogSettings_cli_topic"></a>

O código de exemplo a seguir mostra como usar `delete-access-log-settings`.

**AWS CLI**  
**Para desativar o registro em log de acesso para uma API**  
O exemplo `delete-access-log-settings` a seguir exclui as configurações do registro em log de acesso do estágio `$default` de uma API. Para desabilitar o registro de acesso em log de um estágio, exclua as configurações do log de acesso.  

```
aws apigatewayv2 delete-access-log-settings \
    --api-id a1b2c3d4 \
    --stage-name '$default'
```
Este comando não produz saída.  
Para obter mais informações, consulte [Configurar o registros em log para uma API HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-logging.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [DeleteAccessLogSettings](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/delete-access-log-settings.html) na *Referência de comandos da AWS CLI*. 

### `delete-api-mapping`
<a name="apigatewayv2_DeleteApiMapping_cli_topic"></a>

O código de exemplo a seguir mostra como usar `delete-api-mapping`.

**AWS CLI**  
**Para excluir um mapeamento de API**  
O exemplo `delete-api-mapping` a seguir exclui um mapeamento de API do nome de domínio personalizado `api.example.com`.  

```
aws apigatewayv2 delete-api-mapping \
    --api-mapping-id a1b2c3 \
    --domain-name api.example.com
```
Este comando não produz saída.  
Para obter mais informações, consulte [Configurar um nome de domínio personalizado regional no API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-regional-api-custom-domain-create.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [DeleteApiMapping](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/delete-api-mapping.html) na *Referência de comandos da AWS CLI*. 

### `delete-api`
<a name="apigatewayv2_DeleteApi_cli_topic"></a>

O código de exemplo a seguir mostra como usar `delete-api`.

**AWS CLI**  
**Como excluir uma API**  
O exemplo `delete-api` a seguir exclui uma API.  

```
aws apigatewayv2 delete-api \
    --api-id a1b2c3d4
```
Este comando não produz saída.  
Para obter mais informações, consulte [Trabalhar com APIs HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api.html) e [Trabalhar com APIs de WebSocket](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-websocket-api.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [DeleteApi](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/delete-api.html) na *Referência de comandos da AWS CLI*. 

### `delete-authorizer`
<a name="apigatewayv2_DeleteAuthorizer_cli_topic"></a>

O código de exemplo a seguir mostra como usar `delete-authorizer`.

**AWS CLI**  
**Para excluir um autorizador**  
O exemplo `delete-authorizer` a seguir exclui um autorizador.  

```
aws apigatewayv2 delete-authorizer \
    --api-id a1b2c3d4 \
    --authorizer-id a1b2c3
```
Este comando não produz saída.  
Para obter mais informações, consulte [Controlar o acesso a APIs HTTP com autorizadores JWT](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-jwt-authorizer.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [DeleteAuthorizer](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/delete-authorizer.html) na *Referência de comandos da AWS CLI*. 

### `delete-cors-configuration`
<a name="apigatewayv2_DeleteCorsConfiguration_cli_topic"></a>

O código de exemplo a seguir mostra como usar `delete-cors-configuration`.

**AWS CLI**  
**Para excluir a configuração CORS de uma API HTTP**  
O exemplo `delete-cors-configuration` a seguir desabilita o CORS para uma API HTTP excluindo sua configuração de CORS.  

```
aws apigatewayv2 delete-cors-configuration \
    --api-id a1b2c3d4
```
Este comando não produz saída.  
Para obter mais informações, consulte [Configurar o CORS para uma API HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-cors.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [DeleteCorsConfiguration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/delete-cors-configuration.html) na *Referência de comandos da AWS CLI*. 

### `delete-deployment`
<a name="apigatewayv2_DeleteDeployment_cli_topic"></a>

O código de exemplo a seguir mostra como usar `delete-deployment`.

**AWS CLI**  
**Para excluir uma implantação**  
O exemplo `delete-deployment` a seguir exclui uma implantação de uma API.  

```
aws apigatewayv2 delete-deployment \
    --api-id a1b2c3d4 \
    --deployment-id a1b2c3
```
Este comando não produz saída.  
Para obter mais informações, consulte [Implantação da API](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-basic-concept.html#apigateway-definition-api-deployment) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Consulte detalhes da API em [DeleteDeployment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/delete-deployment.html) na *Referência de comandos da AWS CLI*. 

### `delete-domain-name`
<a name="apigatewayv2_DeleteDomainName_cli_topic"></a>

O código de exemplo a seguir mostra como usar `delete-domain-name`.

**AWS CLI**  
**Para excluir um nome de domínio personalizado**  
O exemplo `delete-domain-name` a seguir exclui um nome de domínio personalizado.  

```
aws apigatewayv2 delete-domain-name \
    --domain-name api.example.com
```
Este comando não produz saída.  
Para obter mais informações, consulte [Configurar um nome de domínio personalizado regional no API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-regional-api-custom-domain-create.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [DeleteDomainName](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/delete-domain-name.html) na *Referência de comandos da AWS CLI*. 

### `delete-integration`
<a name="apigatewayv2_DeleteIntegration_cli_topic"></a>

O código de exemplo a seguir mostra como usar `delete-integration`.

**AWS CLI**  
**Para excluir uma integração**  
O exemplo `delete-integration` a seguir exclui uma integração de API.  

```
aws apigatewayv2 delete-integration \
    --api-id a1b2c3d4 \
    --integration-id a1b2c3
```
Este comando não produz saída.  
Para obter mais informações, consulte [Configurar integrações para APIs HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations.html) e [Configurar integrações de APIs de WebSocket](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-websocket-api-integrations.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [DeleteIntegration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/delete-integration.html) na *Referência de comandos da AWS CLI*. 

### `delete-route-settings`
<a name="apigatewayv2_DeleteRouteSettings_cli_topic"></a>

O código de exemplo a seguir mostra como usar `delete-route-settings`.

**AWS CLI**  
**Para excluir as configurações de rota**  
O exemplo `delete-route-settings` a seguir exclui as configurações de rota para a rota especificada.  

```
aws apigatewayv2 delete-route-settings \
    --api-id a1b2c3d4 \
    --stage-name dev \
    --route-key 'GET /pets'
```
Este comando não produz saída.  
Para obter mais informações, consulte [Trabalhar com rotas para APIs HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-routes.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [DeleteRouteSettings](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/delete-route-settings.html) na *Referência de comandos da AWS CLI*. 

### `delete-route`
<a name="apigatewayv2_DeleteRoute_cli_topic"></a>

O código de exemplo a seguir mostra como usar `delete-route`.

**AWS CLI**  
**Para excluir uma rota**  
O exemplo `delete-route` a seguir exclui uma rota da API.  

```
aws apigatewayv2 delete-route \
    --api-id a1b2c3d4 \
    --route-id a1b2c3
```
Este comando não produz saída.  
Para obter mais informações, consulte [Trabalhar com rotas para APIs HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-routes.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [DeleteRoute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/delete-route.html) na *Referência de comandos da AWS CLI*. 

### `delete-routing-rule`
<a name="apigatewayv2_DeleteRoutingRule_cli_topic"></a>

O código de exemplo a seguir mostra como usar `delete-routing-rule`.

**AWS CLI**  
**Como excluir uma regra de roteamento**  
O exemplo `delete-routing-rule` a seguir exclui uma regra de roteamento para um nome de domínio personalizado.  

```
aws apigatewayv2 delete-routing-rule \
    --domain-name 'regional.example.com' \
    --routing-rule-id aaa111
```
Este comando não produz saída.  
Para ter mais informações, consulte [Regras de roteamento para associar estágios da API a um nome de domínio personalizado para APIs REST](https://docs.aws.amazon.com/apigateway/latest/developerguide/rest-api-routing-rules.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [DeleteRoutingRule](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/delete-routing-rule.html) na *Referência de comandos da AWS CLI*. 

### `delete-stage`
<a name="apigatewayv2_DeleteStage_cli_topic"></a>

O código de exemplo a seguir mostra como usar `delete-stage`.

**AWS CLI**  
**Para excluir uma estágio**  
O exemplo `delete-stage` a seguir exclui o estágio `test` de uma API.  

```
aws apigatewayv2 delete-stage \
    --api-id a1b2c3d4 \
    --stage-name test
```
Este comando não produz saída.  
Para obter mais informações, consulte [Trabalhar com estágios para APIs HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-stages.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [DeleteStage](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/delete-stage.html) na *Referência de comandos da AWS CLI*. 

### `delete-vpc-link`
<a name="apigatewayv2_DeleteVpcLink_cli_topic"></a>

O código de exemplo a seguir mostra como usar `delete-vpc-link`.

**AWS CLI**  
**Para excluir um link da VPC para uma API HTTP**  
O exemplo `delete-vpc-link` a seguir exclui um link da VPC.  

```
aws apigatewayv2 delete-vpc-link \
    --vpc-link-id abcd123
```
Este comando não produz saída.  
Para obter mais informações, consulte [Trabalhar com links da VPC para APIs HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-vpc-links.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [DeleteVpcLink](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/delete-vpc-link.html) na *Referência de comandos da AWS CLI*. 

### `export-api`
<a name="apigatewayv2_ExportApi_cli_topic"></a>

O código de exemplo a seguir mostra como usar `export-api`.

**AWS CLI**  
**Para exportar uma definição do OpenAPI de uma API HTTP**  
O exemplo `export-api` a seguir exporta uma definição do OpenAPI 3.0 de um estágio de API chamado `prod` para um arquivo YAML denominado `stage-definition.yaml`. O arquivo de definição exportado inclui extensões do API Gateway por padrão.  

```
aws apigatewayv2 export-api \
    --api-id a1b2c3d4 \
    --output-type YAML \
    --specification OAS30 \
    --stage-name prod \
    stage-definition.yaml
```
Este comando não produz saída.  
Para obter mais informações, consulte [Exportar uma API HTTP do API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-export.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [ExportApi](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/export-api.html) na *Referência de comandos da AWS CLI*. 

### `get-api-mapping`
<a name="apigatewayv2_GetApiMapping_cli_topic"></a>

O código de exemplo a seguir mostra como usar `get-api-mapping`.

**AWS CLI**  
**Para obter informações sobre um mapeamento de API para um nome de domínio personalizado**  
O exemplo `get-api-mapping` a seguir exibe informações sobre um mapeamento de API para o nome de domínio personalizado `api.example.com`.  

```
aws apigatewayv2 get-api-mapping \
    --api-mapping-id a1b2c3 \
    --domain-name api.example.com
```
Resultado:  

```
{
    "ApiId": "a1b2c3d4",
    "ApiMappingId": "a1b2c3d5",
    "ApiMappingKey": "myTestApi"
    "Stage": "test"
}
```
Para obter mais informações, consulte [Configurar um nome de domínio personalizado regional no API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-regional-api-custom-domain-create.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [GetApiMapping](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-api-mapping.html) na *Referência de comandos da AWS CLI*. 

### `get-api-mappings`
<a name="apigatewayv2_GetApiMappings_cli_topic"></a>

O código de exemplo a seguir mostra como usar `get-api-mappings`.

**AWS CLI**  
**Para obter mapeamentos de API para um nome de domínio personalizado**  
O exemplo `get-api-mappings` a seguir exibe uma lista de todos os mapeamentos de API para o nome de domínio personalizado `api.example.com`.  

```
aws apigatewayv2 get-api-mappings \
    --domain-name api.example.com
```
Resultado:  

```
{
    "Items": [
        {
            "ApiId": "a1b2c3d4",
            "ApiMappingId": "a1b2c3d5",
            "ApiMappingKey": "myTestApi"
            "Stage": "test"
        },
        {
            "ApiId": "a5b6c7d8",
            "ApiMappingId": "a1b2c3d6",
            "ApiMappingKey": "myDevApi"
            "Stage": "dev"
        },
    ]
}
```
Para obter mais informações, consulte [Configurar um nome de domínio personalizado regional no API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-regional-api-custom-domain-create.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [GetApiMappings](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-api-mappings.html) na *Referência de comandos da AWS CLI*. 

### `get-api`
<a name="apigatewayv2_GetApi_cli_topic"></a>

O código de exemplo a seguir mostra como usar `get-api`.

**AWS CLI**  
**Para recuperar informações sobre uma API**  
O exemplo `get-api` a seguir exibe informações sobre uma API.  

```
aws apigatewayv2 get-api \
    --api-id a1b2c3d4
```
Resultado:  

```
{
    "ApiEndpoint": "https://a1b2c3d4.execute-api.us-west-2.amazonaws.com",
    "ApiId": "a1b2c3d4",
    "ApiKeySelectionExpression": "$request.header.x-api-key",
    "CreatedDate": "2020-03-28T00:32:37Z",
    "Name": "my-api",
    "ProtocolType": "HTTP",
    "RouteSelectionExpression": "$request.method $request.path",
    "Tags": {
        "department": "finance"
    }
}
```
+  Para ver detalhes da API, consulte [GetApi](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-api.html) na *Referência de comandos da AWS CLI*. 

### `get-apis`
<a name="apigatewayv2_GetApis_cli_topic"></a>

O código de exemplo a seguir mostra como usar `get-apis`.

**AWS CLI**  
**Para recuperar uma lista de APIs**  
O exemplo `get-apis` a seguir lista todas as APIs do usuário atual.  

```
aws apigatewayv2 get-apis
```
Resultado:  

```
{
    "Items": [
        {
            "ApiEndpoint": "wss://a1b2c3d4.execute-api.us-west-2.amazonaws.com",
            "ApiId": "a1b2c3d4",
            "ApiKeySelectionExpression": "$request.header.x-api-key",
            "CreatedDate": "2020-04-07T20:21:59Z",
            "Name": "my-websocket-api",
            "ProtocolType": "WEBSOCKET",
            "RouteSelectionExpression": "$request.body.message",
            "Tags": {}
        },
        {
            "ApiEndpoint": "https://a1b2c3d5.execute-api.us-west-2.amazonaws.com",
            "ApiId": "a1b2c3d5",
            "ApiKeySelectionExpression": "$request.header.x-api-key",
            "CreatedDate": "2020-04-07T20:23:50Z",
            "Name": "my-http-api",
            "ProtocolType": "HTTP",
            "RouteSelectionExpression": "$request.method $request.path",
            "Tags": {}
        }
    ]
}
```
Para obter mais informações, consulte [Trabalhar com APIs HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api.html) e [Trabalhar com APIs de WebSocket](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-websocket-api.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [GetApis](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-apis.html) na *Referência de comandos da AWS CLI*. 

### `get-authorizer`
<a name="apigatewayv2_GetAuthorizer_cli_topic"></a>

O código de exemplo a seguir mostra como usar `get-authorizer`.

**AWS CLI**  
**Para recuperar informações sobre um autorizador**  
O exemplo `get-authorizer` a seguir exibe informações detalhadas sobre um autorizador.  

```
aws apigatewayv2 get-authorizer \
    --api-id a1b2c3d4 \
    --authorizer-id a1b2c3
```
Resultado:  

```
{
    "AuthorizerId": "a1b2c3",
    "AuthorizerType": "JWT",
    "IdentitySource": [
        "$request.header.Authorization"
    ],
    "JwtConfiguration": {
        "Audience": [
            "123456abc"
        ],
        "Issuer": "https://cognito-idp.us-west-2.amazonaws.com/us-west-2_abc123"
    },
    "Name": "my-jwt-authorizer"
}
```
Para obter mais informações, consulte [Controlar o acesso a APIs HTTP com autorizadores JWT](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-jwt-authorizer.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [GetAuthorizer](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-authorizer.html) na *Referência de comandos da AWS CLI*. 

### `get-authorizers`
<a name="apigatewayv2_GetAuthorizers_cli_topic"></a>

O código de exemplo a seguir mostra como usar `get-authorizers`.

**AWS CLI**  
**Para recuperar uma lista de autorizadores de uma API**  
O exemplo `get-authorizers` a seguir exibe uma lista de todos os autorizadores de uma API.  

```
aws apigatewayv2 get-authorizers \
    --api-id a1b2c3d4
```
Resultado:  

```
{
    "Items": [
        {
            "AuthorizerId": "a1b2c3",
            "AuthorizerType": "JWT",
            "IdentitySource": [
                "$request.header.Authorization"
            ],
            "JwtConfiguration": {
                "Audience": [
                    "123456abc"
                ],
                "Issuer": "https://cognito-idp.us-west-2.amazonaws.com/us-west-2_abc123"
            },
            "Name": "my-jwt-authorizer"
        },
        {
            "AuthorizerId": "a1b2c4",
            "AuthorizerType": "JWT",
            "IdentitySource": [
                "$request.header.Authorization"
            ],
            "JwtConfiguration": {
                "Audience": [
                    "6789abcde"
                ],
                "Issuer": "https://cognito-idp.us-west-2.amazonaws.com/us-west-2_abc234"
            },
            "Name": "new-jwt-authorizer"
        }
    ]
}
```
Para obter mais informações, consulte [Controlar o acesso a APIs HTTP com autorizadores JWT](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-jwt-authorizer.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [GetAuthorizers](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-authorizers.html) na *Referência de comandos da AWS CLI*. 

### `get-deployment`
<a name="apigatewayv2_GetDeployment_cli_topic"></a>

O código de exemplo a seguir mostra como usar `get-deployment`.

**AWS CLI**  
**Para recuperar informações sobre uma implantação**  
O exemplo `get-deployment` a seguir exibe informações sobre uma implantação.  

```
aws apigatewayv2 get-deployment \
    --api-id a1b2c3d4 \
    --deployment-id abcdef
```
Resultado:  

```
{
    "AutoDeployed": true,
    "CreatedDate": "2020-04-07T23:58:40Z",
    "DeploymentId": "abcdef",
    "DeploymentStatus": "DEPLOYED",
    "Description": "Automatic deployment triggered by changes to the Api configuration"
}
```
Para obter mais informações, consulte [Implantação da API](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-basic-concept.html#apigateway-definition-api-deployment) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [GetDeployment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-deployment.html) na *Referência de comandos da AWS CLI*. 

### `get-deployments`
<a name="apigatewayv2_GetDeployments_cli_topic"></a>

O código de exemplo a seguir mostra como usar `get-deployments`.

**AWS CLI**  
**Para recuperar uma lista de implantações**  
O exemplo `get-deployments` a seguir exibe uma lista de todas as implantações de uma API.  

```
aws apigatewayv2 get-deployments \
    --api-id a1b2c3d4
```
Resultado:  

```
{
    "Items": [
        {
            "AutoDeployed": true,
            "CreatedDate": "2020-04-07T23:58:40Z",
            "DeploymentId": "abcdef",
            "DeploymentStatus": "DEPLOYED",
            "Description": "Automatic deployment triggered by changes to the Api configuration"
        },
        {
            "AutoDeployed": true,
            "CreatedDate": "2020-04-06T00:33:00Z",
            "DeploymentId": "bcdefg",
            "DeploymentStatus": "DEPLOYED",
            "Description": "Automatic deployment triggered by changes to the Api configuration"
        }
    ]
}
```
Para obter mais informações, consulte [Implantação da API](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-basic-concept.html#apigateway-definition-api-deployment) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [GetDeployments](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-deployments.html) na *Referência de comandos da AWS CLI*. 

### `get-domain-name`
<a name="apigatewayv2_GetDomainName_cli_topic"></a>

O código de exemplo a seguir mostra como usar `get-domain-name`.

**AWS CLI**  
**Para recuperar informações sobre um nome de domínio personalizado**  
O exemplo `get-domain-name` a seguir exibe informações sobre um nome de domínio personalizado.  

```
aws apigatewayv2 get-domain-name \
    --domain-name api.example.com
```
Resultado:  

```
{
    "ApiMappingSelectionExpression": "$request.basepath",
    "DomainName": "api.example.com",
    "DomainNameConfigurations": [
        {
            "ApiGatewayDomainName": "d-1234.execute-api.us-west-2.amazonaws.com",
            "CertificateArn": "arn:aws:acm:us-west-2:123456789012:certificate/123456789012-1234-1234-1234-12345678",
            "EndpointType": "REGIONAL",
            "HostedZoneId": "123456789111",
            "SecurityPolicy": "TLS_1_2",
            "DomainNameStatus": "AVAILABLE"
        }
    ],
    "Tags": {}
}
```
Para obter mais informações, consulte [Configurar um nome de domínio personalizado regional no API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-regional-api-custom-domain-create.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/apigatewayv2/get-domain-name.html) na *Referência de comandos da AWS CLI*. 

### `get-domain-names`
<a name="apigatewayv2_GetDomainNames_cli_topic"></a>

O código de exemplo a seguir mostra como usar `get-domain-names`.

**AWS CLI**  
**Para recuperar uma lista de nomes de domínio personalizados**  
O exemplo `get-domain-names` a seguir exibe uma lista de todos os nomes de domínio personalizados do usuário atual.  

```
aws apigatewayv2 get-domain-names
```
Resultado:  

```
{
    "Items": [
        {
            "ApiMappingSelectionExpression": "$request.basepath",
            "DomainName": "api.example.com",
            "DomainNameConfigurations": [
                {
                    "ApiGatewayDomainName": "d-1234.execute-api.us-west-2.amazonaws.com",
                    "CertificateArn": "arn:aws:acm:us-west-2:123456789012:certificate/123456789012-1234-1234-1234-12345678",
                    "EndpointType": "REGIONAL",
                    "HostedZoneId": "123456789111",
                    "SecurityPolicy": "TLS_1_2",
                    "DomainNameStatus": "AVAILABLE"
                }
            ]
        },
        {
            "ApiMappingSelectionExpression": "$request.basepath",
            "DomainName": "newApi.example.com",
            "DomainNameConfigurations": [
                {
                    "ApiGatewayDomainName": "d-5678.execute-api.us-west-2.amazonaws.com",
                    "CertificateArn": "arn:aws:acm:us-west-2:123456789012:certificate/123456789012-1234-1234-1234-12345678",
                    "EndpointType": "REGIONAL",
                    "HostedZoneId": "123456789222",
                    "SecurityPolicy": "TLS_1_2",
                    "DomainNameStatus": "AVAILABLE"
                }
            ]
        }
    ]
}
```
Para obter mais informações, consulte [Configurar um nome de domínio personalizado regional no API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-regional-api-custom-domain-create.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/apigatewayv2/get-domain-names.html) na *Referência de comandos da AWS CLI*. 

### `get-integration`
<a name="apigatewayv2_GetIntegration_cli_topic"></a>

O código de exemplo a seguir mostra como usar `get-integration`.

**AWS CLI**  
**Para recuperar informações sobre uma integração**  
O exemplo `get-integration` a seguir mostra informações sobre uma integração.  

```
aws apigatewayv2 get-integration \
    --api-id a1b2c3d4 \
    --integration-id a1b2c3
```
Resultado:  

```
{
    "ApiGatewayManaged": true,
    "ConnectionType": "INTERNET",
    "IntegrationId": "a1b2c3",
    "IntegrationMethod": "POST",
    "IntegrationType": "AWS_PROXY",
    "IntegrationUri": "arn:aws:lambda:us-west-2:12356789012:function:hello12",
    "PayloadFormatVersion": "2.0",
    "TimeoutInMillis": 30000
}
```
Para obter mais informações, consulte [Configurar integrações para APIs HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations.html) e [Configurar integrações de APIs de WebSocket](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-websocket-api-integrations.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [GetIntegration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-integration.html) na *Referência de comandos da AWS CLI*. 

### `get-integrations`
<a name="apigatewayv2_GetIntegrations_cli_topic"></a>

O código de exemplo a seguir mostra como usar `get-integrations`.

**AWS CLI**  
**Para recuperar uma lista de integrações**  
O exemplo `get-integrations` a seguir exibe uma lista de todas as integrações de uma API.  

```
aws apigatewayv2 get-integrations \
    --api-id a1b2c3d4
```
Resultado:  

```
{
    "Items": [
        {
            "ApiGatewayManaged": true,
            "ConnectionType": "INTERNET",
            "IntegrationId": "a1b2c3",
            "IntegrationMethod": "POST",
            "IntegrationType": "AWS_PROXY",
            "IntegrationUri": "arn:aws:lambda:us-west-2:123456789012:function:my-function",
            "PayloadFormatVersion": "2.0",
            "TimeoutInMillis": 30000
        },
        {
            "ConnectionType": "INTERNET",
            "IntegrationId": "a1b2c4",
            "IntegrationMethod": "ANY",
            "IntegrationType": "HTTP_PROXY",
            "IntegrationUri": "https://www.example.com",
            "PayloadFormatVersion": "1.0",
            "TimeoutInMillis": 30000
        }
    ]
}
```
Para obter mais informações, consulte [Configurar integrações para APIs HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations.html) e [Configurar integrações de APIs de WebSocket](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-websocket-api-integrations.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [GetIntegrations](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-integrations.html) na *Referência de comandos da AWS CLI*. 

### `get-route`
<a name="apigatewayv2_GetRoute_cli_topic"></a>

O código de exemplo a seguir mostra como usar `get-route`.

**AWS CLI**  
**Para recuperar informações sobre uma rota**  
O exemplo `get-route` a seguir exibe informações sobre uma rota.  

```
aws apigatewayv2 get-route \
    --api-id a1b2c3d4 \
    --route-id 72jz1wk
```
Resultado:  

```
{
    "ApiKeyRequired": false,
    "AuthorizationType": "NONE",
    "RouteId": "72jz1wk",
    "RouteKey": "ANY /pets",
    "Target": "integrations/a1b2c3"
}
```
Para obter mais informações, consulte [Trabalhar com rotas para APIs HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-routes.html) no *Guia do desenvolvedor do Amazon API Gateway*  
+  Para ver detalhes da API, consulte [GetRoute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-route.html) na *Referência de comandos da AWS CLI*. 

### `get-routes`
<a name="apigatewayv2_GetRoutes_cli_topic"></a>

O código de exemplo a seguir mostra como usar `get-routes`.

**AWS CLI**  
**Para recuperar uma lista de rotas**  
O exemplo `get-routes` a seguir exibe uma lista de todas as rotas de uma API.  

```
aws apigatewayv2 get-routes \
    --api-id a1b2c3d4
```
Resultado:  

```
{
    "Items": [
        {
            "ApiKeyRequired": false,
            "AuthorizationType": "NONE",
            "RouteId": "72jz1wk",
            "RouteKey": "ANY /admin",
            "Target": "integrations/a1b2c3"
        },
        {
            "ApiGatewayManaged": true,
            "ApiKeyRequired": false,
            "AuthorizationType": "NONE",
            "RouteId": "go65gqi",
            "RouteKey": "$default",
            "Target": "integrations/a1b2c4"
        }
    ]
}
```
Para obter mais informações, consulte [Trabalhar com rotas para APIs HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-routes.html) no *Guia do desenvolvedor do Amazon API Gateway*  
+  Para ver detalhes da API, consulte [GetRoutes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-routes.html) na *Referência de comandos da AWS CLI*. 

### `get-routing-rule`
<a name="apigatewayv2_GetRoutingRule_cli_topic"></a>

O código de exemplo a seguir mostra como usar `get-routing-rule`.

**AWS CLI**  
**Como obter uma regra de roteamento**  
O exemplo `get-routing-rule` a seguir obtém uma regra de roteamento para um nome de domínio.  

```
aws apigatewayv2 get-routing-rule \
    --domain-name 'regional.example.com' \
    --routing-rule-id aaa111
```
Resultado:  

```
{
    "Actions": [
        {
            "InvokeApi": {
                "ApiId": "abcd1234",
                "Stage": "prod",
                "StripBasePath": false
            }
        }
    ],
    "Conditions": [
        {
            "MatchBasePaths": {
                "AnyOf": [
                    "PetStoreShopper"
                ]
            }
        }
    ],
    "Priority": 50,
    "RoutingRuleArn": "arn:aws:apigateway:us-east-2:123456789012:/domainnames/regional.example.com/routingrules/aaa111",
    "RoutingRuleId": "aaa111"
}
```
Para ter mais informações, consulte [Regras de roteamento para associar estágios da API a um nome de domínio personalizado para APIs REST](https://docs.aws.amazon.com/apigateway/latest/developerguide/rest-api-routing-rules.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [GetRoutingRule](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-routing-rule.html) na *Referência de comandos da AWS CLI*. 

### `get-stage`
<a name="apigatewayv2_GetStage_cli_topic"></a>

O código de exemplo a seguir mostra como usar `get-stage`.

**AWS CLI**  
**Para recuperar informações sobre um estágio**  
O exemplo `get-stage` a seguir mostra informações sobre o estágio `prod` de uma API.  

```
aws apigatewayv2 get-stage \
    --api-id a1b2c3d4 \
    --stage-name prod
```
Resultado:  

```
{
    "CreatedDate": "2020-04-08T00:36:05Z",
    "DefaultRouteSettings": {
        "DetailedMetricsEnabled": false
    },
    "DeploymentId": "x1zwyv",
    "LastUpdatedDate": "2020-04-08T00:36:13Z",
    "RouteSettings": {},
    "StageName": "prod",
    "StageVariables": {
        "function": "my-prod-function"
    },
    "Tags": {}
}
```
Para obter mais informações, consulte [Trabalhar com estágios para APIs HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-stages.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [GetStage](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-stage.html) na *Referência de comandos da AWS CLI*. 

### `get-stages`
<a name="apigatewayv2_GetStages_cli_topic"></a>

O código de exemplo a seguir mostra como usar `get-stages`.

**AWS CLI**  
**Para recuperar uma lista de estágios**  
O exemplo `get-stages` a seguir lista todos os estágios de uma API.  

```
aws apigatewayv2 get-stages \
    --api-id a1b2c3d4
```
Resultado:  

```
{
    "Items": [
        {
            "ApiGatewayManaged": true,
            "AutoDeploy": true,
            "CreatedDate": "2020-04-08T00:08:44Z",
            "DefaultRouteSettings": {
                "DetailedMetricsEnabled": false
            },
            "DeploymentId": "dty748",
            "LastDeploymentStatusMessage": "Successfully deployed stage with deployment ID 'dty748'",
            "LastUpdatedDate": "2020-04-08T00:09:49Z",
            "RouteSettings": {},
            "StageName": "$default",
            "StageVariables": {},
            "Tags": {}
        },
        {
            "AutoDeploy": true,
            "CreatedDate": "2020-04-08T00:35:06Z",
            "DefaultRouteSettings": {
                "DetailedMetricsEnabled": false
            },
            "LastUpdatedDate": "2020-04-08T00:35:48Z",
            "RouteSettings": {},
            "StageName": "dev",
            "StageVariables": {
                "function": "my-dev-function"
            },
            "Tags": {}
        },
        {
            "CreatedDate": "2020-04-08T00:36:05Z",
            "DefaultRouteSettings": {
                "DetailedMetricsEnabled": false
            },
            "DeploymentId": "x1zwyv",
            "LastUpdatedDate": "2020-04-08T00:36:13Z",
            "RouteSettings": {},
            "StageName": "prod",
            "StageVariables": {
                "function": "my-prod-function"
            },
            "Tags": {}
        }
    ]
}
```
Para obter mais informações, consulte [Trabalhar com estágios para APIs HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-stages.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [GetStages](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-stages.html) na *Referência de comandos da AWS CLI*. 

### `get-tags`
<a name="apigatewayv2_GetTags_cli_topic"></a>

O código de exemplo a seguir mostra como usar `get-tags`.

**AWS CLI**  
**Para recuperar uma lista de tags de um recurso**  
O exemplo `get-tags` a seguir lista todas as tags de uma API.  

```
aws apigatewayv2 get-tags \
    --resource-arn arn:aws:apigateway:us-west-2::/apis/a1b2c3d4
```
Resultado:  

```
{
    "Tags": {
        "owner": "dev-team",
        "environment": "prod"
    }
}
```
Para obter mais informações, consulte [Marcar recursos do API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-tagging.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [GetTags](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-tags.html) na *Referência de comandos da AWS CLI*. 

### `get-vpc-link`
<a name="apigatewayv2_GetVpcLink_cli_topic"></a>

O código de exemplo a seguir mostra como usar `get-vpc-link`.

**AWS CLI**  
**Para recuperar informações sobre um link da VPC**  
O exemplo `get-vpc-link` a seguir exibe informações sobre um link da VPC.  

```
aws apigatewayv2 get-vpc-link \
    --vpc-link-id abcd123
```
Resultado:  

```
{
    "CreatedDate": "2020-04-07T00:27:47Z",
    "Name": "MyVpcLink",
    "SecurityGroupIds": [
        "sg1234",
        "sg5678"
    ],
    "SubnetIds": [
        "subnet-aaaa",
        "subnet-bbbb"
    ],
    "Tags": {},
    "VpcLinkId": "abcd123",
    "VpcLinkStatus": "AVAILABLE",
    "VpcLinkStatusMessage": "VPC link is ready to route traffic",
    "VpcLinkVersion": "V2"
}
```
Para obter mais informações, consulte [Trabalhar com links da VPC para APIs HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-vpc-links.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [GetVpcLink](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-vpc-link.html) na *Referência de comandos da AWS CLI*. 

### `get-vpc-links`
<a name="apigatewayv2_GetVpcLinks_cli_topic"></a>

O código de exemplo a seguir mostra como usar `get-vpc-links`.

**AWS CLI**  
**Para recuperar uma lista de links da VPC**  
O exemplo `get-vpc-links` a seguir exibe uma lista de todos os links da VPC do usuário atual.  

```
aws apigatewayv2 get-vpc-links
```
Resultado:  

```
{
    "Items": [
        {
            "CreatedDate": "2020-04-07T00:27:47Z",
            "Name": "MyVpcLink",
            "SecurityGroupIds": [
                "sg1234",
                "sg5678"
            ],
            "SubnetIds": [
                "subnet-aaaa",
                "subnet-bbbb"
            ],
            "Tags": {},
            "VpcLinkId": "abcd123",
            "VpcLinkStatus": "AVAILABLE",
            "VpcLinkStatusMessage": "VPC link is ready to route traffic",
            "VpcLinkVersion": "V2"
        }
        {
            "CreatedDate": "2020-04-07T00:27:47Z",
            "Name": "MyOtherVpcLink",
            "SecurityGroupIds": [
                "sg1234",
                "sg5678"
            ],
            "SubnetIds": [
                "subnet-aaaa",
                "subnet-bbbb"
            ],
            "Tags": {},
            "VpcLinkId": "abcd456",
            "VpcLinkStatus": "AVAILABLE",
            "VpcLinkStatusMessage": "VPC link is ready to route traffic",
            "VpcLinkVersion": "V2"
        }
    ]
}
```
Para obter mais informações, consulte [Trabalhar com links da VPC para APIs HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-vpc-links.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [GetVpcLinks](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/get-vpc-links.html) na *Referência de comandos da AWS CLI*. 

### `import-api`
<a name="apigatewayv2_ImportApi_cli_topic"></a>

O código de exemplo a seguir mostra como usar `import-api`.

**AWS CLI**  
**Para importar uma API HTTP**  
O exemplo `import-api` a seguir cria uma API HTTP a partir de um arquivo de definição da OpenAPI 3.0 denominado `api-definition.yaml`.  

```
aws apigatewayv2 import-api \
    --body file://api-definition.yaml
```
Conteúdo de `api-definition.yaml`:  

```
openapi: 3.0.1
info:
    title: My Lambda API
    version: v1.0
paths:
    /hello:
        x-amazon-apigateway-any-method:
            x-amazon-apigateway-integration:
                payloadFormatVersion: 2.0
                type: aws_proxy
                httpMethod: POST
                uri: arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:hello/invocations
                connectionType: INTERNET
```
Resultado:  

```
{
    "ApiEndpoint": "https://a1b2c3d4.execute-api.us-west-2.amazonaws.com",
    "ApiId": "a1b2c3d4",
    "ApiKeySelectionExpression": "$request.header.x-api-key",
    "CreatedDate": "2020-04-08T17:19:38+00:00",
    "Name": "My Lambda API",
    "ProtocolType": "HTTP",
    "RouteSelectionExpression": "$request.method $request.path",
    "Tags": {},
    "Version": "v1.0"
}
```
Para obter mais informações, consulte [Trabalhar com definições da OpenAPI para APIs HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-open-api.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [ImportApi](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/import-api.html) na *Referência de comandos da AWS CLI*. 

### `list-routing-rules`
<a name="apigatewayv2_ListRoutingRules_cli_topic"></a>

O código de exemplo a seguir mostra como usar `list-routing-rules`.

**AWS CLI**  
**Como listar regras de roteamento**  
O exemplo `list-routing-rules` a seguir lista as regras de roteamento para um nome de domínio.  

```
aws apigatewayv2 list-routing-rules \
    --domain-name 'regional.example.com'
```
Resultado:  

```
{
    "RoutingRules": [
        {
            "Actions": [
                {
                    "InvokeApi": {
                        "ApiId": "abcd1234",
                        "Stage": "prod",
                        "StripBasePath": false
                    }
                }
            ],
            "Conditions": [
                {
                    "MatchBasePaths": {
                        "AnyOf": [
                            "PetStoreShopper"
                        ]
                    }
                }
            ],
            "Priority": 150,
            "RoutingRuleArn": "arn:aws:apigateway:us-east-1:123456789012:/domainnames/regional.example.com/routingrules/aaa111",
            "RoutingRuleId": "aaa111"
        }
    ]
}
```
Para ter mais informações, consulte [Regras de roteamento para associar estágios da API a um nome de domínio personalizado para APIs REST](https://docs.aws.amazon.com/apigateway/latest/developerguide/rest-api-routing-rules.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [ListRoutingRules](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/list-routing-rules.html) na *Referência de comandos da AWS CLI*. 

### `put-routing-rule`
<a name="apigatewayv2_PutRoutingRule_cli_topic"></a>

O código de exemplo a seguir mostra como usar `put-routing-rule`.

**AWS CLI**  
**Como atualizar uma regra de roteamento**  
O exemplo `put-routing-rule` a seguir atualiza a prioridade de uma regra de roteamento.  

```
aws apigatewayv2 put-routing-rule \
    --domain-name 'regional.example.com' \
    --priority 150 \
    --conditions '[ \
        { \
            "MatchBasePaths": { \
                "AnyOf": [ \
                    "PetStoreShopper" \
                ] \
            } \
        } \
    ]' \
    --actions '[ \
        { \
            "InvokeApi": { \
                "ApiId": "abcd1234", \
                "Stage": "prod" \
            } \
        } \
    ]'
```
Resultado:  

```
{
    "Actions": [
        {
            "InvokeApi": {
                "ApiId": "abcd1234",
                "Stage": "prod",
                "StripBasePath": false
            }
        }
    ],
    "Conditions": [
        {
            "MatchBasePaths": {
                "AnyOf": [
                    "PetStoreShopper"
                ]
            }
        }
    ],
    "Priority": 150,
    "RoutingRuleArn": "arn:aws:apigateway:us-east-2:123456789012:/domainnames/regional.example.com/routingrules/aaa111",
    "RoutingRuleId": "aaa111"
}
```
Para ter mais informações, consulte [Regras de roteamento para associar estágios da API a um nome de domínio personalizado para APIs REST](https://docs.aws.amazon.com/apigateway/latest/developerguide/rest-api-routing-rules.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [PutRoutingRule](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/put-routing-rule.html) na *Referência de comandos da AWS CLI*. 

### `reimport-api`
<a name="apigatewayv2_ReimportApi_cli_topic"></a>

O código de exemplo a seguir mostra como usar `reimport-api`.

**AWS CLI**  
**Para reimportar uma API HTTP**  
O exemplo `reimport-api` a seguir atualiza uma API HTTP existente para usar a definição da OpenAPI 3.0 especificada em `api-definition.yaml`.  

```
aws apigatewayv2 reimport-api \
    --body file://api-definition.yaml \
    --api-id a1b2c3d4
```
Conteúdo de `api-definition.yaml`:  

```
openapi: 3.0.1
info:
    title: My Lambda API
    version: v1.0
paths:
    /hello:
        x-amazon-apigateway-any-method:
            x-amazon-apigateway-integration:
                payloadFormatVersion: 2.0
                type: aws_proxy
                httpMethod: POST
                uri: arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:12356789012:function:hello/invocations
                connectionType: INTERNET
```
Resultado:  

```
{
    "ApiEndpoint": "https://a1b2c3d4.execute-api.us-west-2.amazonaws.com",
    "ApiId": "a1b2c3d4",
    "ApiKeySelectionExpression": "$request.header.x-api-key",
    "CreatedDate": "2020-04-08T17:19:38+00:00",
    "Name": "My Lambda API",
    "ProtocolType": "HTTP",
    "RouteSelectionExpression": "$request.method $request.path",
    "Tags": {},
    "Version": "v1.0"
}
```
Para obter mais informações, consulte [Trabalhar com definições da OpenAPI para APIs HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-open-api.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [ReimportApi](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/reimport-api.html) na *Referência de comandos da AWS CLI*. 

### `tag-resource`
<a name="apigatewayv2_TagResource_cli_topic"></a>

O código de exemplo a seguir mostra como usar `tag-resource`.

**AWS CLI**  
**Como marcar um recurso**  
O exemplo `tag-resource` a seguir adiciona uma tag com o nome de chave `Department` e um valor de `Accounting` à API especificada.  

```
aws apigatewayv2 tag-resource \
    --resource-arn arn:aws:apigateway:us-west-2::/apis/a1b2c3d4 \
    --tags Department=Accounting
```
Este comando não produz saída.  
Para obter mais informações, consulte [Marcar recursos do API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-tagging.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Consulte detalhes da API em [TagResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/tag-resource.html) na *Referência de comandos da AWS CLI*. 

### `untag-resource`
<a name="apigatewayv2_UntagResource_cli_topic"></a>

O código de exemplo a seguir mostra como usar `untag-resource`.

**AWS CLI**  
**Como remover as tags de um recurso**  
O exemplo `untag-resource` a seguir remove as tags com os nomes das chaves `Project` e `Owner` da API especificada.  

```
aws apigatewayv2 untag-resource \
    --resource-arn arn:aws:apigateway:us-west-2::/apis/a1b2c3d4 \
    --tag-keys Project Owner
```
Este comando não produz saída.  
Para obter mais informações, consulte [Marcar recursos do API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-tagging.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para obter detalhes sobre a API, consulte [UntagResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/untag-resource.html) na *Referência de comandos da AWS CLI*. 

### `update-api-mapping`
<a name="apigatewayv2_UpdateApiMapping_cli_topic"></a>

O código de exemplo a seguir mostra como usar `update-api-mapping`.

**AWS CLI**  
**Para criar um mapeamento de API**  
O exemplo `update-api-mapping` a seguir altera um mapeamento de API de um nome de domínio personalizado. Como resultado, a URL base usando o nome de domínio personalizado para a API e estágio especificados se torna `https://api.example.com/dev`.  

```
aws apigatewayv2 update-api-mapping \
    --api-id a1b2c3d4 \
    --stage dev \
    --domain-name api.example.com \
    --api-mapping-id 0qzs2sy7bh \
    --api-mapping-key dev
```
Resultado:  

```
{
    "ApiId": "a1b2c3d4",
    "ApiMappingId": "0qzs2sy7bh",
    "ApiMappingKey": "dev"
    "Stage": "dev"
}
```
Para obter mais informações, consulte [Configurar um nome de domínio personalizado regional no API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-regional-api-custom-domain-create.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [UpdateApiMapping](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/update-api-mapping.html) na *Referência de comandos da AWS CLI*. 

### `update-api`
<a name="apigatewayv2_UpdateApi_cli_topic"></a>

O código de exemplo a seguir mostra como usar `update-api`.

**AWS CLI**  
**Para habilitar o CORS para uma API HTTP**  
O exemplo `update-api` a seguir atualiza a configuração CORS da API especificada para permitir solicitações de `https://www.example.com`.  

```
aws apigatewayv2 update-api \
    --api-id a1b2c3d4 \
    --cors-configuration AllowOrigins=https://www.example.com
```
Resultado:  

```
{
    "ApiEndpoint": "https://a1b2c3d4.execute-api.us-west-2.amazonaws.com",
    "ApiId": "a1b2c3d4",
    "ApiKeySelectionExpression": "$request.header.x-api-key",
    "CorsConfiguration": {
        "AllowCredentials": false,
        "AllowHeaders": [
            "header1",
            "header2"
        ],
        "AllowMethods": [
            "GET",
            "OPTIONS"
        ],
        "AllowOrigins": [
            "https://www.example.com"
        ]
    },
    "CreatedDate": "2020-04-08T18:39:37+00:00",
    "Name": "my-http-api",
    "ProtocolType": "HTTP",
    "RouteSelectionExpression": "$request.method $request.path",
    "Tags": {},
    "Version": "v1.0"
}
```
Para obter mais informações, consulte [Configurar o CORS para uma API HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-cors.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [UpdateApi](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/update-api.html) na *Referência de comandos da AWS CLI*. 

### `update-authorizer`
<a name="apigatewayv2_UpdateAuthorizer_cli_topic"></a>

O código de exemplo a seguir mostra como usar `update-authorizer`.

**AWS CLI**  
**Para atualizar um autorizador**  
O exemplo `update-authorizer` a seguir altera a fonte de identidade de um autorizador do JWT para um cabeçalho chamado `Authorization`.  

```
aws apigatewayv2 update-authorizer \
    --api-id a1b2c3d4 \
    --authorizer-id a1b2c3 \
    --identity-source '$request.header.Authorization'
```
Resultado:  

```
{
    "AuthorizerId": "a1b2c3",
    "AuthorizerType": "JWT",
    "IdentitySource": [
        "$request.header.Authorization"
    ],
    "JwtConfiguration": {
        "Audience": [
            "123456abc"
        ],
        "Issuer": "https://cognito-idp.us-west-2.amazonaws.com/us-west-2_abc123"
    },
    "Name": "my-jwt-authorizer"
}
```
Para obter mais informações, consulte [Controlar o acesso a APIs HTTP com autorizadores JWT](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-jwt-authorizer.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [UpdateAuthorizer](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/update-authorizer.html) na *Referência de comandos da AWS CLI*. 

### `update-deployment`
<a name="apigatewayv2_UpdateDeployment_cli_topic"></a>

O código de exemplo a seguir mostra como usar `update-deployment`.

**AWS CLI**  
**Para alterar a descrição de uma implantação**  
O exemplo `update-deployment` a seguir atualiza a descrição de uma implantação.  

```
aws apigatewayv2 update-deployment \
    --api-id a1b2c3d4 \
    --deployment-id abcdef \
    --description 'Manual deployment to fix integration test failures.'
```
Resultado:  

```
{
    "AutoDeployed": false,
    "CreatedDate": "2020-02-05T16:21:48+00:00",
    "DeploymentId": "abcdef",
    "DeploymentStatus": "DEPLOYED",
    "Description": "Manual deployment to fix integration test failures."
}
```
Para obter mais informações, consulte [Desenvolver uma API HTTP no API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [UpdateDeployment](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/update-deployment.html) na *Referência de comandos da AWS CLI*. 

### `update-domain-name`
<a name="apigatewayv2_UpdateDomainName_cli_topic"></a>

O código de exemplo a seguir mostra como usar `update-domain-name`.

**AWS CLI**  
**Para atualizar um nome de domínio personalizado**  
O exemplo `update-domain-name` a seguir especifica um novo certificado ACM para o nome de domínio personalizado `api.example.com`.  

```
aws apigatewayv2 update-domain-name \
    --domain-name api.example.com \
    --domain-name-configurations CertificateArn=arn:aws:acm:us-west-2:123456789012:certificate/123456789012-1234-1234-1234-12345678
```
Resultado:  

```
{
    "ApiMappingSelectionExpression": "$request.basepath",
    "DomainName": "regional.example.com",
    "DomainNameConfigurations": [
        {
            "ApiGatewayDomainName": "d-id.execute-api.us-west-2.amazonaws.com",
            "CertificateArn": "arn:aws:acm:us-west-2:123456789012:certificate/123456789012-1234-1234-1234-12345678",
            "EndpointType": "REGIONAL",
            "HostedZoneId": "123456789111",
            "SecurityPolicy": "TLS_1_2",
            "DomainNameStatus": "AVAILABLE"
        }
    ]
}
```
Para obter mais informações, consulte [Configurar um nome de domínio personalizado regional no API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-regional-api-custom-domain-create.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/apigatewayv2/update-domain-name.html) na *Referência de comandos da AWS CLI*. 

### `update-integration`
<a name="apigatewayv2_UpdateIntegration_cli_topic"></a>

O código de exemplo a seguir mostra como usar `update-integration`.

**AWS CLI**  
**Para atualizar uma integração com o Lambda**  
O exemplo `update-integration` a seguir atualiza uma integração existente do AWS Lambda para usar a função do Lambda especificada.  

```
aws apigatewayv2 update-integration \
    --api-id a1b2c3d4 \
    --integration-id a1b2c3 \
    --integration-uri arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:my-new-function/invocations
```
Resultado:  

```
{
    "ConnectionType": "INTERNET",
    "IntegrationId": "a1b2c3",
    "IntegrationMethod": "POST",
    "IntegrationType": "AWS_PROXY",
    "IntegrationUri": "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:my-new-function/invocations",
    "PayloadFormatVersion": "2.0",
    "TimeoutInMillis": 5000
}
```
Para obter mais informações, consulte [Configurar integrações para APIs HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations.html) e [Configurar integrações de APIs de WebSocket](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-websocket-api-integrations.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [UpdateIntegration](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/update-integration.html) na *Referência de comandos da AWS CLI*. 

### `update-route`
<a name="apigatewayv2_UpdateRoute_cli_topic"></a>

O código de exemplo a seguir mostra como usar `update-route`.

**AWS CLI**  
**Exemplo 1: atualizar a integração de uma rota**  
O exemplo `update-route` a seguir atualiza a integração de uma rota especificada.  

```
aws apigatewayv2 update-route \
    --api-id a1b2c3d4 \
    --route-id a1b2c3 \
    --target integrations/a1b2c6
```
Resultado:  

```
{
    "ApiKeyRequired": false,
    "AuthorizationType": "NONE",
    "RouteId": "a1b2c3",
    "RouteKey": "ANY /pets",
    "Target": "integrations/a1b2c6"
}
```
**Exemplo 2: adicionar um autorizador a uma rota**  
O exemplo `update-route` a seguir atualiza uma rota para usar um autorizador JWT.  

```
aws apigatewayv2 update-route \
    --api-id a1b2c3d4  \
    --route-id a1b2c3  \
    --authorization-type JWT \
    --authorizer-id a1b2c5 \
    --authorization-scopes user.id user.email
```
Resultado:  

```
{
    "ApiKeyRequired": false,
    "AuthorizationScopes": [
        "user.id",
        "user.email"
    ],
    "AuthorizationType": "JWT",
    "AuthorizerId": "a1b2c5",
    "OperationName": "GET HTTP",
    "RequestParameters": {},
    "RouteId": "a1b2c3",
    "RouteKey": "GET /pets",
    "Target": "integrations/a1b2c6"
}
```
Para obter mais informações, consulte [Controlar o acesso a APIs HTTP com autorizadores JWT](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-jwt-authorizer.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [UpdateRoute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/update-route.html) na *Referência de comandos da AWS CLI*. 

### `update-stage`
<a name="apigatewayv2_UpdateStage_cli_topic"></a>

O código de exemplo a seguir mostra como usar `update-stage`.

**AWS CLI**  
**Como configurar o controle de utilização personalizado**  
O exemplo `update-stage` a seguir configura o controle de utilização personalizado para o estágio especificado e a rota de uma API.  

```
aws apigatewayv2 update-stage \
    --api-id a1b2c3d4 \
    --stage-name dev \
    --route-settings '{"GET /pets":{"ThrottlingBurstLimit":100,"ThrottlingRateLimit":2000}}'
```
Resultado:  

```
{
    "CreatedDate": "2020-04-05T16:21:16+00:00",
    "DefaultRouteSettings": {
        "DetailedMetricsEnabled": false
    },
    "DeploymentId": "shktxb",
    "LastUpdatedDate": "2020-04-08T22:23:17+00:00",
    "RouteSettings": {
        "GET /pets": {
            "ThrottlingBurstLimit": 100,
            "ThrottlingRateLimit": 2000.0
        }
    },
    "StageName": "dev",
    "StageVariables": {},
    "Tags": {}
}
```
Para obter mais informações, consulte [Proteger sua API HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-protect.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/apigatewayv2/update-stage.html) na *Referência de comandos da AWS CLI*. 

### `update-vpc-link`
<a name="apigatewayv2_UpdateVpcLink_cli_topic"></a>

O código de exemplo a seguir mostra como usar `update-vpc-link`.

**AWS CLI**  
**Para atualizar um link da VPC**  
O exemplo `update-vpc-link` a seguir atualiza o nome de um link da VPC. Depois de criar um link de VPC, você não pode alterar seus grupos de segurança ou sub-redes.  

```
aws apigatewayv2 update-vpc-link \
    --vpc-link-id abcd123 \
    --name MyUpdatedVpcLink
```
Resultado:  

```
{
    "CreatedDate": "2020-04-07T00:27:47Z",
    "Name": "MyUpdatedVpcLink",
    "SecurityGroupIds": [
        "sg1234",
        "sg5678"
    ],
    "SubnetIds": [
        "subnet-aaaa",
        "subnet-bbbb"
    ],
    "Tags": {},
    "VpcLinkId": "abcd123",
    "VpcLinkStatus": "AVAILABLE",
    "VpcLinkStatusMessage": "VPC link is ready to route traffic",
    "VpcLinkVersion": "V2"
}
```
Para obter mais informações, consulte [Trabalhar com links da VPC para APIs HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-vpc-links.html) no *Guia do desenvolvedor do Amazon API Gateway*.  
+  Para ver detalhes da API, consulte [UpdateVpcLink](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/apigatewayv2/update-vpc-link.html) na *Referência de comandos da AWS CLI*.