

# Criar integrações para APIs HTTP no API Gateway
<a name="http-api-develop-integrations"></a>

*Integrações* conectam uma rota aos recursos de backend. As APIs HTTP são compatíveis com integrações de proxy do Lambda, serviços da AWS e proxy HTTP. Por exemplo, é possível configurar uma solicitação `POST` para a rota `/signup` da sua API para se integrar a uma função do Lambda que lida com o cadastro de clientes.

**Topics**
+ [

# Criar integrações de proxy AWS Lambda para APIs HTTP no API Gateway
](http-api-develop-integrations-lambda.md)
+ [

# Criar integrações de proxy HTTP para APIs HTTP
](http-api-develop-integrations-http.md)
+ [

# Criar integrações de serviços da AWS para APIs HTTP no API Gateway
](http-api-develop-integrations-aws-services.md)
+ [

# Criar integrações privadas para APIs HTTP no API Gateway
](http-api-develop-integrations-private.md)

# Criar integrações de proxy AWS Lambda para APIs HTTP no API Gateway
<a name="http-api-develop-integrations-lambda"></a>

Uma integração de proxy do Lambda permite integrar uma rota de API com uma função do Lambda. Quando um cliente chama sua API, o API Gateway envia a solicitação para a função do Lambda e retorna a resposta da função para o cliente. Para obter exemplos de criação de uma API HTTP, consulte [Criar uma API HTTP](http-api-develop.md#http-api-examples).

## Versão do formato da carga útil
<a name="http-api-develop-integrations-lambda.proxy-format"></a>

A versão do formato de carga útil especifica o formato do evento que o API Gateway envia para uma integração do Lambda e como o API Gateway interpreta a resposta do Lambda. Por padrão, se você não especificar uma versão de formato de carga útil, o Console de gerenciamento da AWS usará a versão mais recente. Se você criar uma integração do Lambda usando a AWS CLI, o CloudFormation ou um SDK, será necessário especificar um `payloadFormatVersion`. Os valores suportados são `1.0` e `2.0`.

Para saber mais sobre como definir o`payloadFormatVersion`, consulte [create-integration](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/create-integration.html). Para saber mais sobre como determinar a `payloadFormatVersion` de uma integração existente, consulte [get-integration](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/get-integration.html).

### Diferenças do formato da carga útil
<a name="http-api-develop-integrations-lambda.proxy-format-differences"></a>

A lista a seguir mostra as diferenças entre as versões do formato da carga útil `1.0` e `2.0`:
+ O formato `2.0` não tem campos `multiValueHeaders` ou `multiValueQueryStringParameters`. Os cabeçalhos duplicados são combinados com vírgulas e incluídos no campo `headers`. As strings de consulta duplicadas são combinadas com vírgulas e incluídas no campo `queryStringParameters`.
+ O formato `2.0` tem `rawPath`. Se você usar um mapeamento de API para associar o estágio a um nome de domínio personalizado, `rawPath` não fornecerá o valor do mapeamento de API. Use o formato `1.0` e `path` para acessar o mapeamento da API de seu nome de domínio personalizado.
+ O formato `2.0` inclui um novo campo `cookies`. Todos os cabeçalhos de cookie na solicitação são combinados com vírgulas e adicionados ao campo `cookies`. Na resposta ao cliente, cada cookie torna-se um cabeçalho `set-cookie`.

### Estrutura do formato da carga útil
<a name="http-api-develop-integrations-lambda.proxy-format-structure"></a>

Os exemplos a seguir mostram a estrutura de cada versão do formato de carga útil. Todos os nomes de cabeçalho ficam em letras minúsculas.

------
#### [ 2.0 ]

```
{
  "version": "2.0",
  "routeKey": "$default",
  "rawPath": "/my/path",
  "rawQueryString": "parameter1=value1&parameter1=value2&parameter2=value",
  "cookies": [
    "cookie1",
    "cookie2"
  ],
  "headers": {
    "header1": "value1",
    "header2": "value1,value2"
  },
  "queryStringParameters": {
    "parameter1": "value1,value2",
    "parameter2": "value"
  },
  "requestContext": {
    "accountId": "123456789012",
    "apiId": "api-id",
    "authentication": {
      "clientCert": {
        "clientCertPem": "CERT_CONTENT",
        "subjectDN": "www.example.com",
        "issuerDN": "Example issuer",
        "serialNumber": "a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1",
        "validity": {
          "notBefore": "May 28 12:30:02 2019 GMT",
          "notAfter": "Aug  5 09:36:04 2021 GMT"
        }
      }
    },
    "authorizer": {
      "jwt": {
        "claims": {
          "claim1": "value1",
          "claim2": "value2"
        },
        "scopes": [
          "scope1",
          "scope2"
        ]
      }
    },
    "domainName": "id.execute-api.us-east-1.amazonaws.com",
    "domainPrefix": "id",
    "http": {
      "method": "POST",
      "path": "/my/path",
      "protocol": "HTTP/1.1",
      "sourceIp": "192.0.2.1",
      "userAgent": "agent"
    },
    "requestId": "id",
    "routeKey": "$default",
    "stage": "$default",
    "time": "12/Mar/2020:19:03:58 +0000",
    "timeEpoch": 1583348638390
  },
  "body": "Hello from Lambda",
  "pathParameters": {
    "parameter1": "value1"
  },
  "isBase64Encoded": false,
  "stageVariables": {
    "stageVariable1": "value1",
    "stageVariable2": "value2"
  }
}
```

------
#### [ 1.0 ]

```
{
  "version": "1.0",
  "resource": "/my/path",
  "path": "/my/path",
  "httpMethod": "GET",
  "headers": {
    "header1": "value1",
    "header2": "value2"
  },
  "multiValueHeaders": {
    "header1": [
      "value1"
    ],
    "header2": [
      "value1",
      "value2"
    ]
  },
  "queryStringParameters": {
    "parameter1": "value1",
    "parameter2": "value"
  },
  "multiValueQueryStringParameters": {
    "parameter1": [
      "value1",
      "value2"
    ],
    "parameter2": [
      "value"
    ]
  },
  "requestContext": {
    "accountId": "123456789012",
    "apiId": "id",
    "authorizer": {
      "claims": null,
      "scopes": null
    },
    "domainName": "id.execute-api.us-east-1.amazonaws.com",
    "domainPrefix": "id",
    "extendedRequestId": "request-id",
    "httpMethod": "GET",
    "identity": {
      "accessKey": null,
      "accountId": null,
      "caller": null,
      "cognitoAuthenticationProvider": null,
      "cognitoAuthenticationType": null,
      "cognitoIdentityId": null,
      "cognitoIdentityPoolId": null,
      "principalOrgId": null,
      "sourceIp": "192.0.2.1",
      "user": null,
      "userAgent": "user-agent",
      "userArn": null,
      "clientCert": {
        "clientCertPem": "CERT_CONTENT",
        "subjectDN": "www.example.com",
        "issuerDN": "Example issuer",
        "serialNumber": "a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1",
        "validity": {
          "notBefore": "May 28 12:30:02 2019 GMT",
          "notAfter": "Aug  5 09:36:04 2021 GMT"
        }
      }
    },
    "path": "/my/path",
    "protocol": "HTTP/1.1",
    "requestId": "id=",
    "requestTime": "04/Mar/2020:19:15:17 +0000",
    "requestTimeEpoch": 1583349317135,
    "resourceId": null,
    "resourcePath": "/my/path",
    "stage": "$default"
  },
  "pathParameters": null,
  "stageVariables": null,
  "body": "Hello from Lambda!",
  "isBase64Encoded": false
}
```

------

## Formato de resposta da função do Lambda
<a name="http-api-develop-integrations-lambda.response"></a>

A versão do formato da carga determina a estrutura da resposta que a função do Lambda deve retornar.

### Resposta de função do Lambda para o formato 1.0
<a name="http-api-develop-integrations-lambda.v1"></a>

Com a versão do formato `1.0`, as integrações do Lambda devem retornar uma resposta no formato JSON a seguir:

**Example**  

```
{
    "isBase64Encoded": true|false,
    "statusCode": httpStatusCode,
    "headers": { "headername": "headervalue", ... },
    "multiValueHeaders": { "headername": ["headervalue", "headervalue2", ...], ... },
    "body": "..."
}
```

### Resposta de função do Lambda para o formato 2.0
<a name="http-api-develop-integrations-lambda.v2"></a>

Com a versão de formato `2.0`, o API Gateway pode inferir o formato de resposta para você. O API Gateway fará as suposições a seguir se sua função do Lambda retornar JSON válido e não retornar um `statusCode`:
+ `isBase64Encoded` é `false`.
+ `statusCode` é `200`.
+ `content-type` é `application/json`.
+ `body` é a resposta da função.

Os exemplos a seguir mostram a saída de uma função do Lambda e a interpretação do API Gateway.


| Saída da função do Lambda | Interpretação do API Gateway | 
| --- | --- | 
|  <pre>"Hello from Lambda!"</pre>  |  <pre>{<br />  "isBase64Encoded": false,<br />  "statusCode": 200,<br />  "body": "Hello from Lambda!",<br />  "headers": {<br />    "content-type": "application/json"<br />  }<br />}</pre>  | 
|  <pre>{ "message": "Hello from Lambda!" }</pre>  |  <pre>{<br />  "isBase64Encoded": false,<br />  "statusCode": 200,<br />  "body": "{ \"message\": \"Hello from Lambda!\" }",<br />  "headers": {<br />    "content-type": "application/json"<br />  }<br />}</pre>  | 

Para personalizar a resposta, a função do Lambda deve retornar uma resposta com o formato a seguir.

```
{
    "cookies" : ["cookie1", "cookie2"],
    "isBase64Encoded": true|false,
    "statusCode": httpStatusCode,
    "headers": { "headername": "headervalue", ... },
    "body": "Hello from Lambda!"
}
```

# Criar integrações de proxy HTTP para APIs HTTP
<a name="http-api-develop-integrations-http"></a>

Uma integração de proxy HTTP permite que você conecte uma rota de API a um endpoint HTTP roteável publicamente. Com esse tipo de integração, o API Gateway transmite toda a solicitação e resposta entre o front-end e o backend. 

Para criar uma integração de proxy HTTP, forneça a URL de um endpoint HTTP roteável publicamente.

## Integração de proxy HTTP com variáveis de caminho
<a name="http-api-develop-integrations-http-proxy"></a>

É possível usar variáveis de caminho em rotas de API HTTP.

Por exemplo, a rota `/pets/{petID}` captura solicitações para a `/pets/6`. Você pode fazer referência a variáveis de caminho no URI de integração para enviar o conteúdo das variáveis para uma integração. Um exemplo é `/pets/extendedpath/{petID}`.

Você pode usar variáveis de caminho voraz para capturar todos os recursos filho de uma rota. Para criar uma variável de caminho voraz, adicione `+` ao nome da variável, por exemplo, `{proxy+}`. 

Para configurar uma rota com uma integração de proxy HTTP que captura todas as solicitações, crie uma rota de API com uma variável de caminho voraz (por exemplo, `/parent/{proxy+}`). Integre a rota a um endpoint HTTP (por exemplo, `https://petstore-demo-endpoint.execute-api.com/petstore/{proxy}`) no método `ANY`. O parâmetro de caminho voraz deve estar no final do caminho do recurso.

# Criar integrações de serviços da AWS para APIs HTTP no API Gateway
<a name="http-api-develop-integrations-aws-services"></a>

Você pode integrar sua API HTTP com serviços da AWS usando *integrações de primeira classe*. Uma integração de primeira classe conecta uma rota de API HTTP a uma API de serviço da AWS. Quando um cliente invoca uma rota apoiada por uma integração de primeira classe, o API Gateway invoca uma API de serviço da AWS para você. Por exemplo, é possível usar integrações de primeira classe para enviar uma mensagem para uma fila do Amazon Simple Queue Service ou iniciar uma máquina de estado do AWS Step Functions. Para obter ações de serviço compatíveis, consulte [Referência do subtipo de integração](http-api-develop-integrations-aws-services-reference.md).

## Mapear parâmetros de solicitação
<a name="http-api-develop-integrations-aws-services-parameter-mapping"></a>

Integrações de primeira classe têm parâmetros obrigatórios e opcionais. É necessário configurar todos os parâmetros necessários para criar uma integração. Você pode usar valores estáticos ou mapear parâmetros que são avaliados dinamicamente no tempo de execução. Para obter uma lista completa de integrações e parâmetros compatíveis, consulte [Referência do subtipo de integração](http-api-develop-integrations-aws-services-reference.md).

A tabela a seguir descreve os parâmetros de solicitação de mapeamento compatíveis.


| Tipo | Exemplo | Observações | 
| --- | --- | --- | 
| Valor de cabeçalho | \$1request.header.nome | Nomes de cabeçalhos não diferenciam maiúsculas de minúsculas. O API Gateway combina vários valores de cabeçalho com vírgulas, por exemplo, "header1": "value1,value2". | 
| Valor da string de consulta | \$1request.querystring.nome | Os nomes de strings de consulta diferenciam maiúsculas e minúsculas O API Gateway combina vários valores com vírgulas, por exemplo, "querystring1": "Value1,Value2". | 
| Parâmetro de caminho | \$1request.path.name | O valor de um parâmetro de caminho na solicitação. Por exemplo, se a rota for /pets/\$1petId\$1, você poderá mapear o parâmetro petId da solicitação com \$1request.path.petId. | 
| Solicitar passagem do corpo | \$1request.body | O API Gateway transmite todo o corpo da solicitação. | 
| Corpo da solicitação | \$1request.body.name | Uma [expressão de caminho JSON](https://goessner.net/articles/JsonPath/index.html#e2). Descidas recursivas (\$1request.body..name) e expressões de filtro (?(expression)) não são compatíveis.  Quando você especifica um caminho JSON, o API Gateway trunca o corpo da solicitação em 100 KB e, em seguida, aplica a expressão de seleção. Para enviar cargas maiores que 100 KB, especifique `$request.body`.   | 
| Variável de contexto | \$1context.variableName | O valor de uma [variável de contexto](http-api-logging-variables.md) compatível. | 
| Variável de estágio | \$1stageVariables.variableName | O valor de uma [variável de estágio](http-api-stages.stage-variables.md). | 
| Valor estático | string | Um valor constante. | 

## Criar uma integração de primeira classe
<a name="http-api-develop-integrations-aws-services-example"></a>

Antes de criar uma integração de primeira classe, é necessário criar uma função do IAM que conceda ao API Gateway permissões para invocar a ação de serviço da AWS à qual você está se integrando. Para saber mais, consulte [Criação de uma função para um serviço da AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html).

Para criar uma integração de primeira classe, escolha uma ação de serviço da AWS compatível, como `SQS-SendMessage`, configure os parâmetros de solicitação e forneça uma função que conceda ao API Gateway permissões para invocar a API de serviço integrado da AWS. Dependendo do subtipo de integração, diferentes parâmetros de solicitação são necessários. Para saber mais, consulte [Referência do subtipo de integração](http-api-develop-integrations-aws-services-reference.md).

O comando [create-integration](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/create-integration.html) indicado abaixo cria uma integração que envia uma mensagem do Amazon SQS:

```
aws apigatewayv2 create-integration \
    --api-id abcdef123 \
    --integration-subtype SQS-SendMessage \
    --integration-type AWS_PROXY \
    --payload-format-version 1.0 \
    --credentials-arn arn:aws:iam::123456789012:role/apigateway-sqs \
    --request-parameters '{"QueueUrl": "$request.header.queueUrl", "MessageBody": "$request.body.message"}'
```

## Criar uma integração de primeira classe usando o CloudFormation
<a name="http-api-develop-integrations-aws-services-example-cfn"></a>

O exemplo a seguir mostra um trecho do CloudFormation que cria uma rota `/{source}/{detailType}` com uma integração de primeira classe com o Amazon EventBridge.

O parâmetro `Source` é mapeado para o parâmetro de caminho `{source}`, o `DetailType` é mapeado para o parâmetro de caminho `{DetailType}` e o parâmetro `Detail` é mapeado para o corpo da solicitação.

O trecho não mostra o barramento de eventos ou o perfil do IAM que concede permissões ao API Gateway para invocar a ação `PutEvents`.

```
Route:
    Type: AWS::ApiGatewayV2::Route
    Properties:
      ApiId: !Ref HttpApi
      AuthorizationType: None
      RouteKey: 'POST /{source}/{detailType}'
      Target: !Join 
        - /
        - - integrations
          - !Ref Integration
  Integration:
    Type: AWS::ApiGatewayV2::Integration
    Properties:
      ApiId: !Ref HttpApi
      IntegrationType: AWS_PROXY
      IntegrationSubtype: EventBridge-PutEvents
      CredentialsArn: !GetAtt EventBridgeRole.Arn
      RequestParameters:
        Source: $request.path.source
        DetailType: $request.path.detailType
        Detail: $request.body
        EventBusName: !GetAtt EventBus.Arn
      PayloadFormatVersion: "1.0"
```

# Referência do subtipo de integração
<a name="http-api-develop-integrations-aws-services-reference"></a>

Os [subtipos de integração](https://docs.aws.amazon.com/apigatewayv2/latest/api-reference/apis-apiid-integrations-integrationid.html#apis-apiid-integrations-integrationid-prop-integration-integrationsubtype) a seguir são compatíveis com APIs HTTP.

**Topics**
+ [

## EventBridge-PutEvents 1.0
](#EventBridge-PutEvents)
+ [

## SQS-SendMessage 1.0
](#SQS-SendMessage)
+ [

## SQS-ReceiveMessage 1.0
](#SQS-ReceiveMessage)
+ [

## SQS-DeleteMessage 1.0
](#SQS-DeleteMessage)
+ [

## SQS-PurgeQueue 1.0
](#SQS-PurgeQueue)
+ [

## AppConfig-GetConfiguration 1.0
](#AppConfig-GetConfiguration)
+ [

## Kinesis-PutRecord 1.0
](#Kinesis-PutRecord)
+ [

## StepFunctions-StartExecution 1.0
](#StepFunctions-StartExecution)
+ [

## StepFunctions-StartSyncExecution 1.0
](#StepFunctions-StartSyncExecution)
+ [

## StepFunctions-StopExecution 1.0
](#StepFunctions-StopExecution)

## EventBridge-PutEvents 1.0
<a name="EventBridge-PutEvents"></a>

Envia eventos personalizados para o Amazon EventBridge para que eles possam ser correspondidos a regras.


| Parâmetro | Obrigatório | 
| --- | --- | 
| Detalhes | Verdadeiro | 
| DetailType | Verdadeiro | 
| Origem | Verdadeiro | 
| Tempo | Falso | 
| EventBusName | Falso | 
| Recursos | Falso | 
| Região | Falso | 
| TraceHeader | Falso | 

Para saber mais, consulte [PutEvents](https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutEvents.html) na *Referência de API do Amazon EventBridge*.

## SQS-SendMessage 1.0
<a name="SQS-SendMessage"></a>

Entrega uma mensagem para a fila especificada.


| Parâmetro | Obrigatório | 
| --- | --- | 
| QueueUrl | Verdadeiro | 
| MessageBody | Verdadeiro | 
| DelaySeconds | Falso | 
| MessageAttributes | Falso | 
| MessageDeduplicationId | Falso | 
| MessageGroupId | Falso | 
| MessageSystemAttributes | Falso | 
| Região | Falso | 

Para saber mais, consulte [SendMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html) na *Referência de API do Amazon Simple Queue Service*.

## SQS-ReceiveMessage 1.0
<a name="SQS-ReceiveMessage"></a>

Recupera uma ou mais mensagens (até 10) de uma fila especificada.


| Parâmetro | Obrigatório | 
| --- | --- | 
| QueueUrl | Verdadeiro | 
| AttributeNames | Falso | 
| MaxNumberOfMessages | Falso | 
| MessageAttributeNames | Falso | 
| ReceiveRequestAttemptId | Falso | 
| VisibilityTimeout | Falso | 
| WaitTimeSeconds | Falso | 
| Região | Falso | 

Para saber mais, consulte [ReceiveMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_ReceiveMessage.html) na *Referência de API do Amazon Simple Queue Service*.

## SQS-DeleteMessage 1.0
<a name="SQS-DeleteMessage"></a>

Exclui a mensagem especificada da fila especificada.


| Parâmetro | Obrigatório | 
| --- | --- | 
| ReceiptHandle | Verdadeiro | 
| QueueUrl | Verdadeiro | 
| Região | Falso | 

Para saber mais, consulte [DeleteMessage](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_DeleteMessage.html) na *Referência de API do Amazon Simple Queue Service*.

## SQS-PurgeQueue 1.0
<a name="SQS-PurgeQueue"></a>

Exclui todas as mensagens da fila especificada.


| Parâmetro | Obrigatório | 
| --- | --- | 
| QueueUrl | Verdadeiro | 
| Região | Falso | 

Para saber mais, consulte [PurgeQueue](https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_PurgeQueue.html) na *Referência de API do Amazon Simple Queue Service*.

## AppConfig-GetConfiguration 1.0
<a name="AppConfig-GetConfiguration"></a>

Receba informações sobre uma configuração.


| Parâmetro | Obrigatório | 
| --- | --- | 
| Aplicativo | Verdadeiro | 
| Ambiente | Verdadeiro | 
| Configuração | Verdadeiro | 
| ClientId | Verdadeiro | 
| ClientConfigurationVersion | Falso | 
| Região | Falso | 

Para saber mais, consulte [GetConfiguration](https://docs.aws.amazon.com/appconfig/2019-10-09/APIReference/API_GetConfiguration.html) na *Referência da API AppConfig da AWS*.

## Kinesis-PutRecord 1.0
<a name="Kinesis-PutRecord"></a>

Grava um único registro de dados em um stream de dados do Amazon Kinesis.


| Parâmetro | Obrigatório | 
| --- | --- | 
| StreamName | Verdadeiro | 
| Dados | Verdadeiro | 
| PartitionKey | Verdadeiro | 
| SequenceNumberForOrdering | Falso | 
| ExplicitHashKey | Falso | 
| Região | Falso | 

Para saber mais, consulte [PutRecord](https://docs.aws.amazon.com/kinesis/latest/APIReference/API_PutRecord.html) na *Referência de API do Amazon Kinesis Data Streams*.

## StepFunctions-StartExecution 1.0
<a name="StepFunctions-StartExecution"></a>

Inicia uma execução de máquina de estado.


| Parâmetro | Obrigatório | 
| --- | --- | 
| StateMachineArn | Verdadeiro | 
| Nome | Falso | 
| Entrada | Falso | 
| Região | Falso | 

Para saber mais, consulte [StartExecution](https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartExecution.html) na *Referência da API do AWS Step Functions*.

## StepFunctions-StartSyncExecution 1.0
<a name="StepFunctions-StartSyncExecution"></a>

Inicia uma execução de máquina de estado síncrono.


| Parâmetro | Obrigatório | 
| --- | --- | 
| StateMachineArn | Verdadeiro | 
| Nome | Falso | 
| Entrada | Falso | 
| Região | Falso | 
| TraceHeader | Falso | 

Para saber mais, consulte [StartSyncExecution](https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartSyncExecution.html) na *Referência da API do AWS Step Functions*.

## StepFunctions-StopExecution 1.0
<a name="StepFunctions-StopExecution"></a>

Interrompe uma execução.


| Parâmetro | Obrigatório | 
| --- | --- | 
| ExecutionArn | Verdadeiro | 
| Causa | Falso | 
| Erro | Falso | 
| Região | Falso | 

Para saber mais, consulte [StopExecution](https://docs.aws.amazon.com/step-functions/latest/apireference/API_StopExecution.html) na *Referência da API do AWS Step Functions*.

# Criar integrações privadas para APIs HTTP no API Gateway
<a name="http-api-develop-integrations-private"></a>

As integrações privadas permitem que você crie integrações de API com recursos privados em uma VPC, como Application Load Balancers ou aplicações baseadas em contêiner do Amazon ECS. 

Você pode expor seus recursos em uma VPC para acesso por clientes fora da VPC usando integrações privadas. Você pode controlar o acesso à sua API usando qualquer um dos [ métodos de autorização](http-api-access-control.md) compatíveis com o API Gateway.

**nota**  
Para criar uma integração privada, primeiro crie um link de VPC. Os links da VPC V2 agora comportam APIs HTTP e REST. Para saber mais sobre links da VPC V2, consulte [Configurar links da VPC V2 no API Gateway](apigateway-vpc-links-v2.md). 

Depois de criar um link da VPC V2, é possível configurar integrações privadas que se conectam a um Application Load Balancer, Network Load Balancer ou a recursos registrados em um serviço do AWS Cloud Map.

## Considerações
<a name="http-api-develop-integrations-private-considerations"></a>

As considerações a seguir podem afetar o uso de integrações privadas:
+ Todos os recursos devem ser de propriedade da mesma Conta da AWS. Isso inclui o balanceador de carga ou o serviço AWS Cloud Map, o link da VPC e a API HTTP.
+ Por padrão, o tráfego de integração privada usa o protocolo HTTP. Para usar HTTPS, especifique uma [https://docs.aws.amazon.com/apigatewayv2/latest/api-reference/apis-apiid-integrations-integrationid.html](https://docs.aws.amazon.com/apigatewayv2/latest/api-reference/apis-apiid-integrations-integrationid.html). Para fazer isso usando o Console de gerenciamento da AWS, ao criar sua integração privada, escolha **Configurações avançadas** e, depois, insira um nome de servidor seguro.
+ Para integrações privadas, o API Gateway inclui a parte do [estágio](http-api-stages.md) do endpoint da API na solicitação para seus recursos de backend. Por exemplo, uma solicitação para o estágio `test` de uma API inclui `test/route-path` na solicitação para sua integração privada. Para remover o nome do estágio da solicitação para os seus recursos de backend, use o [mapeamento de parâmetros](http-api-parameter-mapping.md) para substituir o caminho da solicitação para `$request.path`.

## Criar uma integração privada usando um Application Load Balancer ou Network Load Balancer
<a name="http-api-develop-integrations-private-ELB"></a>

Antes de criar uma integração privada, você deve criar um link da VPC V2. Para saber mais sobre links da VPC V2, consulte [Configurar links da VPC V2 no API Gateway](apigateway-vpc-links-v2.md).

Para criar uma integração privada com um Application Load Balancer ou Network Load Balancer, crie uma integração de proxy HTTP, especifique o link de VPC a ser usado e forneça o ARN de listener do balanceador de carga.

O comando [create-integration](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/create-integration.html) indicado abaixo cria uma integração privada que se conecta a um balanceador de carga usando um link de VPC.

```
aws apigatewayv2 create-integration --api-id api-id --integration-type HTTP_PROXY \
    --integration-method GET --connection-type VPC_LINK \
    --connection-id VPC-link-ID \
    --integration-uri arn:aws:elasticloadbalancing:us-east-2:123456789012:listener/app/my-load-balancer/50dc6c495c0c9188/0467ef3c8400ae65
    --payload-format-version 1.0
```

## Criar uma integração privada usando a descoberta de serviço do AWS Cloud Map
<a name="http-api-develop-integrations-private-Cloud-Map"></a>

Antes de criar uma integração privada, você deve criar um link da VPC V2. Para saber mais sobre links de VPC, consulte [Configurar links da VPC V2 no API Gateway](apigateway-vpc-links-v2.md).

Para integrações com o AWS Cloud Map, o API Gateway usa `DiscoverInstances` para identificar recursos. Você pode usar parâmetros de consulta para direcionar recursos específicos. Os atributos dos recursos registrados devem incluir endereços IP e portas. O API Gateway distribui solicitações entre recursos íntegros que são retornados de `DiscoverInstances`. Para saber mais, consulte [DiscoverInstances](https://docs.aws.amazon.com/cloud-map/latest/api/API_DiscoverInstances.html) na Referência da API do AWS Cloud Map.

**nota**  
Se usar o Amazon ECS para preencher entradas no AWS Cloud Map, você deverá configurar a tarefa do Amazon ECS para usar registros SRV com a descoberta de serviços do Amazon ECS ou ativar o Amazon ECS Service Connect. Para obter mais informações, consulte [Interconexão de serviços](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/interconnecting-services.html) no Guia do desenvolvedor do Amazon Elastic Container Service.

Para criar uma integração privada com o AWS Cloud Map, crie uma integração de proxy HTTP, especifique o link de VPC a ser usado e forneça o ARN do serviço AWS Cloud Map.

O comando [create-integration](https://docs.aws.amazon.com/cli/latest/reference/apigatewayv2/create-integration.html) indicado abaixo cria uma integração privada que usa a descoberta de serviços do AWS Cloud Map para identificar recursos:

```
aws apigatewayv2 create-integration --api-id api-id --integration-type HTTP_PROXY  \
    --integration-method GET --connection-type VPC_LINK \
    --connection-id VPC-link-ID \
    --integration-uri arn:aws:servicediscovery:us-east-2:123456789012:service/srv-id?stage=prod&deployment=green_deployment
    --payload-format-version 1.0
```