Tutorial: Crie uma API HTTP CRUD com o Lambda e o DynamoDB - Amazon API Gateway
Etapa 1: Crie uma tabela do DynamoDBEtapa 2: Criar uma função do LambdaEtapa 3: Crie uma API HTTPEtapa 4: Crie rotasEtapa 5: Crie uma integraçãoEtapa 6: Anexe a sua integração às rotasEtapa 7: Teste a sua APIEtapa 8: LimparPróximas etapas: Automatizar com AWS SAM ou AWS CloudFormation

Tutorial: Crie uma API HTTP CRUD com o Lambda e o DynamoDB

Neste tutorial, você cria uma API sem servidor que cria, lê, atualiza e exclui itens de uma tabela do DynamoDB. O DynamoDB é um serviço de banco de dados NoSQL totalmente gerenciado que proporciona uma performance rápida e previsível com escalabilidade contínua. Este tutorial leva aproximadamente 30 minutos para ser concluído, e você pode fazê-lo no nível gratuito da AWS.

Primeiro, você cria uma tabela do DynamoDB usando o console do DynamoDB. Em seguida, você cria uma função do Lambda usando o console do AWS Lambda. Em seguida, crie uma API HTTP usando o console do API Gateway. Por fim, você testa a sua API.

Quando você invoca sua API HTTP, o API Gateway encaminha a solicitação para sua função do Lambda. A função do Lambda interage com o DynamoDB e retorna uma resposta ao API Gateway. O API Gateway retorna uma resposta para você.

Visão geral da API HTTP que você cria neste tutorial.

Para concluir esse exercício, você precisa de uma conta da AWS e de um usuário do AWS Identity and Access Management com acesso ao console. Para obter mais informações, consulte Configurar para usar o API Gateway.

Neste tutorial, você usará o AWS Management Console. Para obter um modelo AWS SAM que cria essa API e todos os recursos relacionados, consulte template.yaml.

Etapa 1: Crie uma tabela do DynamoDB

Você usa uma tabela do DynamoDB para armazenar dados para a sua API.

Cada item tem um ID exclusivo, que usamos como partition key (chave de partição) para a tabela.

Como criar uma tabela do DynamoDB

  1. Abra o console do DynamoDB em https://console.aws.amazon.com/dynamodb/.

  2. Escolha Create table.

  3. Em Table name (Nome da tabela), insira http-crud-tutorial-items.

  4. Em Partition key, (Chave de partição), insira id.

  5. Escolha Create table.

Etapa 2: Criar uma função do Lambda

Você cria uma função do Lambda para o backend da sua API. Essa função do Lambda cria, lê, atualiza e exclui itens do DynamoDB. A função usa events from API Gateway (eventos do API Gateway) para definir como interagir com o DynamoDB. Para fins de simplicidade, este tutorial usa uma única função do Lambda. Como prática recomendada, você deve criar funções separadas para cada rota.

Como criar uma função do Lambda

  1. Abra o console do Lambda em https://console.aws.amazon.com/lambda

  2. Escolha Create function (Criar função).

  3. Em Function name (Nome da função), insira http-crud-tutorial-function.

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

  5. Em Permissions (Permissões), escolha Change default execution role (Alterar a função de execução padrão).

  6. Selecione Criar uma nova função a partir de modelos de política da AWS.

  7. Em Role name (Nome da função), insira http-crud-tutorial-role.

  8. Em Policy templates (Modelos de políticas), escolha Simple microservice permissions. Esta política concede à função do Lambda permissão para interagir com o DynamoDB.

    nota

    Este tutorial usa uma política gerenciada em prol da simplicidade. Como prática recomendada, você deve criar sua própria política do IAM para conceder as permissões mínimas necessárias.

  9. Escolha Create function (Criar função).

  10. Abra a função do Lambda no editor de código do console e substitua seu conteúdo pelo código a seguir. Escolha Deploy (Implantar) para atualizar a sua função.

Node.js
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
import {
  DynamoDBDocumentClient,
  ScanCommand,
  PutCommand,
  GetCommand,
  DeleteCommand,
} from "@aws-sdk/lib-dynamodb";

const client = new DynamoDBClient({});

const dynamo = DynamoDBDocumentClient.from(client);

const tableName = "http-crud-tutorial-items";

export const handler = async (event, context) => {
  let body;
  let statusCode = 200;
  const headers = {
    "Content-Type": "application/json",
  };

  try {
    switch (event.routeKey) {
      case "DELETE /items/{id}":
        await dynamo.send(
          new DeleteCommand({
            TableName: tableName,
            Key: {
              id: event.pathParameters.id,
            },
          })
        );
        body = `Deleted item ${event.pathParameters.id}`;
        break;
      case "GET /items/{id}":
        body = await dynamo.send(
          new GetCommand({
            TableName: tableName,
            Key: {
              id: event.pathParameters.id,
            },
          })
        );
        body = body.Item;
        break;
      case "GET /items":
        body = await dynamo.send(
          new ScanCommand({ TableName: tableName })
        );
        body = body.Items;
        break;
      case "PUT /items":
        let requestJSON = JSON.parse(event.body);
        await dynamo.send(
          new PutCommand({
            TableName: tableName,
            Item: {
              id: requestJSON.id,
              price: requestJSON.price,
              name: requestJSON.name,
            },
          })
        );
        body = `Put item ${requestJSON.id}`;
        break;
      default:
        throw new Error(`Unsupported route: "${event.routeKey}"`);
    }
  } catch (err) {
    statusCode = 400;
    body = err.message;
  } finally {
    body = JSON.stringify(body);
  }

  return {
    statusCode,
    body,
    headers,
  };
};
Python
import json
import boto3
from decimal import Decimal

client = boto3.client('dynamodb')
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table('http-crud-tutorial-items')
tableName = 'http-crud-tutorial-items'


def lambda_handler(event, context):
    print(event)
    body = {}
    statusCode = 200
    headers = {
        "Content-Type": "application/json"
    }

    try:
        if event['routeKey'] == "DELETE /items/{id}":
            table.delete_item(
                Key={'id': event['pathParameters']['id']})
            body = 'Deleted item ' + event['pathParameters']['id']
        elif event['routeKey'] == "GET /items/{id}":
            body = table.get_item(
                Key={'id': event['pathParameters']['id']})
            body = body["Item"]
            responseBody = [
                {'price': float(body['price']), 'id': body['id'], 'name': body['name']}]
            body = responseBody
        elif event['routeKey'] == "GET /items":
            body = table.scan()
            body = body["Items"]
            print("ITEMS----")
            print(body)
            responseBody = []
            for items in body:
                responseItems = [
                    {'price': float(items['price']), 'id': items['id'], 'name': items['name']}]
                responseBody.append(responseItems)
            body = responseBody
        elif event['routeKey'] == "PUT /items":
            requestJSON = json.loads(event['body'])
            table.put_item(
                Item={
                    'id': requestJSON['id'],
                    'price': Decimal(str(requestJSON['price'])),
                    'name': requestJSON['name']
                })
            body = 'Put item ' + requestJSON['id']
    except KeyError:
        statusCode = 400
        body = 'Unsupported route: ' + event['routeKey']
    body = json.dumps(body)
    res = {
        "statusCode": statusCode,
        "headers": {
            "Content-Type": "application/json"
        },
        "body": body
    }
    return res

Etapa 3: Crie uma API HTTP

A API HTTP fornece um endpoint de HTTP para sua função do Lambda. Nesta etapa, você cria uma API vazia. Nas etapas a seguir, você configura rotas e integrações para conectar a sua API e sua função do Lambda.

Para criar uma API HTTP

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

  2. Escolha Create API (Criar API) e, em seguida, em API HTTP (API HTTP), escolha Build (Criar).

  3. Em API name (Nome da API), insira http-crud-tutorial-api.

  4. Escolha Next (Próximo).

  5. Em Configure routes (Configurar rotas), escolha Next (Próximo) para ignorar a criação da rota. Você cria rotas mais tarde.

  6. Analise o estágio que o API Gateway cria para você e escolha Next (Avançar).

  7. Escolha Create (Criar).

Etapa 4: Crie rotas

As rotas são uma forma de enviar as solicitações de API recebidas a recursos de backend. As rotas consistem em duas partes: um método HTTP e um caminho de recurso, por exemplo, GET /items. Para esta API de exemplo, criamos quatro rotas:

  • GET /items/{id}

  • GET /items

  • PUT /items

  • DELETE /items/{id}

Para criar rotas

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

  2. Selecione a API.

  3. Selecione Routes (Rotas).

  4. Escolha Create (Criar).

  5. Em Método, escolha GET.

  6. Para o caminho, insira /items/{id}. O {id} no final do caminho é um parâmetro de caminho que o API Gateway recupera do caminho de solicitação quando um cliente faz uma solicitação.

  7. Escolha Create (Criar).

  8. Repita as etapas quatro a sete para GET /itemsDELETE /items/{id} e PUT /items.

A sua API tem rotas para GET /items, GET /items/{id}, DELETE /items/{id} e PUT /items.

Etapa 5: Crie uma integração

Você cria uma integração para conectar uma rota aos recursos de backend. Para este exemplo de API, você cria uma integração do Lambda que usa para todas as rotas.

Para criar uma integração

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

  2. Selecione a API.

  3. Escolha Integrations (Integrações).

  4. Escolha Manage integrations (Gerenciar integrações) e, em seguida, escolha Create (Criar).

  5. Pule Attach this integration to a route (Anexar esta integração a uma rota). Você conclui isso em uma etapa posterior.

  6. Em Integration type (Tipo de integração), escolha Lambda function (Função do Lambda).

  7. Em Lambda function (Função do Lambda), insira http-crud-tutorial-function.

  8. Escolha Create (Criar).

Etapa 6: Anexe a sua integração às rotas

Para este exemplo de API, você usa a mesma integração do Lambda para todas as rotas. Depois de anexar a integração a todas as rotas da API, sua função do Lambda é invocada quando um cliente chama qualquer uma de suas rotas.

Para anexar integrações a rotas

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

  2. Selecione a API.

  3. Escolha Integrations (Integrações).

  4. Escolha uma rota.

  5. Em Choose an existing integration (Escolher uma integração existente), escolha http-crud-tutorial-function.

  6. Escolha Attach integration (Anexar integração).

  7. Repita as etapas quatro a seis para todas as rotas.

Todas as rotas mostram que há uma integração com o AWS Lambda anexada.

O console mostra o AWS Lambda em todas as rotas para indicar que sua integração está anexada.

Agora que você tem uma API HTTP com rotas e integrações, já pode testar a sua API.

Etapa 7: Teste a sua API

Para ter certeza de que a sua API está funcionando, use curl.

Para obter a URL para invocar a sua API

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

  2. Selecione a API.

  3. Observe o URL de invocação da sua API. Ela aparece em Invoke URL (Invocar URL) na página Details (Detalhes).

    Depois de criar a API, o console mostra o URL de chamada da API.

  4. Copie a URL de invocação da sua API.

    A URL completa se assemelha a https://abcdef123.execute-api.us-west-2.amazonaws.com.

Para criar ou atualizar um item

  • Use o comando a seguir para criar ou atualizar um item. O comando inclui um corpo de solicitação com o ID, o preço e o nome do item.

    curl -X "PUT" -H "Content-Type: application/json" -d "{\"id\": \"123\", \"price\": 12345, \"name\": \"myitem\"}" https://abcdef123.execute-api.us-west-2.amazonaws.com/items
Para obter todos os itens

  • Use o comando a seguir para listar todos os itens.

    curl https://abcdef123.execute-api.us-west-2.amazonaws.com/items
Para obter um item

  • Use o comando a seguir para obter um item pelo seu ID.

    curl https://abcdef123.execute-api.us-west-2.amazonaws.com/items/123
Para excluir um item

  1. Use o comando a seguir para excluir um item.

    curl -X "DELETE" https://abcdef123.execute-api.us-west-2.amazonaws.com/items/123

  2. Obtenha todos os itens para verificar se o item foi excluído.

    curl https://abcdef123.execute-api.us-west-2.amazonaws.com/items

Etapa 8: Limpar

Para evitar custos desnecessários, exclua os recursos que você criou como parte desse exercício de conceitos básicos. As etapas a seguir excluem sua API HTTP, sua função do Lambda e recursos associados.

Como excluir uma tabela do DynamoDB

  1. Abra o console do DynamoDB em https://console.aws.amazon.com/dynamodb/.

  2. Selecionar a sua tabela.

  3. Selecione Delete table (Excluir tabela).

  4. Confirme a sua decisão e escolha Delete (Excluir).

Para excluir uma API HTTP

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

  2. Na página APIs , selecione uma API. Escolha Actions (Ações) e, depois, escolha Delete (Excluir).

  3. Escolha Delete (Excluir).

Para excluir uma função do Lambda

  1. Abra o console do Lambda em https://console.aws.amazon.com/lambda

  2. Na página Functions(Funções), selecione uma função. Escolha Actions (Ações) e, depois, escolha Delete (Excluir).

  3. Escolha Delete (Excluir).

Para excluir um grupo de logs de uma função do Lambda

  1. No console do Amazon CloudWatch, abra a página Log groups (Grupos de log).

  2. Na página Log groups (Grupos de log), selecione o grupo de log da função (/aws/lambda/http-crud-tutorial-function). Escolha Actions (Ações) e selecione Delete log group (Excluir grupo de log).

  3. Escolha Delete (Excluir).

Para excluir a função de execução de uma função do Lambda

  1. No console do AWS Identity and Access Management, abra a página Roles (Funções).

  2. Selecione a atribuição da função, por exemplo, http-crud-tutorial-role.

  3. Selecione Delete role (Excluir função).

  4. Escolha Sim, excluir.

Próximas etapas: Automatizar com AWS SAM ou AWS CloudFormation

Você pode automatizar a criação e a limpeza dos recursos da AWS usando o AWS CloudFormation ou o AWS SAM. Para obter um exemplo de modelo do AWS SAM para este tutorial, consulte template.yaml.

Para ver modelos de exemplo do AWS CloudFormation, consulte modelos de exemplo do AWS CloudFormation.