# Invocar uma função do Lambda usando um endpoint do Amazon API Gateway É possível criar uma API da Web com um endpoint HTTP para a função do Lambda usando o Amazon API Gateway. O API Gateway fornece ferramentas para criar e documentar APIs da Web que direcionam as solicitações HTTP para as funções do Lambda. É possível proteger o acesso à sua API com controles de autenticação e autorização. Suas APIs podem veicular o tráfego pela Internet ou podem ser acessadas somente dentro da VPC. **dica** O Lambda fornece duas maneiras de invocar uma função por meio de um endpoint HTTP: API Gateway e URLs de funções do Lambda. Se não tiver certeza de qual é o melhor método para seu caso de uso, consulte [Seleção de um método para invocar a função do Lambda usando uma solicitação HTTP](apig-http-invoke-decision.md). Os recursos em sua API definem um ou mais métodos, como GET ou POST. Os métodos têm uma integração que direciona solicitações para uma função do Lambda ou outro tipo de integração. É possível definir cada recurso e método individualmente ou usar tipos especiais de recurso e método para corresponder todas as solicitações que se enquadram em um padrão. Um [recurso proxy](https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html) captura todos os caminhos abaixo de um recurso. O método `ANY` captura todos os métodos HTTP. **Topics** + [Escolher um tipo de API](#services-apigateway-apitypes) + [Adicionar um endpoint público à sua função do Lambda](#apigateway-add) + [Integração de proxy](#apigateway-proxy) + [Formato de eventos](#apigateway-example-event) + [Formato de resposta](#apigateway-types-transforms) + [Permissões](#apigateway-permissions) + [Aplicação de exemplo](#services-apigateway-samples) + [O manipulador de eventos do Powertools para AWS Lambda](#services-apigateway-powertools) + [Tutorial: Uso do Lambda com API Gateway](services-apigateway-tutorial.md) + [Tratamento de erros do Lambda com uma API do API Gateway](services-apigateway-errors.md) + [Seleção de um método para invocar a função do Lambda usando uma solicitação HTTP](apig-http-invoke-decision.md) ## Escolher um tipo de API O API Gateway é compatível com três tipos de API que invocam as funções do Lambda: + [API HTTP](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api.html): uma API RESTful leve e de baixa latência. + [API REST](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-rest-api.html): uma API RESTful personalizável e com muitos recursos. + [API de WebSocket](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-websocket-api.html): uma API da Web que mantém conexões persistentes com clientes para uma comunicação duplex completa. As APIs HTTP e REST são ambas APIs RESTful que processam solicitações de HTTP e retornam respostas. As APIs HTTP são mais recentes e são criadas com a versão 2 da API do API Gateway. Os recursos abaixo são novos para APIs HTTP: **Recursos da API HTTP** + **Implantações automáticas**: quando você modifica rotas ou integrações, as alterações são implantadas automaticamente em estágios com implantação automática habilitada. + **Estágio padrão**: você pode criar um estágio padrão (`$default`) para veicular solicitações no caminho raiz do URL da API. Para estágios nomeados, você deve incluir o nome do estágio no início do caminho. + **Configuração de CORS**: você pode configurar sua API para adicionar cabeçalhos CORS às respostas de saída em vez de adicioná-las manualmente no código da função. As APIs REST são APIs RESTful clássicas às quais o API Gateway oferece suporte desde o lançamento. As APIs REST têm atualmente mais recursos de personalização, integração e gerenciamento. **Recursos da API REST** + **Tipos de integração**: APIs REST são compatíveis com integrações personalizadas do Lambda. Com uma integração personalizada, você pode enviar apenas o corpo da solicitação para a função ou aplicar um modelo de transformação ao corpo da solicitação antes de enviá-la para a função. + **Controle de acesso**: as APIs REST oferecem suporte a mais opções de autenticação e autorização. + **Monitoramento e rastreamento**: as APIs REST oferecem suporte ao monitoramento do AWS X-Ray e a outras opções de log. Para obter uma comparação detalhada, consulte [Escolher entre APIs HTTP e REST](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-vs-rest.html) no *Guia do desenvolvedor do API Gateway*. As APIs WebSocket também usam a API do API Gateway versão 2 e oferecem suporte a um conjunto de recursos semelhante. Use uma API WebSocket para aplicativos que se beneficiam de uma conexão persistente entre o cliente e a API. As APIs WebSocket oferecem uma comunicação duplex completa, o que significa que tanto o cliente quanto a API podem enviar mensagens continuamente sem esperar por uma resposta. As APIs HTTP oferecem suporte a um formato de evento simplificado (versão 2.0). Para obter um exemplo de um evento de API HTTP, consulte [Criação integrações de proxy AWS Lambda para APIs HTTP no API Gateway](https://docs.aws.amazon.com//apigateway/latest/developerguide/http-api-develop-integrations-lambda.html). Para obter mais informações, consulte [Criar integrações de proxy do AWS Lambda para APIs HTTP no API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html). ## Adicionar um endpoint público à sua função do Lambda **Como adicionar um endpoint público à sua função do Lambda** 1. Abra a [página Funções](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda. 1. Escolha uma função. 1. Em **Visão geral da função**, escolha **Adicionar gatilho**. 1. Selecione **API Gateway**. 1. Escolher **Create an API** (Criar uma API) ou **Use an existing API** (Usar uma API existente). 1. **New API** (Nova API): para **API type** (Tipo de API), escolha **HTTP API**. Para obter mais informações, consulte [Escolher um tipo de API](#services-apigateway-apitypes). 1. **Existing API**: selecione a API na lista suspensa ou insira seu ID (por exemplo, r3pmxmplak). 1. Em **Security (Segurança)**, escolha **Open (Abrir)**. 1. Escolha **Adicionar**. ## Integração de proxy As APIs do API Gateway são compostas por estágios, recursos, métodos e integrações. O estágio e o recurso determinam o caminho do endpoint: **Formato do caminho da API** + `/prod/`: o estágio e o recurso raiz de `prod`. + `/prod/user`: o estágio de `prod` e o recurso de `user`. + `/dev/{proxy+}`: qualquer rota no estágio de `dev`. + `/`: (APIs HTTP) o estágio padrão e o recurso raiz. Uma integração do Lambda mapeia uma combinação de caminho e método de HTTP para uma função do Lambda. É possível configurar o API Gateway para transmitir o corpo da solicitação de HTTP no estado em que se encontra (integração personalizada) ou para encapsular o corpo da solicitação em um documento que inclui todas as informações de solicitação, inclusive cabeçalhos, recursos, caminho e método. Para obter mais informações, consulte [Integrações de proxy do Lambda no API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html). ## Formato de eventos O Amazon API Gateway invoca sua função [de modo síncrono](invocation-sync.md) com um evento que contém uma representação JSON da solicitação de HTTP. Para uma integração personalizada, o evento é o corpo da solicitação. Para uma integração de proxy, o evento tem uma estrutura definida. Para ver um exemplo de um evento de proxy de uma API REST do API Gateway, consulte [Formato de entrada de uma função do Lambda para integração de proxy](https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html#api-gateway-simple-proxy-for-lambda-input-format) no *Guia do desenvolvedor do API Gateway*. ## Formato de resposta O API Gateway aguarda uma resposta de sua função e retransmite o resultado para o chamador. Para uma integração personalizada, defina uma resposta de integração e uma resposta de método para converter a saída da função em uma resposta de HTTP. Para uma integração de proxy, a função deve responder com uma representação da resposta em um formato específico. O exemplo abaixo mostra um objeto de resposta de uma função Node.js. O objeto de resposta representa uma resposta de HTTP bem-sucedida que contém um documento JSON. **Example index.mjs: objeto de resposta de integração de proxy (Node.js)** ``` var response = { "statusCode": 200, "headers": { "Content-Type": "application/json" }, "isBase64Encoded": false, "multiValueHeaders": { "X-Custom-Header": ["My value", "My other value"], }, "body": "{\n \"TotalCodeSize\": 104330022,\n \"FunctionCount\": 26\n}" } ``` O runtime do Lambda serializa o objeto de resposta em JSON e o envia para a API. A API analisa a resposta e a utiliza para criar uma resposta de HTTP que, então, é enviada para o cliente que fez a solicitação original. **Example Resposta HTTP** ``` < HTTP/1.1 200 OK < Content-Type: application/json < Content-Length: 55 < Connection: keep-alive < x-amzn-RequestId: 32998fea-xmpl-4268-8c72-16138d629356 < X-Custom-Header: My value < X-Custom-Header: My other value < X-Amzn-Trace-Id: Root=1-5e6aa925-ccecxmplbae116148e52f036 < { "TotalCodeSize": 104330022, "FunctionCount": 26 } ``` ## Permissões O Amazon API Gateway recebe permissão para invocar sua função por meio da [política baseada em recursos](access-control-resource-based.md) da função. É possível conceder permissão de invocar a uma API inteira ou conceder acesso limitado a um estágio, recurso ou método. Ao adicionar uma API à sua função usando o console do Lambda, o console do API Gateway ou em um modelo de AWS SAM, a política baseada em recursos da função é atualizada automaticamente. Veja abaixo um exemplo de política de função. **Example política de função** **** ``` { "Version":"2012-10-17", "Id": "default", "Statement": [ { "Sid": "nodejs-apig-functiongetEndpointPermissionProd-BWDBXMPLXE2F", "Effect": "Allow", "Principal": { "Service": "apigateway.amazonaws.com" }, "Action": "lambda:InvokeFunction", "Resource": "arn:aws:lambda:us-east-2:111122223333:function:nodejs-apig-function-1G3MXMPLXVXYI", "Condition": { "StringEquals": { "aws:SourceAccount": "111122223333" }, "ArnLike": { "aws:SourceArn": "arn:aws:execute-api:us-east-2:111122223333:ktyvxmpls1/*/GET/" } } } ] } ``` É possível gerenciar manualmente as permissões da política de função com as seguintes operações da API: + [AddPermission](https://docs.aws.amazon.com/lambda/latest/api/API_AddPermission.html) + [RemovePermission](https://docs.aws.amazon.com/lambda/latest/api/API_RemovePermission.html) + [GetPolicy](https://docs.aws.amazon.com/lambda/latest/api/API_GetPolicy.html) Para conceder permissão de invocação a uma API existente, use o comando `add-permission`. Exemplo: ``` aws lambda add-permission \ --function-name my-function \ --statement-id apigateway-get --action lambda:InvokeFunction \ --principal apigateway.amazonaws.com \ --source-arn "arn:aws:execute-api:us-east-2:123456789012:mnh1xmpli7/default/GET/" ``` A seguinte saída deverá ser mostrada: ``` { "Statement": "{\"Sid\":\"apigateway-test-2\",\"Effect\":\"Allow\",\"Principal\":{\"Service\":\"apigateway.amazonaws.com\"},\"Action\":\"lambda:InvokeFunction\",\"Resource\":\"arn:aws:lambda:us-east-2:123456789012:function:my-function\",\"Condition\":{\"ArnLike\":{\"AWS:SourceArn\":\"arn:aws:execute-api:us-east-2:123456789012:mnh1xmpli7/default/GET\"}}}" } ``` **nota** Se a sua função e a API estiverem em Regiões da AWS diferentes, o identificador de região no ARN de origem deverá corresponder à região da função, e não à região da API. Quando o API Gateway invoca uma função, ele usa um ARN de recurso baseado no ARN da API, mas modificado para corresponder à região da função. O ARN de origem no exemplo concede permissão a uma integração no método GET do recurso raiz no estágio padrão de uma API com o ID `mnh1xmpli7`. É possível usar um asterisco no ARN de origem para conceder permissões a vários estágios, métodos ou recursos. **Padrões de recursos** + `mnh1xmpli7/*/GET/*`: método GET em todos os recursos, em todos os estágios. + `mnh1xmpli7/prod/ANY/user`: método ANY no recurso `user` no estágio `prod`. + `mnh1xmpli7/*/*/*`: qualquer método em todos os recursos, em todos os estágios. Para obter detalhes sobre como exibir a política e remover instruções, consulte [Visualizar políticas do IAM baseadas em recurso no Lambda](access-control-resource-based.md). ## Aplicação de exemplo O aplicativo de exemplo de [API Gateway com Node.js](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/nodejs-apig) inclui uma função com um modelo do AWS SAM que cria uma API REST com o rastreamento do AWS X-Ray habilitado. Ele também inclui scripts para implantar, invocar a função, testar a API e fazer a limpeza. ## O manipulador de eventos do Powertools para AWS Lambda O manipulador de eventos do kit de ferramentas Powertools para AWS Lambda fornece roteamento, middleware, configuração CORS, geração de especificações da OpenAPI, validação de solicitações, tratamento de erros e outros recursos úteis ao escrever funções do Lambda invocadas por um endpoint do API Gateway (HTTP ou REST). O utilitário de manipulador de eventos está disponível para Python e TypeScript/JavaScript. Para obter mais informações, consulte a [API REST do manipulador de eventos](https://docs.powertools.aws.dev/lambda/python/latest/core/event_handler/api_gateway/) na documentação do *Powertools para AWS Lambda (Python)* e a [API HTTP do manipulador de eventos na documentação do *Powertools para AWS Lambda (TypeScript)*. ](https://docs.aws.amazon.com/powertools/typescript/latest/features/event-handler/http/) ### Python ``` from aws_lambda_powertools import Logger from aws_lambda_powertools.event_handler import APIGatewayRestResolver from aws_lambda_powertools.logging import correlation_paths from aws_lambda_powertools.utilities.typing.lambda_context import LambdaContext app = APIGatewayRestResolver() logger = Logger() @app.get("/healthz") def ping(): return {"message": "health status ok"} @logger.inject_lambda_context(correlation_id_path=correlation_paths.API_GATEWAY_REST) def lambda_handler(event: dict, context: LambdaContext) -> dict: return app.resolve(event, context) ``` ### Typescript ``` import { Router } from '@aws-lambda-powertools/event-handler/experimental-rest'; import { Logger } from '@aws-lambda-powertools/logger'; import { correlationPaths, search, } from '@aws-lambda-powertools/logger/correlationId'; import type { Context } from 'aws-lambda/handler'; const logger = new Logger({ correlationIdSearchFn: search, }); const app = new Router({ logger }); app.get("/healthz", async () => { return { message: "health status ok" }; }); export const handler = async (event: unknown, context: Context) => { // You can continue using other utilities just as before logger.addContext(context); logger.setCorrelationId(event, correlationPaths.API_GATEWAY_REST); return app.resolve(event, context); }; ``` # Tutorial: Uso do Lambda com API Gateway Neste tutorial, você criará uma API REST que será usada para invocar uma função do Lambda usando uma solicitação HTTP. A função do Lambda executará operações de criação, leitura, atualização e exclusão (CRUD) em uma tabela do DynamoDB. Essa função será fornecida aqui para fins de demonstração, mas você aprenderá a configurar uma API REST do API Gateway que pode invocar qualquer função do Lambda. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/APIG_tut_resources.png) O uso do API Gateway fornece aos usuários um endpoint HTTP seguro para invocar a função do Lambda e pode ajudar a gerenciar grandes volumes de chamadas para a função, ao realizar o controle de utilização do tráfego e validar e autorizar as chamadas de API automaticamente. O API Gateway também oferece controles de segurança flexíveis usando o AWS Identity and Access Management (IAM) e o Amazon Cognito. Isso é útil para casos de uso em que é necessária uma autorização prévia para as chamadas em sua aplicação. **dica** O Lambda fornece duas maneiras de invocar uma função por meio de um endpoint HTTP: API Gateway e URLs de funções do Lambda. Se não tiver certeza de qual é o melhor método para seu caso de uso, consulte [Seleção de um método para invocar a função do Lambda usando uma solicitação HTTP](apig-http-invoke-decision.md). Para concluir este tutorial, você passará pelos estágios a seguir: 1. Criação e configuração de uma função do Lambda em Python ou em Node.js para a execução de operações em uma tabela do DynamoDB. 1. Criação de uma API REST no API Gateway para conexão com a função do Lambda. 1. Criação de uma tabela do DynamoDB e realização de teste com a função do Lambda no console. 1. Implantação da API e realização de teste da configuração completa usando curl em um terminal. Ao concluir esses estágios, você aprenderá a usar o API Gateway para criar um endpoint HTTP que pode invocar uma função do Lambda com segurança em qualquer escala. Você também aprenderá como implantar a API e testá-la no console, além de como enviar uma solicitação HTTP usando um terminal. ## Criação de uma política de permissões Antes de ser possível criar uma [função de execução](lambda-intro-execution-role.md) para a função do Lambda, primeiro é necessário criar uma política de permissões para fornecer à sua função permissão para acessar os recursos da AWS necessários. Para este tutorial, a política permitirá que o Lambda execute operações de CRUD em uma tabela do DynamoDB e grave no Amazon CloudWatch Logs. **Para criar a política** 1. Abra a [página Policies](https://console.aws.amazon.com/iam/home#/policies) (Políticas) do console do IAM. 1. Escolha **Create Policy**. 1. Escolha a guia **JSON** e cole a política personalizada a seguir no editor JSON. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "Stmt1428341300017", "Action": [ "dynamodb:DeleteItem", "dynamodb:GetItem", "dynamodb:PutItem", "dynamodb:Query", "dynamodb:Scan", "dynamodb:UpdateItem" ], "Effect": "Allow", "Resource": "*" }, { "Sid": "", "Resource": "*", "Action": [ "logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents" ], "Effect": "Allow" } ] } ``` ------ 1. Escolha **Próximo: tags**. 1. Selecione **Próximo: revisar**. 1. No campo **Política de revisão**, em **Nome** da política, insira **lambda-apigateway-policy**. 1. Escolha **Criar política**. ## Criar uma função de execução Um [perfil de execução](lambda-intro-execution-role.md) é um perfil do AWS Identity and Access Management (IAM) que concede a uma função do Lambda permissão para acessar recursos e Serviços da AWS. Para permitir que a função execute operações em uma tabela do DynamoDB, vincule a política de permissões criada na etapa anterior. **Para criar um perfil de execução e vincular a política de permissões personalizada** 1. Abra a página [Funções](https://console.aws.amazon.com/iam/home#/roles) no console do IAM. 1. Selecione **Criar perfil**. 1. Para o tipo de entidade confiável, escolha **Serviço da AWS** e, em seguida, para o caso de uso, selecione **Lambda**. 1. Escolha **Próximo**. 1. Na caixa de pesquisa de política, insira **lambda-apigateway-policy**. 1. Nos resultados da pesquisa, selecione a política que você criou (`lambda-apigateway-policy`) e, depois, escolha **Next** (Avançar). 1. Em **Role details** (Detalhes do perfil), para **Role name** (Nome do perfil), insira **lambda-apigateway-role** e, em seguida, escolha **Create role** (Criar perfil). ## Criar a função do Lambda 1. Abra a [página Funções](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda e escolha **Criar função**. 1. Escolha **Criar do zero**. 1. Em **Function name** (Nome da função), insira `LambdaFunctionOverHttps`. 1. Em **Runtime**, escolha o runtime Node.js ou Python mais recente. 1. Em **Permissions** (Permissões), expanda **Change default execution role** (Alterar função de execução padrão). 1. Escolha **Usar um perfil existente** e selecione o perfil **lambda-apigateway-role** que você criou anteriormente. 1. Escolha a opção **Criar função**. 1. No painel **Código-fonte**, substitua o código padrão pelo código Node.js ou Python a seguir. ------ #### [ Node.js ] A configuração `region` deve corresponder à Região da AWS na qual que você implanta a função e [cria a tabela do DynamoDB](#services-apigateway-tutorial-table). **Example index.mjs** ``` import { DynamoDBDocumentClient, PutCommand, GetCommand, UpdateCommand, DeleteCommand} from "@aws-sdk/lib-dynamodb"; import { DynamoDBClient } from "@aws-sdk/client-dynamodb"; const ddbClient = new DynamoDBClient({ region: "us-east-2" }); const ddbDocClient = DynamoDBDocumentClient.from(ddbClient); // Define the name of the DDB table to perform the CRUD operations on const tablename = "lambda-apigateway"; /** * Provide an event that contains the following keys: * * - operation: one of 'create,' 'read,' 'update,' 'delete,' or 'echo' * - payload: a JSON object containing the parameters for the table item * to perform the operation on */ export const handler = async (event, context) => { const operation = event.operation; if (operation == 'echo'){ return(event.payload); } else { event.payload.TableName = tablename; let response; switch (operation) { case 'create': response = await ddbDocClient.send(new PutCommand(event.payload)); break; case 'read': response = await ddbDocClient.send(new GetCommand(event.payload)); break; case 'update': response = ddbDocClient.send(new UpdateCommand(event.payload)); break; case 'delete': response = ddbDocClient.send(new DeleteCommand(event.payload)); break; default: response = 'Unknown operation: ${operation}'; } console.log(response); return response; } }; ``` ------ #### [ Python ] **Example lambda\$1function.py** ``` import boto3 # Define the DynamoDB table that Lambda will connect to table_name = "lambda-apigateway" # Create the DynamoDB resource dynamo = boto3.resource('dynamodb').Table(table_name) # Define some functions to perform the CRUD operations def create(payload): return dynamo.put_item(Item=payload['Item']) def read(payload): return dynamo.get_item(Key=payload['Key']) def update(payload): return dynamo.update_item(**{k: payload[k] for k in ['Key', 'UpdateExpression', 'ExpressionAttributeNames', 'ExpressionAttributeValues'] if k in payload}) def delete(payload): return dynamo.delete_item(Key=payload['Key']) def echo(payload): return payload operations = { 'create': create, 'read': read, 'update': update, 'delete': delete, 'echo': echo, } def lambda_handler(event, context): '''Provide an event that contains the following keys: - operation: one of the operations in the operations dict below - payload: a JSON object containing parameters to pass to the operation being performed ''' operation = event['operation'] payload = event['payload'] if operation in operations: return operations[operation](payload) else: raise ValueError(f'Unrecognized operation "{operation}"') ``` ------ **nota** Neste exemplo, o nome da tabela do DynamoDB está definido como uma variável em seu código da função. Em uma aplicação real, a prática recomendada é transferir esse parâmetro como uma variável de ambiente e evitar codificar o nome da tabela. Para obter mais informações, consulte [Usar variáveis de ambiente do AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-envvars.html). 1. Na seção **DEPLOY**, escolha **Implantar** para atualizar o código da função: ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png) ## Testar a função Antes de integrar a função com o API Gateway, confirme se a implantação da função ocorreu com êxito. Use o console do Lambda para enviar um evento de teste para a função. 1. Na página do console do Lambda da função, escolha a guia **Testar**. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/test-tab.png) 1. Role para baixo até a seção **JSON do evento** e substitua o evento padrão pelo que se segue. Esse evento corresponde à estrutura esperada pela função do Lambda. ``` { "operation": "echo", "payload": { "somekey1": "somevalue1", "somekey2": "somevalue2" } } ``` 1. Escolha **Testar**. 1. Em **Execução da função: êxito**, expanda **Detalhes**. Você deverá ver a resposta a seguir: ``` { "somekey1": "somevalue1", "somekey2": "somevalue2" } ``` ## Criar uma API REST usando o API Gateway Nesta etapa, você cria a API REST do API Gateway que usará para invocar a função do Lambda. **Para criar a API** 1. Abra o [console do API Gateway](https://console.aws.amazon.com/apigateway). 1. Selecione **Create API** (Criar API). 1. Na caixa do **API REST**, escolha **Construir**. 1. Em **Detalhes da API**, deixe a opção **Nova API** selecionada e, em **Nome da API**, insira**DynamoDBOperations**. 1. Selecione **Criar API**. ## Criação de um recurso na API REST Para adicionar um método HTTP à API, primeiro é necessário criar um recurso no qual esse método possa operar. Aqui você cria o recurso para gerenciar a tabela do DynamoDB. **Para criar o recurso** 1. No [Console do Gateway da API](https://console.aws.amazon.com/apigateway), na página **Recursos** da API, escolha **Criar recurso**. 1. Em **Detalhes do recurso**, em **Nome do recurso**, insira **DynamoDBManager**. 1. Escolha **Create Resource** (Criar recurso). ## Criação de um método HTTP POST Nesta etapa, você cria um método (`POST`) para o recurso `DynamoDBManager`. Você vincula esse método `POST` à função do Lambda para que, quando o método receber uma solicitação HTTP, o API Gateway invoque sua função do Lambda. **nota** Para a finalidade deste tutorial, um método HTTP (`POST`) será usado para invocar uma única função do Lambda que executa todas as operações em sua tabela do DynamoDB. Em uma aplicação real, a prática recomendada é usar diferentes funções do Lambda e métodos HTTP para cada operação. Para obter mais informações, consulte [The Lambda monolith](https://serverlessland.com/content/service/lambda/guides/aws-lambda-operator-guide/monolith) no Serverless Land. **Para criar o método POST** 1. Na página **Recursos** da API, certifique-se de que o recurso `/DynamoDBManager` esteja realçado. Em seguida, no painel **Métodos**, escolha **Criar método**. 1. Em **Tipo de método**, escolha **POST**. 1. Em **Tipo de integração**, mantenha a opção **Função do Lambda** selecionada. 1. Em **Função do Lambda**, escolha o nome do recurso da Amazon (ARN) para sua função (`LambdaFunctionOverHttps`). 1. Escolha **Criar método**. ## Criar uma tabela do DynamoDB Crie uma tabela do DynamoDB em branco na qual a função do Lambda executará as operações de CRUD. **Para criar uma tabela do DynamoDB** 1. Abra a [página Tables (Tabelas) no console do DynamoDB](https://console.aws.amazon.com/dynamodbv2#tables). 1. Escolha **Criar tabela**. 1. Em **Detalhes da tabela**, faça o seguinte: 1. Em **Table name** (Nome da tabela), insira **lambda-apigateway**. 1. Para a **Chave de partição**, insira **id** e mantenha o tipo de dados definido como **String**. 1. Em **Table settings** (Configurações da tabela), mantenha **Default settings** (Configurações padrões). 1. Escolha **Criar tabela**. ## Teste da integração do API Gateway, do Lambda e do DynamoDB Agora está tudo pronto para que ocorra o teste da integração do método de API do API Gateway com a função do Lambda e a tabela do DynamoDB. Ao usar o console do API Gateway, você envia solicitações diretamente para o método `POST` usando a função de teste do console. Nesta etapa, primeiro você usa uma operação `create` para adicionar um novo item à tabela do DynamoDB e, em seguida, usa uma operação `update` para modificar o item. **Teste 1: para criar um novo item na tabela do DynamoDB** 1. No [API Gateway console](https://console.aws.amazon.com/apigateway) (Console do API Gateway), escolha a sua API (`DynamoDBOperations`). 1. No recurso `DynamoDBManager`, escolha o método **POST**. 1. Selecione a guia **Testar**. Talvez seja necessário selecionar o botão de seta para a direita para mostrar a guia. 1. Em **Método de teste**, mantenha as opções **Strings de consulta** e **Cabeçalhos** vazias. Em **Corpo da solicitação**, cole o seguinte JSON: ``` { "operation": "create", "payload": { "Item": { "id": "1234ABCD", "number": 5 } } } ``` 1. Escolha **Testar**. Os resultados que são exibidos quando o teste é concluído devem mostrar status `200`. Esse código de status indica que a operação `create` ocorreu com êxito. Para confirmar, verifique se a tabela do DynamoDB passou a conter o novo item. 1. Abra a [página Tables](https://console.aws.amazon.com/dynamodbv2#tables) (Tabelas) do console do DynamoDB e escolha a tabela `lambda-apigateway`. 1. Escolha **Explore table items** (Explorar itens da tabela). No painel **Itens retornados**, você verá um item com o **id** `1234ABCD` e o **número** `5`. Exemplo: ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/items-returned.png) **Teste 2: para atualizar o item na tabela do DynamoDB** 1. No [Console do API Gateway](https://console.aws.amazon.com/apigateway), retorne para a guia **Teste** do seu método POST. 1. Em **Método de teste**, mantenha as opções **Strings de consulta** e **Cabeçalhos** vazias. Em **Corpo da solicitação**, cole o seguinte JSON: ``` { "operation": "update", "payload": { "Key": { "id": "1234ABCD" }, "UpdateExpression": "SET #num = :newNum", "ExpressionAttributeNames": { "#num": "number" }, "ExpressionAttributeValues": { ":newNum": 10 } } } ``` 1. Escolha **Testar**. Os resultados que são exibidos quando o teste é concluído devem mostrar status `200`. Esse código de status indica que a operação `update` ocorreu com êxito. Para confirmar, verifique se o item na tabela do DynamoDB foi modificado. 1. Abra a [página Tables](https://console.aws.amazon.com/dynamodbv2#tables) (Tabelas) do console do DynamoDB e escolha a tabela `lambda-apigateway`. 1. Escolha **Explore table items** (Explorar itens da tabela). No painel **Itens retornados**, você verá um item com o **id** `1234ABCD` e o **número** `10`. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/items-returned-2.png) ## Implantar a API Para que um cliente chame a API, você deve criar uma implantação e um estágio associado. Um estágio representa um snapshot da API, incluindo seus métodos e integrações. **Para implantar a API** 1. Abra a página **APIs** do [API Gateway console](https://console.aws.amazon.com/apigateway) (Console do API Gateway) e escolha a API `DynamoDBOperations`. 1. Na página **Recursos** da sua API, escolha **Implantar API**. 1. Em **Estágio**, escolha **\$1Novo estágio\$1** e, em seguida, em **Nome do estágio**, insira **test**. 1. Escolha **Implantar**. 1. No painel **Detalhes do estágio** copie o **URL de invocação**. Você usará isso na próxima etapa para invocar a função usando uma solicitação HTTP. ## Uso de curl para invocar a função usando solicitações HTTP Agora é possível invocar a função do Lambda ao emitir uma solicitação HTTP para a API. Nesta etapa, você criará um novo item na tabela do DynamoDB e realizará as operações de leitura, atualização e exclusão nesses itens. **Para criar um item na tabela do DynamoDB usando curl** 1. Abra um terminal ou prompt de comando em sua máquina local e execute o seguinte comando `curl` usando o URL de invocação que você copiou na etapa anterior. Este comando usa as seguintes opções: + `-H`: adiciona um cabeçalho à solicitação. Aqui, especifica o tipo de conteúdo como JSON. + `-d`: envia dados no corpo da solicitação. Essa opção usa um método HTTP POST por padrão. ------ #### [ Linux/macOS ] ``` curl https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager \ -H "Content-Type: application/json" \ -d '{"operation": "create", "payload": {"Item": {"id": "5678EFGH", "number": 15}}}' ``` ------ #### [ PowerShell ] ``` curl.exe 'https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager' -H 'Content-Type: application/json' -d '{\"operation\": \"create\", \"payload\": {\"Item\": {\"id\": \"5678EFGH\", \"number\": 15}}}' ``` ------ Se a operação foi bem-sucedida, você deverá ver uma resposta retornada com um código 200 de status de HTTP. 1. Também é possível usar o console do DynamoDB para confirmar que o item novo está na sua tabela fazendo o seguinte: 1. Abra a [página Tables](https://console.aws.amazon.com/dynamodbv2#tables) (Tabelas) do console do DynamoDB e escolha a tabela `lambda-apigateway`. 1. Escolha **Explore table items** (Explorar itens da tabela). No painel **Itens retornados**, você verá um item com o **id** `5678EFGH` e o **número** `15`. **Para ler o item na tabela do DynamoDB usando curl** + No seu terminal ou prompt de comando, execute o seguinte comando `curl` para ler o valor do item que você acabou de criar. Use seu próprio URL de invocação. ------ #### [ Linux/macOS ] ``` curl https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager \ -H "Content-Type: application/json" \ -d '{"operation": "read", "payload": {"Key": {"id": "5678EFGH"}}}' ``` ------ #### [ PowerShell ] ``` curl.exe 'https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager' -H 'Content-Type: application/json' -d '{\"operation\": \"read\", \"payload\": {\"Key\": {\"id\": \"5678EFGH\"}}}' ``` ------ Você deve ver uma saída como uma das seguintes, dependendo de ter escolhido o código da função em Node.js ou em Python: ------ #### [ Node.js ] ``` {"$metadata":{"httpStatusCode":200,"requestId":"7BP3G5Q0C0O1E50FBQI9NS099JVV4KQNSO5AEMVJF66Q9ASUAAJG", "attempts":1,"totalRetryDelay":0},"Item":{"id":"5678EFGH","number":15}} ``` ------ #### [ Python ] ``` {"Item":{"id":"5678EFGH","number":15},"ResponseMetadata":{"RequestId":"QNDJICE52E86B82VETR6RKBE5BVV4KQNSO5AEMVJF66Q9ASUAAJG", "HTTPStatusCode":200,"HTTPHeaders":{"server":"Server","date":"Wed, 31 Jul 2024 00:37:01 GMT","content-type":"application/x-amz-json-1.0", "content-length":"52","connection":"keep-alive","x-amzn-requestid":"QNDJICE52E86B82VETR6RKBE5BVV4KQNSO5AEMVJF66Q9ASUAAJG","x-amz-crc32":"2589610852"}, "RetryAttempts":0}} ``` ------ **Para atualizar o item na tabela do DynamoDB usando curl** 1. No seu terminal ou prompt de comando, execute o seguinte comando `curl` para atualizar o item que você acabou de criar ao alterar o valor `number`. Use seu próprio URL de invocação. ------ #### [ Linux/macOS ] ``` curl https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager \ -H "Content-Type: application/json" \ -d '{"operation": "update", "payload": {"Key": {"id": "5678EFGH"}, "UpdateExpression": "SET #num = :new_value", "ExpressionAttributeNames": {"#num": "number"}, "ExpressionAttributeValues": {":new_value": 42}}}' ``` ------ #### [ PowerShell ] ``` curl.exe 'https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager' -H 'Content-Type: application/json' -d '{\"operation\": \"update\", \"payload\": {\"Key\": {\"id\": \"5678EFGH\"}, \"UpdateExpression\": \"SET #num = :new_value\", \"ExpressionAttributeNames\": {\"#num\": \"number\"}, \"ExpressionAttributeValues\": {\":new_value\": 42}}}' ``` ------ 1. Para confirmar que o valor de `number` para p item foi atualizado, execute outro comando de leitura: ------ #### [ Linux/macOS ] ``` curl https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager \ -H "Content-Type: application/json" \ -d '{"operation": "read", "payload": {"Key": {"id": "5678EFGH"}}}' ``` ------ #### [ PowerShell ] ``` curl.exe 'https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager' -H 'Content-Type: application/json' -d '{\"operation\": \"read\", \"payload\": {\"Key\": {\"id\": \"5678EFGH\"}}}' ``` ------ **Para excluir o item na tabela do DynamoDB usando curl** 1. No seu terminal ou prompt de comando, execute o seguinte comando `curl` para excluir o item que você acabou de criar. Use seu próprio URL de invocação. ------ #### [ Linux/macOS ] ``` curl https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager \ -H "Content-Type: application/json" \ -d '{"operation": "delete", "payload": {"Key": {"id": "5678EFGH"}}}' ``` ------ #### [ PowerShell ] ``` curl.exe 'https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager' -H 'Content-Type: application/json' -d '{\"operation\": \"delete\", \"payload\": {\"Key\": {\"id\": \"5678EFGH\"}}}' ``` ------ 1. Confirme se a operação de exclusão ocorreu com êxito. No painel **Itens retornados** da página **Explorar itens** do console do DynamoDB, verifique se o item com o **id** `5678EFGH` não está mais na tabela. ## Limpeza dos recursos (opcional) Agora você pode excluir os recursos criados para este tutorial, a menos que queira mantê-los. Excluindo os recursos da AWS que você não está mais usando, você evita cobranças desnecessárias em sua Conta da AWS. **Como excluir a função do Lambda** 1. Abra a página [Functions](https://console.aws.amazon.com/lambda/home#/functions) (Funções) no console do Lambda. 1. Selecione a função que você criou. 1. Selecione **Ações**, **Excluir**. 1. Digite **confirm** no campo de entrada de texto e escolha **Delete** (Excluir). **Para excluir a função de execução** 1. Abra a página [Roles](https://console.aws.amazon.com/iam/home#/roles) (Funções) no console do IAM. 1. Selecione a função de execução que você criou. 1. Escolha **Excluir**. 1. Insira o nome do perfil no campo de entrada de texto e escolha **Delete** (Excluir). **Para excluir a API** 1. Abra a [página APIs](https://console.aws.amazon.com/apigateway/main/apis) do console do API Gateway. 1. Selecione a API que você criou. 1. Selecione **Ações**, **Excluir**. 1. Escolha **Excluir**. **Para excluir uma tabela do DynamoDB** 1. Abra a [página Tables](https://console.aws.amazon.com//dynamodb/home#tables:) (Tabelas) no console do DynamoDB. 1. Selecione a tabela que você criou. 1. Escolha **Excluir**. 1. Digite **delete** na caixa de texto. 1. Selecione **Delete table** (Excluir tabela). # Tratamento de erros do Lambda com uma API do API Gateway O API Gateway trata todos os erros de invocação e função como erros internos. Se a API do Lambda rejeitar a solicitação de invocação, o API Gateway retornará um código de erro 500. Se a função é executada, mas retorna um erro ou retorna uma resposta no formato errado, o API Gateway retorna um código de erro 502. Em ambos os casos, o corpo da resposta do API Gateway é `{"message": "Internal server error"}`. **nota** O API Gateway não tenta novamente nenhuma invocação do Lambda. Se o Lambda retornar um erro, o API Gateway retornará uma resposta de erro ao cliente. O exemplo a seguir mostra um mapa de rastreamento do X-Ray para uma solicitação que resultou em um erro de função e um erro 502 do API Gateway. O cliente recebe a mensagem de erro genérica. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/tracemap-apig-502.png) Para personalizar a resposta de erro, é necessário detectar erros no código e formatar uma resposta no formato necessário. **Example [index.mjs](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/nodejs-apig/function/index.mjs): erro de formatação** ``` var formatError = function(error){ var response = { "statusCode": error.statusCode, "headers": { "Content-Type": "text/plain", "x-amzn-ErrorType": error.code }, "isBase64Encoded": false, "body": error.code + ": " + error.message } return response } ``` O API Gateway converte essa resposta em um erro HTTP com um código de status e um corpo personalizado. No mapa de rastreamento, o nó da função é verde porque ele tratou o erro. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/tracemap-apig-404.png) # Seleção de um método para invocar a função do Lambda usando uma solicitação HTTP Muitos casos de uso comuns do Lambda envolvem invocar a função usando uma solicitação HTTP. Por exemplo, você pode querer que uma aplicação Web invoque sua função por meio de uma solicitação do navegador. As funções do Lambda também podem ser usadas para criar APIs REST completas, lidar com interações do usuário em aplicativos móveis, processar dados de serviços externos por meio de chamadas HTTP ou criar webhooks personalizados. As seções a seguir explicam quais são as opções para invocar o Lambda por meio de HTTP e fornecem informações para que você tome a decisão certa para seu caso de uso específico. ## Quais são suas opções ao selecionar um método de invocação HTTP? O Lambda oferece dois métodos principais para invocar uma função usando uma solicitação HTTP: [URLs de função](urls-configuration.md) e o [API Gateway](services-apigateway.md). As principais diferenças entre ambos são as duas opções seguintes: + Os **URLs de função do Lambda** fornecem um endpoint HTTP simples e direto para uma função do Lambda. Eles são otimizados para proporcionar simplicidade e economia e fornecem o caminho mais rápido para expor uma função do Lambda via HTTP. + O **API Gateway** é um serviço mais avançado para criar APIs completas. O API Gateway é otimizado para criar e gerenciar APIs de produção em grande escala e fornece ferramentas abrangentes para segurança, monitoramento e gerenciamento de tráfego. ## Recomendações se você já conhece seus requisitos Se você já sabe quais são seus requisitos, estas são as nossas recomendações básicas: Recomendamos usar os **[URLs de funções](urls-configuration.md)** para aplicações simples ou prototipagem em que você só precisa de métodos básicos de autenticação e tratamento de solicitações/respostas e onde deseja ter o mínimo de custo e a complexidade. O **[API Gateway](services-apigateway.md)** é a melhor opção para aplicações de produção em grande escala ou para casos em que você precisa de recursos mais avançados, como suporte à [descrição de OpenAPI](https://www.openapis.org/), opções de autenticação, nomes de domínio personalizados ou tratamento avançado de solicitações/respostas, incluindo controle de utilização, armazenamento em cache e transformação de solicitação/resposta. ## O que considerar ao selecionar um método para invocar a função do Lambda Ao selecionar entre URLs de função e o API Gateway, você precisa considerar os seguintes fatores: + Suas necessidades de autenticação, como se você precisa do OAuth ou do Amazon Cognito para autenticar usuários + Seus requisitos de escalabilidade e a complexidade da API que deseja implementar + Se você precisa de recursos avançados, como validação de solicitação e formatação de solicitação/resposta + Seus requisitos de monitoramento + Suas metas de custo Ao compreender esses fatores, você pode selecionar a opção que melhor equilibra seus requisitos de segurança, complexidade e custo. As informações a seguir resumem as principais diferenças entre as duas opções. ### Autenticação + Os **URLs de função** fornecem opções básicas de autenticação por meio do AWS Identity and Access Management (IAM). É possível configurar seus endpoints para serem públicos (sem autenticação) ou para exigirem a autenticação do IAM. Com a autenticação do IAM, você pode usar credenciais padrão da AWS ou perfis do IAM para controlar o acesso. Embora seja simples de configurar, essa abordagem oferece opções limitadas em comparação a outros métodos de autenticação. + O **API Gateway** fornece acesso a uma variedade maior de opções de autenticação. Além da autenticação do IAM, você pode usar [autorizadores do Lambda](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html) (lógica de autenticação personalizada), grupos de usuários do [Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/what-is-amazon-cognito.html) e fluxos do OAuth2.0. Essa flexibilidade permite que você implemente esquemas complexos de autenticação, incluindo provedores de autenticação terceirizados, autenticação baseada em tokens e autenticação multifator. ### Tratamento de solicitação/resposta + Os **URLs de função** fornecem tratamento básico para solicitações e respostas HTTP. Eles são compatíveis com métodos HTTP padrão e incluem suporte integrado para compartilhamento de recursos de origem cruzada (CORS). Embora consigam lidar com cargas úteis JSON e parâmetros de consulta naturalmente, eles não oferecem recursos de transformação ou validação de solicitações. O tratamento de respostas é igualmente simples: o cliente recebe a resposta da sua função do Lambda exatamente como o Lambda a retorna. + O **API Gateway** fornece recursos sofisticados de tratamento de solicitações e respostas. É possível definir validadores de solicitações, transformar solicitações e respostas usando modelos de mapeamento, configurar cabeçalhos de solicitação/resposta e implementar o armazenamento em cache de respostas. O API Gateway também oferece suporte a cargas úteis binárias e nomes de domínio personalizados e pode modificar as respostas antes que elas cheguem ao cliente. É possível configurar modelos para validação e transformação de solicitação/resposta usando o esquema JSON. ### Escalabilidade + Os **URLs de funções** escalam diretamente com os limites de simultaneidade da sua função do Lambda e lidam com picos de tráfego escalando sua função até o limite máximo de simultaneidade configurado. Quando esse limite é atingido, o Lambda responde a solicitações adicionais com respostas HTTP 429. Não há um mecanismo de enfileiramento integrado, portanto, lidar com a escalabilidade depende inteiramente da configuração da sua função do Lambda. Por padrão, as funções do Lambda têm um limite de mil execuções simultâneas por Região da AWS. + O **API Gateway** fornece recursos adicionais de escalabilidade além da própria escalabilidade do Lambda. Ele inclui recursos integrados de enfileiramento e controle de utilização, permitindo que você gerencie os picos de tráfego com mais tranquilidade. Por padrão, o API Gateway pode lidar com até 10 mil solicitações por segundo por região, com uma capacidade de expansão de 5 mil solicitações por segundo. Ele também fornece ferramentas para solicitações de controle de utilização em diferentes níveis (API, estágio ou método) para proteger seu backend. ### Monitoramento + Os **URLs de funções** oferecem monitoramento básico por meio de métricas do Amazon CloudWatch, incluindo contagem de solicitações, latência e taxas de erro. Você tem acesso às métricas e logs padrão do Lambda, que mostram as solicitações brutas que chegam à sua função. Embora isso forneça visibilidade operacional essencial, as métricas se concentram principalmente na execução da função. + O **API Gateway** fornece recursos abrangentes de monitoramento, incluindo métricas detalhadas, geração de logs e opções de rastreamento. É possível monitorar chamadas de API, latência, taxas de erro e taxas de acerto/erro de cache por meio do CloudWatch. O API Gateway também se integra ao AWS X-Ray para rastreamento distribuído e fornece formatos de logs personalizáveis. ### Custo + Os **URLs de funções** seguem o modelo de preços padrão do Lambda: você paga somente pelas invocações de funções e pelo tempo de computação. Não há cobranças adicionais pelo endpoint do URL em si. Isso o torna uma opção econômica para APIs simples ou aplicações com pouco tráfego, caso você não precise dos recursos adicionais do API Gateway. + O **API Gateway** oferece um [nível gratuito](https://aws.amazon.com/api-gateway/pricing/#Free_Tier) que inclui um milhão de chamadas de API recebidas para APIs REST e um milhão de chamadas de API recebidas para APIs HTTP. Depois disso, o API Gateway cobra por chamadas de API, transferência de dados e armazenamento em cache (se habilitado). Consulte a [página de preços](https://aws.amazon.com/api-gateway/pricing/) do API Gateway para entender os custos do seu próprio caso de uso. ### Outros recursos + Os **URLs de funções** são projetados para oferecer simplicidade e integração direta com o Lambda. Eles são compatíveis com endpoints HTTP e HTTPS, oferecem suporte CORS integrado e fornecem endpoints de pilha dupla (IPv4 e IPv6). Embora não tenham recursos avançados, eles se destacam em cenários em que você precisa de uma forma rápida e direta de expor as funções do Lambda via HTTP. + O **API Gateway** inclui vários recursos adicionais, como versionamento de API, gerenciamento de estágios, chaves de API para planos de uso, documentação de API por meio do Swagger/OpenAPI, APIs de WebSocket, APIs privadas em uma VPC e integração com WAF para segurança extra. Ele também oferece suporte a implantações canário, integrações simuladas para testes e integração com outros Serviços da AWS além do Lambda. ## Seleção de um método para invocar a função do Lambda Agora que você conhece os critérios para escolher entre URLs de funções do Lambda e o API Gateway, bem como as principais diferenças entre eles, você poderá selecionar a opção que melhor atende às suas necessidades e usar os recursos a seguir para ajudar a começar a usá-la. ------ #### [ Function URLs ] **Conceitos básicos para usar URLs de funções com os recursos abaixo** + Siga o tutorial [Criar uma função do Lambda com um URL de função](urls-webhook-tutorial.md) + Saiba mais sobre URLs de funções no capítulo [Criar e gerenciar URLs de função do Lambda](urls-configuration.md) deste guia + Experimente o tutorial guiado no console **Criar um aplicativo Web simples** fazendo o seguinte: 1. Abra a [página de funções](https://console.aws.amazon.com/lambda/home#/functions) do console do Lambda. 1. Abra o painel de ajuda escolhendo o ícone no canto superior direito da tela. ![\[\]](http://docs.aws.amazon.com/pt_br/lambda/latest/dg/images/console_help_screenshot.png) 1. Selecione **Tutoriais**. 1. Em **Criar um aplicativo Web simples**, escolha **Iniciar tutorial**. ------ #### [ API Gateway ] **Conceitos básicos para usar o Lambda e o API Gateway com os recursos abaixo** + Siga o tutorial [Uso do Lambda com API Gateway](services-apigateway-tutorial.md) para criar uma API REST integrada a uma função do Lambda de backend. + Saiba mais sobre os diferentes tipos de API oferecidos pelo API Gateway nas seguintes seções do *Guia do desenvolvedor do Amazon API Gateway*: + [APIs REST do API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-rest-api.html) + [APIs HTTP do API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api.html) + [APIs de WebSocket do API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-websocket-api.html) + Experimente um ou mais dos exemplos na seção [Tutoriais e workshops](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-tutorials.html) do *Guia do desenvolvedor do Amazon API Gateway*. ------