# Escolher um tutorial de integração do AWS Lambda
<a name="getting-started-with-lambda-integration"></a>

 Para criar uma API com integrações do Lambda, é possível usar a integração de proxy ou sem proxy do Lambda. 

Com a integração de proxy do Lambda, a entrada da função do Lambda pode ser expressa como qualquer combinação de cabeçalhos de solicitação, variáveis de caminho, parâmetros de strings de consulta, corpo e dados de configuração de API. Só é necessário escolher uma função do Lambda. O API Gateway configura a solicitação de integração e a resposta de integração para você. Após a configuração, o método de API poderá evoluir sem modificar as configurações existentes. Isso é possível porque a função do Lambda de backend analisa os dados da solicitação recebida e responde ao cliente.

Na integração sem proxy do Lambda, é necessário garantir que a entrada da função do Lambda seja fornecida como a carga da solicitação de integração. Você deve mapear todos os dados de entrada fornecidos pelo cliente como parâmetros da solicitação no corpo da solicitação de integração apropriada. Também pode ser necessário converter o corpo da solicitação fornecida pelo cliente em um formato reconhecido pela função do Lambda. 

Nas integrações com ou sem proxy do Lambda, é possível usar uma função do Lambda em uma conta diferente da conta em que criou a API.

**Topics**
+ [Tutorial: Crie uma API REST com uma integração de proxy do Lambda](api-gateway-create-api-as-simple-proxy-for-lambda.md)
+ [Tutorial: Crie uma API REST com uma integração de não proxy do Lambda](getting-started-lambda-non-proxy-integration.md)
+ [Tutorial: Crie uma API REST com uma integração de proxy do Lambda entre contas](apigateway-cross-account-lambda-integrations.md)

# 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!
   ```

# Tutorial: Crie uma API REST com uma integração de não proxy do Lambda
<a name="getting-started-lambda-non-proxy-integration"></a>

Nesta demonstração, usamos o console do API Gateway para criar uma API que permite a um cliente chamar funções do Lambda por meio da integração não proxy do Lambda (também conhecida como integração personalizada). Para obter mais informações sobre AWS Lambda e as funções do Lambda, consulte o [Guia do desenvolvedor do AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/). 

Para facilitar o aprendizado, escolhemos uma função do Lambda simples com configuração mínima da API para orientar você pelas etapas de criação de uma API do API Gateway com a integração personalizada do Lambda. Quando necessário, descrevemos parte da lógica. Para ver um exemplo mais detalhado da integração personalizada do Lambda, consulte [Tutorial: Criar uma API REST de calculadora com duas integrações de serviços da AWS e uma integração sem proxy do Lambda](integrating-api-with-aws-services-lambda.md). 

Antes de criar a API, configure o backend do Lambda criando uma função do Lambda no AWS Lambda, conforme descrito a seguir.

**Topics**
+ [Criar uma função do Lambda para integração não proxy do Lambda](#getting-started-new-lambda)
+ [Criar uma API com integração não proxy do Lambda](#getting-started-new-api)
+ [Testar a chamada do método de API](#getting-started-new-get)
+ [Implantar a API](#getting-started-deploy-api)
+ [Testar a API em uma etapa de implantação](#getting-started-test)
+ [Limpar](#getting-started-clean-up)

## Criar uma função do Lambda para integração não proxy do Lambda
<a name="getting-started-new-lambda"></a>

**nota**  
A criação de funções do Lambda pode resultar em cobranças na conta da AWS.

 Nesta etapa, crie uma função do Lambda no estilo “Hello, World\$1” para a integração personalizada do Lambda. Durante esta demonstração, a função é chamada `GetStartedLambdaIntegration`.

 A implementação dessa função do Lambda `GetStartedLambdaIntegration` é a seguinte: 

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

```
'use strict';
var days = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];            
var times = ['morning', 'afternoon', 'evening', 'night', 'day'];

export const handler = async(event) => {
  console.log(event);
  // Parse the input for the name, city, time and day property values
  let name = event.name === null || event.name === undefined || event.name === "" ? 'you' : event.name;
  let city = event.city === undefined ? 'World' : event.city;
  let time = times.indexOf(event.time)<0 ? 'day' : event.time;
  let day = days.indexOf(event.day)<0 ? null : event.day;

  // Generate a greeting
  let greeting = 'Good ' + time + ', ' + name + ' of ' + city + '. ';
  if (day) greeting += 'Happy ' + day + '!';
  
  // Log the greeting to CloudWatch
  console.log('Hello: ', greeting);
  
  // Return a greeting to the caller
  return {"greeting": greeting}
};
```

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

```
import json

days = {
    'Sunday',
    'Monday',
    'Tuesday',
    'Wednesday',
    'Thursday',
    'Friday',
    'Saturday'}
times = {'morning', 'afternoon', 'evening', 'night', 'day'}


def lambda_handler(event, context):
    print(event)
    # parse the input for the name, city, time, and day property values
    name = event.get("name") or 'you'
    city = event.get("city") or 'World'
    try:
        if event['time'] in times:
            time = event['time']
        else:
            time = 'day'
    except KeyError:
        time = 'day'
    try:
        if event['day'] in days:
            day = event['day']
        else:
            day = ''
    except KeyError:
        day = ''
    # Generate a greeting
    greeting = 'Good ' + time + ', ' + name + ' of ' + \
        city + '.' + ['', ' Happy ' + day + '!'][day != '']
    # Log the greeting to CloudWatch
    print(greeting)

    # Return a greeting to the caller
    return {"greeting": greeting}
```

------

Para a integração personalizada do Lambda o API Gateway transmite a entrada para a função do Lambda do cliente como o corpo da solicitação de integração. O objeto `event` do manipulador da função do Lambda é a entrada. 

Nossa função do Lambda é simples. Ela analisa o objeto de entrada `event` para as propriedades `name`, `city`, `time`e `day`. Em seguida, ela retorna uma saudação, como um objeto JSON de `{"message":greeting}`, para o autor da chamada. A mensagem é no padrão `"Good [morning|afternoon|day], [name|you] in [city|World]. Happy day!"`. Presume-se que a entrada para a função do Lambda seja um dos seguintes objetos JSON: 

```
{
  "city": "...",
  "time": "...",
  "day": "...",
  "name" : "..."
}
```

Para obter mais informações, consulte o [Guia do desenvolvedor do AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html). 

Além disso, a função registra sua execução no Amazon CloudWatch chamando `console.log(...)`. Isso é útil para rastrear as chamadas ao depurar a função. Para permitir que a função `GetStartedLambdaIntegration` registre a chamada, defina uma função do IAM com as políticas apropriadas para que a função do Lambda crie os streams do CloudWatch e adicione entradas de log aos streams. O console do Lambda orienta você na criação das funções e políticas do IAM necessárias.

Se você configurar a API sem usar o console do API Gateway, tal como ao [importar uma API de um arquivo do OpenAPI](https://github.com/aws-samples/api-gateway-secure-pet-store/blob/master/src/main/resources/swagger.yaml#L39), é necessário criar explicitamente, se necessário, e configurar uma função e política de invocação para que o API Gateway invoque as funções do Lambda. Para obter mais informações sobre como configurar funções de invocação e execução do Lambda para uma API do API Gateway, consulte [Controlar o acesso a uma API REST com permissões do IAM](permissions.md). 

 Em comparação com `GetStartedLambdaProxyIntegration`, a função do Lambda para a integração de proxy do Lambda, a função `GetStartedLambdaIntegration` do Lambda para a integração personalizada do Lambda recebe apenas a entrada do corpo da solicitação de integração da API do API Gateway. A função pode retornar uma saída de qualquer objeto JSON, uma string, um número, um Booleano ou até mesmo um blob binário. Em contrapartida, a função do Lambda para a integração de proxy do Lambda pode aceitar a entrada de quaisquer dados da solicitação, mas deve retornar uma saída de determinado objeto JSON. A função `GetStartedLambdaIntegration` para a integração personalizada do Lambda pode ter os parâmetros de solicitação de API como entrada, desde que o API Gateway mapeie os parâmetros de solicitação de API necessários para o corpo da solicitação de integração antes de encaminhar a solicitação do cliente ao backend. Para que isso aconteça, o desenvolvedor da API deve criar um modelo de mapeamento e configurá-lo no método de API ao criar a API. 

Agora, crie a função do Lambda `GetStartedLambdaIntegration`. 

**Como criar a função do Lambda `GetStartedLambdaIntegration` para integração personalizada do Lambda**

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

1. Execute um destes procedimentos:
   + Se a página de boas-vindas for exibida, escolha **Get Started Now (Começar a usar agora)** e **Create function (Criar função)**.
   + Se a página da lista **Lambda > Functions (Lambda > Funções)** for exibida, escolha **Create function (Criar função)**.

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

1. Na tela **Author from scratch (Criar do zero)**, faça o seguinte:

   1. Em **Name (Nome)**, insira **GetStartedLambdaIntegration** como o nome da função do Lambda.

   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. Para **Role name (Nome da função)**, insira um nome para sua função (por exemplo, **GetStartedLambdaIntegrationRole**).

   1. Para **Policy templates (Modelos de política)**, escolha **Simple microservice permissions (Permissões de microsserviço simples)**.

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

1. No painel **Configure function (Configurar função)**, em **Function code (Código de função)** faça o seguinte:

   1. Copie o código da função do Lambda listado no início desta seção e cole-o no editor de código em linha.

   1. Deixe as opções padrão para todos os outros campos nesta seção.

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

1. Para testar a função recém-criada, escolha a guia **Teste**.

   1. Em **Nome do evento**, insira **HelloWorldTest**. 

   1. Para **JSON do evento**, substitua o código padrão pelo seguinte.

      ```
      {
        "name": "Jonny",
        "city": "Seattle",
        "time": "morning",
        "day": "Wednesday"
      }
      ```

   1.  Escolha **Test (Testar)** para invocar a função. A seção **Execution result: succeeded (Resultada da execução: bem-sucedida)** é exibida. Expanda **Detalhes** veja a saída a seguir.

      ```
      {
          "greeting": "Good morning, Jonny of Seattle. Happy Wednesday!"
      }
      ```

      A saída também é gravada no CloudWatch Logs. 

 Como exercício extra, você pode usar o console do IAM para visualizar a função do IAM (`GetStartedLambdaIntegrationRole`) criada como parte da criação da função do Lambda. Há duas políticas em linha anexadas à esta função do IAM. Uma estipula as permissões mais básicas para execução do Lambda. Ela permite chamar o `CreateLogGroup` do CloudWatch para quaisquer recursos do CloudWatch de sua conta na região onde a função do Lambda for criada. Essa política também permite a criação de streams e eventos de registro em log do CloudWatch para a função do Lambda `GetStartedLambdaIntegration`. 

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "logs:CreateLogGroup",
            "Resource": "arn:aws:logs:us-east-1:111111111111:*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "logs:CreateLogStream",
                "logs:PutLogEvents"
            ],
            "Resource": [
                "arn:aws:logs:us-east-1:111111111111:log-group:/aws/lambda/GetStartedLambdaIntegration:*"
            ]
        }
    ]
}
```

------

O outro documento de política se aplica à invocação de outro serviço da AWS que não é usado neste exemplo. Você pode ignorá-lo por enquanto. 

 Associada à função do IAM, há uma entidade confiável, que é `lambda.amazonaws.com`. Esta é a relação de confiança: 

------
#### [ JSON ]

****  

```
{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Service": "lambda.amazonaws.com"
      },
      "Action": "sts:AssumeRole"
    }
  ]
}
```

------

 A combinação dessa relação de confiança e da política em linha possibilita que a função do Lambda invoque uma função `console.log()` para registro de eventos no CloudWatch Logs. 

## Criar uma API com integração não proxy do Lambda
<a name="getting-started-new-api"></a>

 Com a função do Lambda (`GetStartedLambdaIntegration`) criada e testada, você está pronto para expor a função por meio de uma API do API Gateway. Para fins de ilustração, a função do Lambda está exposta com um método HTTP genérico. Usamos o corpo de solicitação, uma variável do caminho URL, uma string de consulta e um cabeçalho para receber os dados de entrada necessários do cliente. Ativamos o validador de solicitações do API Gateway para a API a fim de garantir que todos os dados necessários sejam definidos e especificados apropriadamente. Configuramos um modelo para mapeamento para o API Gateway para transformar os dados de solicitação fornecidos pelo cliente no formato válido, conforme exigido pela função de backend do Lambda.

**Como criar uma API com uma integração não proxy do Lambda**

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 **LambdaNonProxyAPI**.

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 **/\$1city\$1**. Este é um exemplo de recurso com uma variável de caminho que recebe uma entrada do cliente. Posteriormente, você vai associar essa variável de caminho à entrada da função do Lambda usando um modelo de mapeamento.

**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 **\$1city\$1**.

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

1. Selecione **Criar recurso**.

Depois de criar um recurso **/\$1city\$1**, você criará um método `ANY`. O verbo HTTP `ANY` é um espaço reservado para um método HTTP válido que um cliente envia na ocasião da execução. Este exemplo mostra que o método `ANY` pode ser usado para integração personalizada do Lambda assim como para integração de proxy do Lambda.

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

1. Selecione o recurso **/\$1city\$1** 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. Mantenha a opção **Integração do proxy do Lambda** desativada.

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. Escolha **Configurações de solicitação de método**.

   Agora, ative um validador de solicitações para uma variável de caminho de URL, um parâmetro de string de consulta e um cabeçalho a fim de garantir que todos os dados necessários sejam definidos. Neste exemplo, você vai criar um parâmetro de string de consulta `time` e um cabeçalho `day`. 

1. Em **Validador de solicitação**, selecione **Validar parâmetros de string de consulta e cabeçalhos**.

1. Selecione **Parâmetros de string de consulta de URL** e faça o seguinte: 

   1. Escolha **Add query string** (Adicionar string de consulta).

   1. Em **Nome**, digite **time**.

   1. Ative a opção **Obrigatório**.

   1. Mantenha **Armazenamento em cache** desativado. 

1. Selecione **Cabeçalhos de solicitação HTTP** e faça o seguinte: 

   1. Escolha **Add header** (Adicionar cabeçalho).

   1. Em **Nome**, digite **day**.

   1. Ative a opção **Obrigatório**.

   1. Mantenha **Armazenamento em cache** desativado. 

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

Depois de ativar um validador de solicitações, você vai configurar a solicitação de integração do método `ANY` adicionando um modelo de mapeamento de corpo para transformar a solicitação recebida em uma carga útil do JSON, conforme exigido pela função do Lambda de back-end. 

**Como configurar a solicitação de integração**

1. Na guia **Solicitação de integração** em **Configurações de solicitação de integração**, selecione **Editar**.

1. Em **Passagem do corpo da solicitação**, selecione **Quando não há modelos definidos (recomendado)**.

1. Selecione **Modelos de mapeamento**.

1. Escolha **Add mapping template** (Adicionar modelo de mapeamento).

1. Em **Tipo de conteúdo**, insira **application/json**.

1. Em **Corpo do modelo**, insira o seguinte código:

   ```
   #set($inputRoot = $input.path('$'))
   {
     "city": "$input.params('city')",
     "time": "$input.params('time')",
     "day":  "$input.params('day')",
     "name": "$inputRoot.callerName"
   }
   ```

1. Escolha **Salvar**.

## Testar a chamada do método de API
<a name="getting-started-new-get"></a>

 O console do API Gateway fornece uma instalação de testes para que você teste a invocação à API antes que ela seja implantada. Você pode usar o recurso de teste do console para testar a API enviando a seguinte solicitação: 

```
POST /Seattle?time=morning
day:Wednesday

{
    "callerName": "John"
}
```

 Nesta solicitação de teste, você definirá `ANY` como `POST`, definirá `{city}` como `Seattle`, atribuirá `Wednesday` como o valor de cabeçalho `day` e atribuirá `"John"` como o valor `callerName`. 

**Como testar o método `ANY`**

1. Selecione a guia **Testar**. Talvez seja necessário selecionar o botão de seta para a direita para mostrar a guia.

1. Em **Tipo de método**, selecione `POST`.

1. Em **Caminho**, em **cidade**, insira **Seattle**.

1. Em **Strings de consulta**, digite **time=morning**.

1. Em **Cabeçalhos**, insira **day:Wednesday**.

1. Em **Corpo da solicitação**, insira **\$1 "callerName": "John" \$1**.

1. Escolha **Test** (Testar).

Verifique se a carga de resposta retornada é como se segue:

```
{
  "greeting": "Good morning, John of Seattle. Happy Wednesday!"
}
```

Também é possível visualizar os logs para examinar como o API Gateway processa a solicitação e a resposta.

```
Execution log for request test-request
Thu Aug 31 01:07:25 UTC 2017 : Starting execution for request: test-invoke-request
Thu Aug 31 01:07:25 UTC 2017 : HTTP Method: POST, Resource Path: /Seattle
Thu Aug 31 01:07:25 UTC 2017 : Method request path: {city=Seattle}
Thu Aug 31 01:07:25 UTC 2017 : Method request query string: {time=morning}
Thu Aug 31 01:07:25 UTC 2017 : Method request headers: {day=Wednesday}
Thu Aug 31 01:07:25 UTC 2017 : Method request body before transformations: { "callerName": "John" }
Thu Aug 31 01:07:25 UTC 2017 : Request validation succeeded for content type application/json
Thu Aug 31 01:07:25 UTC 2017 : Endpoint request URI: https://lambda.us-west-2.amazonaws.com/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:GetStartedLambdaIntegration/invocations
Thu Aug 31 01:07:25 UTC 2017 : Endpoint request headers: {x-amzn-lambda-integration-tag=test-request, Authorization=****************************************************************************************************************************************************************************************************************************************************************************************************************************************338c72, X-Amz-Date=20170831T010725Z, x-amzn-apigateway-api-id=beags1mnid, X-Amz-Source-Arn=arn:aws:execute-api:us-west-2:123456789012:beags1mnid/null/POST/{city}, Accept=application/json, User-Agent=AmazonAPIGateway_beags1mnid, X-Amz-Security-Token=FQoDYXdzELL//////////wEaDMHGzEdEOT/VvGhabiK3AzgKrJw+3zLqJZG4PhOq12K6W21+QotY2rrZyOzqhLoiuRg3CAYNQ2eqgL5D54+63ey9bIdtwHGoyBdq8ecWxJK/YUnT2Rau0L9HCG5p7FC05h3IvwlFfvcidQNXeYvsKJTLXI05/yEnY3ttIAnpNYLOezD9Es8rBfyruHfJfOqextKlsC8DymCcqlGkig8qLKcZ0hWJWVwiPJiFgL7laabXs++ZhCa4hdZo4iqlG729DE4gaV1mJVdoAagIUwLMo+y4NxFDu0r7I0/EO5nYcCrppGVVBYiGk7H4T6sXuhTkbNNqVmXtV3ch5bOlh7 [TRUNCATED]
Thu Aug 31 01:07:25 UTC 2017 : Endpoint request body after transformations: {
  "city": "Seattle",
  "time": "morning",
  "day": "Wednesday",
  "name" : "John"
}
Thu Aug 31 01:07:25 UTC 2017 : Sending request to https://lambda.us-west-2.amazonaws.com/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:GetStartedLambdaIntegration/invocations
Thu Aug 31 01:07:25 UTC 2017 : Received response. Integration latency: 328 ms
Thu Aug 31 01:07:25 UTC 2017 : Endpoint response body before transformations: {"greeting":"Good morning, John of Seattle. Happy Wednesday!"}
Thu Aug 31 01:07:25 UTC 2017 : Endpoint response headers: {x-amzn-Remapped-Content-Length=0, x-amzn-RequestId=c0475a28-8de8-11e7-8d3f-4183da788f0f, Connection=keep-alive, Content-Length=62, Date=Thu, 31 Aug 2017 01:07:25 GMT, X-Amzn-Trace-Id=root=1-59a7614d-373151b01b0713127e646635;sampled=0, Content-Type=application/json}
Thu Aug 31 01:07:25 UTC 2017 : Method response body after transformations: {"greeting":"Good morning, John of Seattle. Happy Wednesday!"}
Thu Aug 31 01:07:25 UTC 2017 : Method response headers: {X-Amzn-Trace-Id=sampled=0;root=1-59a7614d-373151b01b0713127e646635, Content-Type=application/json}
Thu Aug 31 01:07:25 UTC 2017 : Successfully completed execution
Thu Aug 31 01:07:25 UTC 2017 : Method completed with status: 200
```

Os logs mostram a solicitação recebida antes do mapeamento e a solicitação de integração após o mapeamento. Quando um teste falha, os logs são úteis para avaliar se a entrada original está correta ou se o modelo de mapeamento funciona corretamente. 

## Implantar a API
<a name="getting-started-deploy-api"></a>

 A invocação de teste é uma simulação e tem limitações. Por exemplo, ela ignora qualquer mecanismo de autorização promulgado na API. Para testar a execução da API em tempo real, você deve implantar a API primeiro. Para implantar uma API, você cria um estágio para criar um snapshot da API naquele momento. O nome do estágio também define o caminho base após o nome de host padrão da API. O recurso raiz da API é anexado após o nome do estágio. Quando você modifica a API, deve reimplantá-la em um estágio novo ou existente antes que as alterações entrem em vigor. 

**Para implantar a API em um estágio**

1. Escolha **Implantar API**.

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

1. Em **Stage name (Nome do estágio)**, insira **test**.
**nota**  
A entrada deve ser texto codificado UTF-8 (ou seja, não localizado).

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

1. Escolha **Implantar**.

Em **Detalhes do estágio**, escolha o ícone de cópia para copiar o URL de invocação da API. O padrão geral do URL básico da API é `https://api-id.region.amazonaws.com/stageName`. Por exemplo, o URL básico da API (`beags1mnid`) criada na região `us-west-2` e implantada no estágio `test` é `https://beags1mnid.execute-api.us-west-2.amazonaws.com/test`.

## Testar a API em uma etapa de implantação
<a name="getting-started-test"></a>

Há várias maneiras para testar uma API implantada. Para solicitações GET usando apenas variáveis de caminho do URL ou parâmetros de strings de consulta, é possível digitar o URL de recurso da API em um navegador. 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/).

**Para testar a API usando cURL**

1. Abra uma janela de terminal em seu computador local conectado à Internet.

1. Para testar `POST /Seattle?time=evening`:

   Copie o seguinte comando cURL e cole-o na janela do terminal.

   ```
   curl -v -X POST \
     'https://beags1mnid.execute-api.us-west-2.amazonaws.com/test/Seattle?time=evening' \
     -H 'content-type: application/json' \
     -H 'day: Thursday' \
     -H 'x-amz-docs-region: us-west-2' \
     -d '{
   	"callerName": "John"
   }'
   ```

   Você receberá uma resposta bem-sucedida com a seguinte carga:

   ```
   {"greeting":"Good evening, John of Seattle. Happy Thursday!"}
   ```

   Se você alterar `POST` para `PUT` nesta solicitação de método, obterá a mesma resposta.

## Limpar
<a name="getting-started-clean-up"></a>

Se você não precisar mais das funções do Lambda criadas para esta demonstração, poderá excluí-las agora. Você também pode excluir os recursos do IAM que o acompanham.

**Atenção**  
Se você pretende completar as outras demonstrações desta série, não exclua a função de execução Lambda ou a função de invocação do Lambda. Se você excluir uma função do Lambda da qual as suas APIs dependem, essas APIs deixarão de funcionar. A exclusão de uma função do Lambda não pode ser desfeita. Se quiser usar a função do Lambda novamente, você deverá recriar essa função.  
Se você excluir um recurso do IAM do qual depende uma função do Lambda, esta última deixará de funcionar, juntamente com as APIs que dependem dessa função. A exclusão de um recurso do IAM não pode ser desfeita. Se quiser usar o recurso do IAM novamente, você deverá recriá-lo. 

**Como excluir a função do Lambda**

1. Faça login no Console de gerenciamento da AWS e abra o console AWS Lambda em [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).

1. Na lista de funções, escolha **GetStartedLambdaIntegration**, **Ações** e **Excluir função**. Quando solicitado, escolha **Delete** (Excluir) novamente.

**Como excluir os recursos do IAM associados**

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

1. Em **Details (Detalhes)**, escolha **Roles (Funções)**.

1. Na lista de funções, escolha **GetStartedLambdaIntegrationRole**, **Ações da função** e **Excluir função**. Siga as etapas no console para excluir o perfil.

# Tutorial: Crie uma API REST com uma integração de proxy do Lambda entre contas
<a name="apigateway-cross-account-lambda-integrations"></a>

Agora você pode usar a função do AWS Lambda de uma conta da AWS diferente como seu backend de integração da API. Cada conta pode estar em qualquer região onde o Amazon API Gateway está disponível. Isso facilita o gerenciamento centralizado e o compartilhamento das funções do Lambda de backend em várias APIs.

Nesta seção, mostramos como configurar a integração de proxy do Lambda entre contas usando o console do Amazon API Gateway.

## Criar uma API para integração do Lambda entre contas do API Gateway
<a name="apigateway-cross-account-lambda-integrations-create-api"></a>

**Como criar uma API**

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 **CrossAccountLambdaAPI**.

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**.

## Criar a função de integração do Lambda em outra conta
<a name="apigateway-cross-account-lambda-integrations-create-lambda-function"></a>

Agora você criará uma função do Lambda em uma conta diferente daquela em que criou a API demonstrativa.

**Criar uma função do Lambda em outra conta**

1. Faça login no console do Lambda usando uma conta diferente daquela em que você criou sua API do API Gateway.

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

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

1. Em **Author from scratch (Criar do zero)**, faça o seguinte:

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

   1. Na lista suspensa **Runtime (Tempo de execução)**, escolha um tempo de execução Node.js compatível.

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

   1. Em **Permissions (Permissões)**, expanda **Choose or create an execution role (Escolher ou criar uma função de execução)**. É possível criar uma função ou escolher uma função existente.

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

1. Role para baixo, até o painel **Function code (Código da função)**.

1. Insira a implementação da função Node.js de [Tutorial: Crie uma API REST com uma integração de proxy do Lambda](api-gateway-create-api-as-simple-proxy-for-lambda.md).

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

1. Anote o ARN completo da sua função (no canto superior direito do painel de funções do Lambda). Você precisará dele ao criar a integração do Lambda entre contas.

## Configurar a integração do Lambda entre contas
<a name="apigateway-cross-account-lambda-integrations-create-integration2"></a>

Depois de ter uma função de integração do Lambda em uma conta diferente, você poderá usar o console do API Gateway para adicioná-la à sua API na sua primeira conta.

**nota**  
Se você estiver configurando um autorizador entre regiões e entre contas, o `sourceArn` que é adicionado à função de destino deve usar a região da função, e não a região da 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**.

Depois de criar um recurso, você criará um método `GET`. Você vai integrar o método `GET` a uma função do Lambda em outra conta. 

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

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

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

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**, insira o ARN completo da função do Lambda na Etapa 1. 

   No console do Lambda, você pode encontrar o ARN da sua função no canto superior direito da janela.

1. Ao inserir o ARN, uma string de comando `aws lambda add-permission` é exibida. Esta política concederá acesso da sua primeira conta à função do Lambda da segunda conta. Copie e cole a string de comando `aws lambda add-permission` em uma janela da AWS CLI configurada para a segunda conta.

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

É possível ver a política atualizada da função no console do Lambda.

**(Opcional) Como ver a política atualizada**

1. Faça login no Console de gerenciamento da AWS e abra o console do AWS Lambda em [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).

1. Selecione a função do Lambda.

1. Escolha **Permissions (Permissões)**.

   É necessário ver uma política `Allow` com uma cláusula `Condition` na qual o `AWS:SourceArn` é o ARN para o método `GET` da sua API.