# Configurar a integração de proxy do Lambda para o API Gateway usando a AWS CLI
<a name="set-up-lambda-proxy-integration-using-cli"></a>

Nesta seção, mostramos como usar uma API com a integração de proxy do Lambda usando a AWS CLI. Para obter instruções detalhadas sobre como usar o console do API Gateway para configurar um recurso de proxy com a integração de proxy do Lambda, consulte [Tutorial: Crie uma API REST com uma integração de proxy do Lambda](api-gateway-create-api-as-simple-proxy-for-lambda.md).

Como exemplo, usamos a seguinte função do Lambda como o backend da API:

```
export const handler = async(event, context) => {
    console.log('Received event:', JSON.stringify(event, null, 2));
    var res ={
        "statusCode": 200,
        "headers": {
            "Content-Type": "*/*"
        }
    };
    var greeter = 'World';
    if (event.greeter && event.greeter!=="") {
        greeter =  event.greeter;
    } else if (event.body && event.body !== "") {
        var body = JSON.parse(event.body);
        if (body.greeter && body.greeter !== "") {
            greeter = body.greeter;
        }
    } else if (event.queryStringParameters && event.queryStringParameters.greeter && event.queryStringParameters.greeter !== "") {
        greeter = event.queryStringParameters.greeter;
    } else if (event.multiValueHeaders && event.multiValueHeaders.greeter && event.multiValueHeaders.greeter != "") {
        greeter = event.multiValueHeaders.greeter.join(" and ");
    } else if (event.headers && event.headers.greeter && event.headers.greeter != "") {
        greeter = event.headers.greeter;
    } 
    res.body = "Hello, " + greeter + "!";
    return res
};
```

Comparando isso à configuração de integração personalizada do Lambda em [Configurar integrações personalizadas do Lambda no API Gateway](set-up-lambda-custom-integrations.md), a entrada para essa função do Lambda pode ser expressa nos parâmetros da solicitação e no corpo. Você tem mais latitude para permitir que o cliente transmita os mesmos dados de entrada. Aqui, o cliente pode transmitir o nome do greeter como um parâmetro de string de consulta, um cabeçalho ou uma propriedade de corpo. A função também pode oferecer suporte à integração personalizada do Lambda. A configuração da API é mais simples. Você não configura a resposta de método nem a resposta de integração.

**Como configurar uma integração de proxy do Lambda usando a AWS CLI**

1. Use o comando [create-rest-api](https://docs.aws.amazon.com/cli/latest/reference/apigateway/create-rest-api.html) indicado abaixo para criar uma API:

   ```
   aws apigateway create-rest-api --name 'HelloWorld (AWS CLI)'
   ```

   A saída será exibida da seguinte forma:

   ```
   {
       "name": "HelloWorldProxy (AWS CLI)", 
       "id": "te6si5ach7",
       "rootResourceId" : "krznpq9xpg",
       "createdDate": 1508461860
   }
   ```

   A API `id` (`te6si5ach7`) e o `rootResourceId` (`krznpq9xpg`) são usados em todo este exemplo.

1. Use o comando [create-resource](https://docs.aws.amazon.com/cli/latest/reference/apigateway/create-resource.html) indicado abaixo para criar um [recurso](https://docs.aws.amazon.com/apigateway/latest/api/API_Resource.html) `/greeting` do API Gateway:

   ```
   aws apigateway create-resource \
         --rest-api-id te6si5ach7 \
         --parent-id krznpq9xpg \
         --path-part {proxy+}
   ```

   A saída será exibida da seguinte forma:

   ```
   {
       "path": "/{proxy+}", 
       "pathPart": "{proxy+}", 
       "id": "2jf6xt", 
       "parentId": "krznpq9xpg"
   }
   ```

   Na próxima etapa, você usa o valor `id` (`2jf6xt`) do recurso `{proxy+}` para criar um método no recurso `/{proxy+}`.

1. Use o comando [put-method](https://docs.aws.amazon.com/cli/latest/reference/apigateway/put-method.html) indicado abaixo para criar uma solicitação de método `ANY` de `ANY /{proxy+}`:

   ```
   aws apigateway put-method --rest-api-id te6si5ach7 \
          --resource-id 2jf6xt \
          --http-method ANY \
          --authorization-type "NONE"
   ```

   A saída será exibida da seguinte forma:

   ```
   {
       "apiKeyRequired": false, 
       "httpMethod": "ANY", 
       "authorizationType": "NONE"
   }
   ```

   Esse método de API permite que o cliente receba ou envie saudações da função do Lambda no backend. 

1. Use o comando [put-integration](https://docs.aws.amazon.com/cli/latest/reference/apigateway/put-integration.html) indicado abaixo para configurar a integração do método `ANY /{proxy+}` com uma função do Lambda denominada `HelloWorld`. Essa função responde à solicitação com uma mensagem de `"Hello, {name}!"`, se o parâmetro `greeter` for fornecido ou `"Hello, World!"`, se o parâmetro de string de consulta não for definido.

   ```
   aws apigateway put-integration \
         --rest-api-id te6si5ach7 \
         --resource-id 2jf6xt \
         --http-method ANY \
         --type AWS_PROXY \
         --integration-http-method POST \
         --uri arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:HelloWorld/invocations \
         --credentials arn:aws:iam::123456789012:role/apigAwsProxyRole
   ```
**Importante**  
Para integrações do Lambda, você deve usar o método HTTP de `POST` para a solicitação de integração, de acordo com a [especificação da ação do serviço do Lambda para invocações de função](https://docs.aws.amazon.com/lambda/latest/api/API_Invoke.html). A função do IAM de `apigAwsProxyRole` deve ter políticas que permitem ao serviço `apigateway` invocar funções do Lambda. Para obter mais informações sobre as permissões do IAM, consulte [Modelo de permissões do API Gateway para invocar uma API](permissions.md#api-gateway-control-access-iam-permissions-model-for-calling-api).

   A saída será exibida da seguinte forma:

   ```
   {
       "passthroughBehavior": "WHEN_NO_MATCH", 
       "cacheKeyParameters": [], 
       "uri": "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:1234567890:function:HelloWorld/invocations", 
       "httpMethod": "POST", 
       "cacheNamespace": "vvom7n", 
       "credentials": "arn:aws:iam::1234567890:role/apigAwsProxyRole", 
       "type": "AWS_PROXY"
   }
   ```

   Em vez de fornecer um perfil do IAM para `credentials`, você pode usar o comando [add-permission](https://docs.aws.amazon.com/cli/latest/reference/lambda/add-permission.html) para adicionar permissões baseadas em recurso. Isso é o que o console do API Gateway faz. 

1. Use o comando [create-deployment](https://docs.aws.amazon.com/cli/latest/reference/apigateway/create-deployment.html) indicado abaixo para implantar a API em um estágio `test`:

   ```
   aws apigateway create-deployment  \
         --rest-api-id te6si5ach7 \
         --stage-name test
   ```

1. Teste a API usando os seguintes comandos cURL em um terminal.

   Chamando a API com o parâmetro de string de consulta de `?greeter=jane`:

   ```
   curl -X GET 'https://te6si5ach7.execute-api.us-west-2.amazonaws.com/test/greeting?greeter=jane'
   ```

   Chamando a API com um parâmetro de cabeçalho de `greeter:jane`:

   ```
   curl -X GET https://te6si5ach7.execute-api.us-west-2.amazonaws.com/test/hi \
     -H 'content-type: application/json' \
     -H 'greeter: jane'
   ```

   Chamando a API com um corpo de `{"greeter":"jane"}`:

   ```
   curl -X POST https://te6si5ach7.execute-api.us-west-2.amazonaws.com/test/hi \
     -H 'content-type: application/json' \
     -d '{ "greeter": "jane" }'
   ```

   Em todos os casos, a saída é uma resposta 200 com o corpo de resposta a seguir:

   ```
   Hello, jane!
   ```