# Tutorial: Crie uma API REST com uma integração de proxy do Lambda
<a name="api-gateway-create-api-as-simple-proxy-for-lambda"></a>

A [integração de proxy do Lambda](set-up-lambda-proxy-integrations.md) é um tipo de integração leve e flexível da API do API Gateway que permite integrar um método de API ou uma API inteira a uma função do Lambda. A função do Lambda pode ser escrita em [qualquer linguagem compatível com o Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html). Por se tratar de uma integração de proxy, você pode alterar a implementação da função do Lambda a qualquer momento, sem necessidade de implantar sua API novamente.

Neste tutorial, você faz o seguinte:
+ Criar um "Hello, World\$1" Função do Lambda para ser o backend da API.
+ Criar e testar um "Hello, World\$1" API com integração de proxy do Lambda.

**Topics**
+ [Criar um "Hello, World\$1" Função do Lambda](#api-gateway-proxy-integration-create-lambda-backend)
+ [Criar um "Hello, World\$1" API](#api-gateway-create-api-as-simple-proxy-for-lambda-build)
+ [Implantar e testar a API](#api-gateway-create-api-as-simple-proxy-for-lambda-test)

## Criar um "Hello, World\$1" Função do Lambda
<a name="api-gateway-proxy-integration-create-lambda-backend"></a>

**Como criar um “Hello, World\$1” Função do Lambda no console do Lambda**

1. Abra o console do Lambda em [https://console.aws.amazon.com/lambda](https://console.aws.amazon.com/lambda)

1. Na barra de navegação da AWS, escolha uma [Região da AWS](https://docs.aws.amazon.com/general/latest/gr/apigateway.html).
**nota**  
Anote a região na qual você criará a função do Lambda. Você precisará dela ao criar a API.

1. Selecione **Functions (Funções)** no painel de navegação.

1. Escolha **Create function** (Criar função).

1. Escolha **Author from scratch** (Criar do zero).

1. Em **Basic information (Informações básicas)**, faça o seguinte:

   1. Em **Function name (Nome da função)**, insira **GetStartedLambdaProxyIntegration**.

   1. Em **Tempo de execução**, escolha o último runtime **Node.js** ou **Python** compatível.

   1. Em **Arquitetura**, mantenha a configuração padrão.

   1. Em **Permissions** (Permissões), expanda **Change default execution role** (Alterar função de execução padrão). Na lista suspensa **Perfil de execução**, escolha **Criar perfil com base em modelos de política da AWS**.

   1. Em **Role name (Nome da função)**, insira **GetStartedLambdaBasicExecutionRole**.

   1. Deixe em branco o campo **Policy templates** (Modelos de política).

   1. Escolha **Create function** (Criar função).

1. Em **Function code (Código de função)**, no editor de código em linha, copie/cole o seguinte código:

------
#### [ Node.js ]

   ```
   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
   };
   ```

------
#### [ Python ]

   ```
   import json
   
   
   def lambda_handler(event, context):
       print(event)
   
       greeter = 'World'
   
       try:
           if (event['queryStringParameters']) and (event['queryStringParameters']['greeter']) and (
                   event['queryStringParameters']['greeter'] is not None):
               greeter = event['queryStringParameters']['greeter']
       except KeyError:
           print('No greeter')
   
       try:
           if (event['multiValueHeaders']) and (event['multiValueHeaders']['greeter']) and (
                   event['multiValueHeaders']['greeter'] is not None):
               greeter = " and ".join(event['multiValueHeaders']['greeter'])
       except KeyError:
           print('No greeter')
   
       try:
           if (event['headers']) and (event['headers']['greeter']) and (
                   event['headers']['greeter'] is not None):
               greeter = event['headers']['greeter']
       except KeyError:
           print('No greeter')
   
       if (event['body']) and (event['body'] is not None):
           body = json.loads(event['body'])
           try:
               if (body['greeter']) and (body['greeter'] is not None):
                   greeter = body['greeter']
           except KeyError:
               print('No greeter')
   
       res = {
           "statusCode": 200,
           "headers": {
               "Content-Type": "*/*"
           },
           "body": "Hello, " + greeter + "!"
       }
   
       return res
   ```

------

1. Escolha **Deploy** (Implantar).

## Criar um "Hello, World\$1" API
<a name="api-gateway-create-api-as-simple-proxy-for-lambda-build"></a>

Agora crie uma API para “Hello, World\$1” Função do Lambda usando o console do API Gateway.

**Como criar um “Hello, World\$1” solicitações de**

1. Inicie uma sessão no console do API Gateway em [https://console.aws.amazon.com/apigateway](https://console.aws.amazon.com/apigateway).

1. Se esta for a primeira vez que você usa o API Gateway, você verá uma página com os recursos do serviço. Em **REST API**, escolha **Build** (Criar). Quando o pop-up **Create Example API** (Criar API de exemplo) for exibido, escolha **OK**.

   Se essa não for a primeira vez que você usa o API Gateway, escolha **Create API** (Criar API). Em **REST API**, escolha **Build** (Criar).

1.  Em **API name (Nome da API)**, insira **LambdaProxyAPI**.

1. (Opcional) Em **Description (Descrição)**, insira uma descrição.

1. Mantenha **Tipo de endpoint de API** definido como **Regional**.

1. Em **Tipo de endereço IP**, selecione **IPv4**.

1. Selecione **Criar API**.

Depois de criar uma API, você criará um recurso. Normalmente, os recursos da API são organizados em uma árvore de recursos, de acordo com a lógica do aplicativo. Neste exemplo, você criará um recurso **/helloworld**. 

**Para criar um recurso**

1. Selecione **Criar recurso**.

1. Mantenha **Recurso proxy** desativado. 

1. Mantenha **Caminho do recurso** como `/`.

1. Em **Resource Name (Nome do recurso)**, insira **helloworld**.

1. Mantenha **CORS (Compartilhamento de recursos de origem cruzada)** desativado.

1. Selecione **Criar recurso**.

 Em uma integração de proxy, a solicitação inteira é enviada à função do Lambda de backend como está, por meio de um método `ANY` genérico que representa qualquer método HTTP. O método HTTP real é especificado pelo cliente no tempo de execução. O método `ANY` permite usar uma única configuração do método da API para todos os métodos HTTP compatíveis: `DELETE`, `GET`, `HEAD`, `OPTIONS`, `PATCH`, `POST` e `PUT`.

**Como criar um método `ANY`**

1. Selecione o recurso **/helloworld** e, depois, **Criar método**.

1. Em **Tipo de método**, selecione **ANY**.

1. Em **Tipo de integração**, selecione **Função do Lambda**.

1. Ative **Integração de proxy do Lambda**.

1. Em **Função do Lambda**, selecione a Região da AWS onde você criou a função do Lambda e, depois, insira o nome da função.

1. Para usar o valor de tempo limite padrão de 29 segundos, deixe a opção **Tempo limite padrão** ativada. Para definir um tempo limite personalizado, selecione **Tempo limite padrão** e insira um valor de tempo limite entre `50` e `29000` milissegundos.

1. Escolha **Criar método**.

## Implantar e testar a API
<a name="api-gateway-create-api-as-simple-proxy-for-lambda-test"></a>

**Para implantar sua API**

1. Escolha **Implantar API**.

1. Em **Estágio**, selecione **Novo estágio**.

1. Em **Stage name (Nome do estágio)**, insira **test**.

1. (Opcional) Em **Description (Descrição)**, insira uma descrição.

1. Escolha **Implantar**.

1. Em **Detalhes do estágio**, escolha o ícone de cópia para copiar o URL de invocação da API.

### Usar o navegador e cURL para testar uma API com integração de proxy do Lambda
<a name="api-gateway-create-api-as-simple-proxy-for-lambda-test-curl"></a>

Você pode usar um navegador ou [cURL](https://curl.se/) para testar sua API.

Para testar solicitações `GET` usando apenas parâmetros de string de consulta, você pode inserir o URL do recurso `helloworld` da API em uma barra de endereço do navegador. 

Para criar o URL do recurso `helloworld` da API, acrescente o recurso `helloworld` e o parâmetro da string de consulta `?greeter=John` ao URL de invocação. Seu URL deve ter uma aparência semelhante ao seguinte.

```
https://r275xc9bmd.execute-api.us-east-1.amazonaws.com/test/helloworld?greeter=John
```

Para outros métodos, é necessário usar utilitários de teste de API REST mais avançados, como o [POSTMAN](https://www.postman.com/) ou o [cURL](https://curl.se/). Este tutorial usa cURL. Os exemplos de comando cURL a seguir pressupõem que cURL foi instalado em seu computador.

**Para testar a API implantada usando cURL:**

1. Abra uma janela do terminal.

1. Copie o comando cURL a seguir e cole-o na janela do terminal, substituindo o URL de invocação pelo que foi copiado na etapa anterior e adicione **/helloworld** ao final do URL.
**nota**  
Se você estiver executando o comando no Windows, use a seguinte sintaxe:  

   ```
   curl -v -X POST "https://r275xc9bmd.execute-api.us-east-1.amazonaws.com/test/helloworld" -H "content-type: application/json" -d "{ \"greeter\": \"John\" }"
   ```

   1. Para chamar a API com o parâmetro de string de consulta de `?greeter=John`:

      ```
      curl -X GET 'https://r275xc9bmd.execute-api.us-east-1.amazonaws.com/test/helloworld?greeter=John'
      ```

   1. Para chamar a API com um parâmetro de cabeçalho de `greeter:John`:

      ```
      curl -X GET https://r275xc9bmd.execute-api.us-east-1.amazonaws.com/test/helloworld \
        -H 'content-type: application/json' \
        -H 'greeter: John'
      ```

   1. Como chamar a API com um corpo de `{"greeter":"John"}`:

      ```
      curl -X POST https://r275xc9bmd.execute-api.us-east-1.amazonaws.com/test/helloworld \
        -H 'content-type: application/json' \
        -d '{ "greeter": "John" }'
      ```

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

   ```
   Hello, John!
   ```