Tutorial: Erstellen einer CRUD-HTTP-API mit Lambda und DynamoDB

Fokusmodus

Tutorial: Erstellen einer CRUD-HTTP-API mit Lambda und DynamoDB - Amazon API Gateway

Schritt 1: Erstellen einer DynamoDB-Tabelle Schritt 2: Erstellen einer Lambda-Funktion Schritt 3: HTTP-API erstellen Schritt 4: Routen erstellen Schritt 5: Eine Integration erstellen Schritt 6: Ihre Integration an Routen anfügen Schritt 7: Ihre API testen Schritt 8: Bereinigen Nächste Schritte: Automatisieren Sie mit AWS SAM oder AWS CloudFormation

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

In diesem Tutorial erstellen Sie eine serverlose API, die Elemente aus einer DynamoDB-Tabelle erstellt, liest, aktualisiert und löscht. DynamoDB ist ein vollständig verwalteter NoSQL-Datenbankservice, der schnelle und vorhersehbare Leistung nahtlos skalierbar bereitstellt. Dieses Tutorial dauert ungefähr 30 Minuten, und Sie können es im Rahmen des kostenlosen Kontingents von AWS durchgehen.

Zunächst erstellen Sie mit der DynamoDB-Konsole eine DynamoDB-Tabelle. Dann erstellen Sie mit der AWS Lambda Konsole eine Lambda-Funktion. Als Nächstes erstellen Sie eine HTTP-API mit der API-Gateway-Konsole. Zuletzt testen Sie Ihre API.

Wenn Sie Ihre HTTP-API aufrufen, leitet API Gateway die Anfrage an Ihre Lambda-Funktion weiter. Die Lambda-Funktion interagiert mit DynamoDB und gibt eine Antwort an API Gateway zurück. API Gateway gibt dann eine Antwort an Sie zurück.

Übersicht der HTTP-API, die Sie in diesem Tutorial erstellen.

Um diese Übung abzuschließen, benötigen Sie ein AWS Konto und einen AWS Identity and Access Management Benutzer mit Konsolenzugriff. Weitere Informationen finden Sie unter Einrichten der API Gateway.

In diesem Tutorial wird AWS Management Console verwendet. Eine AWS SAM Vorlage, die diese API und alle zugehörigen Ressourcen erstellt, finden Sie unter template.yaml.

Themen

Schritt 1: Erstellen einer DynamoDB-Tabelle
Schritt 2: Erstellen einer Lambda-Funktion
Schritt 3: HTTP-API erstellen
Schritt 4: Routen erstellen
Schritt 5: Eine Integration erstellen
Schritt 6: Ihre Integration an Routen anfügen
Schritt 7: Ihre API testen
Schritt 8: Bereinigen
Nächste Schritte: Automatisieren Sie mit AWS SAM oder AWS CloudFormation

Schritt 1: Erstellen einer DynamoDB-Tabelle

Sie verwenden eine DynamoDB-Tabelle, um Daten für Ihre API zu speichern.

Jedes Element hat eine eindeutige ID, die wir als Partitionsschlüssel für die Tabelle verwenden.

So erstellen Sie eine DynamoDB-Tabelle

Öffnen Sie die DynamoDB-Konsole unter. https://console.aws.amazon.com/dynamodb/
Wählen Sie Create table aus.
Geben Sie für Table name (Tabellenname) http-crud-tutorial-items ein.
Geben Sie für Partition key (Partitionsschlüssel) den Wert id ein.
Wählen Sie Create table (Tabelle erstellen) aus.

Schritt 2: Erstellen einer Lambda-Funktion

Sie erstellen eine Lambda-Funktion für das Backend Ihrer API. Diese Lambda-Funktion erstellt, liest, aktualisiert und löscht Elemente aus DynamoDB. Die Funktion verwendet Ereignisse von API Gateway, um zu bestimmen, wie mit DynamoDB interagiert wird. Der Einfachheit halber verwendet dieses Tutorial eine einzige Lambda-Funktion. Als Best Practice sollten Sie separate Funktionen für jede Route erstellen. Weitere Informationen finden Sie unter Der Lambda-Monolith.

Eine Lambda-Funktion erstellen

Melden Sie sich bei der Lambda-Konsole unter https://console.aws.amazon.com/lambda an.
Wählen Sie Funktion erstellen aus.
Geben Sie für Function name (Funktionsname) http-crud-tutorial-function ein.
Wählen Sie für Laufzeit die neueste unterstützte Node.js- oder Python-Laufzeit aus.
Wählen Sie unter Berechtigungen die Option Standardeausführungsrolle ändern aus.
Wählen Sie Neue Rolle aus Richtlinienvorlagen erstellen aus AWS .
Geben Sie für Role name (Rollenname) den Namen http-crud-tutorial-role ein.
Wählen Sie für Policy templates (Richtlinienvorlagen) Simple microservice permissions aus. Diese Richtlinie gewährt der Lambda-Funktion die Berechtigung, mit DynamoDB zu interagieren.

Anmerkung
Dieses Tutorial verwendet der Einfachheit halber eine verwaltete Richtlinie. Als Best Practice sollten Sie Ihre eigene IAM-Richtlinie erstellen, um die erforderlichen Mindestberechtigungen zu gewähren.
Wählen Sie Funktion erstellen aus.
Öffnen Sie die Lambda-Funktion im Code-Editor der Konsole und ersetzen Sie den Inhalt durch den folgenden Code. Wählen Sie Deploy (Bereitstellen) aus, um Ihre Funktion zu aktualisieren.

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

anchor anchor


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

Schritt 3: HTTP-API erstellen

Die HTTP-API bietet einen HTTP-Endpunkt für Ihre Lambda-Funktion. In diesem Schritt erstellen Sie eine leere API. In den folgenden Schritten konfigurieren Sie Routen und Integrationen, um Ihre API und Ihre Lambda-Funktion zu verbinden.

So erstellen Sie eine HTTP-API

Melden Sie sich bei der API Gateway Gateway-Konsole unter https://console.aws.amazon.com/apigatewayan.
Wählen Sie Create API (API erstellen) und dann für HTTP API die Option Build (Erstellen) aus.
Geben Sie unter API name (API-Name) http-crud-tutorial-api ein.
Wählen Sie Next.
Wählen Sie für Configure routes (Routen konfigurieren) die Option Next (Weiter) aus, um die Routenerstellung zu überspringen. Sie werden Routen später erstellen.
Überprüfen Sie die Phase, die API Gateway für Sie erstellt, und wählen Sie dann Next (Weiter) aus.
Wählen Sie Create aus.

Schritt 4: Routen erstellen

Routen sind eine Möglichkeit, eingehende API-Anforderungen an Backend-Ressourcen zu senden. Routen bestehen aus zwei Teilen: einer HTTP-Methode und einem Ressourcenpfad, zum Beispie, GET /items. Für diese Beispiel-API erstellen wir vier Routen:

GET /items/{id}
GET /items
PUT /items
DELETE /items/{id}

So werden Routen erstellt

Melden Sie sich bei der API Gateway Gateway-Konsole unter https://console.aws.amazon.com/apigatewayan.
Wählen Sie Ihre API aus.
Wählen Sie Routes (Routen) aus.
Wählen Sie Create aus.
Wählen Sie für Methode GET aus.
Für den Pfad geben Sie ei /items/{id}. {id} am Ende des Pfads ist ein Pfadparameter, den API Gateway vom Anforderungspfad abruft, wenn ein Client eine Anforderung stellt.
Wählen Sie Create aus.
Wiederholen Sie die Schritte 4-7 für GET /items, DELETE /items/{id} und PUT /items.

Ihre API hat Routen für GET /items, GET /items/{id}, DELETE /items/{id} und PUT /items.

Schritt 5: Eine Integration erstellen

Sie erstellen eine Integration, um eine Route mit Backend-Ressourcen zu verbinden. Für diese Beispiel-API erstellen Sie eine Lambda-Integration, die Sie für alle Routen verwenden.

So wird eine Integration erstellt

Melden Sie sich bei der API Gateway Gateway-Konsole unter https://console.aws.amazon.com/apigatewayan.
Wählen Sie Ihre API aus.
Wähle Sie Integrations (Integrationen) aus.
Wählen Sie Manage integrations (Integrationen verwalten) und dann Create (Erstellen) aus.
Überspringen Sie Attach this integration to a route (Diese Integration an eine Route anfügen). Dies werden Sie in einem späteren Schritt abschließen.
Für Integration type (Integrationstyp) wählen Sie Lambda Function (Lambda-Funktion) aus.
Geben Sie für die Lambda function (Lambda-Funktion) http-crud-tutorial-function ein.
Wählen Sie Create aus.

Schritt 6: Ihre Integration an Routen anfügen

Für diese Beispiel-API verwenden Sie dieselbe Lambda-Integration für alle Routen. Nachdem Sie die Integration allen Routen der API angefügt haben, wird Ihre Lambda-Funktion aufgerufen, wenn ein Client eine Ihrer Routen aufruft.

So werden Integrationen an Routen angefügt

Melden Sie sich bei der API Gateway Gateway-Konsole unter https://console.aws.amazon.com/apigatewayan.
Wählen Sie Ihre API aus.
Wähle Sie Integrations (Integrationen) aus.
Wählen Sie eine Route aus.
Wählen Sie unter Choose an existing integration (Eine vorhandene Integration auswählen) http-crud-tutorial-function aus.
Wählen Sie Attach integration (Integration anhängen) aus.
Wiederholen Sie die Schritte 4 bis 6 für alle Routen.

Alle Routen zeigen, dass eine AWS Lambda Integration angehängt ist.

Die Konsole wird AWS Lambda auf allen Routen angezeigt, um darauf hinzuweisen, dass Ihre Integration angehängt ist.

Jetzt, da Sie eine HTTP-API mit Routen und Integrationen haben, können Sie Ihre API testen.

Schritt 7: Ihre API testen

Um sicherzustellen, dass Ihre API funktioniert, verwenden Sie curl.

So wird die URL zum Aufrufen Ihrer API abgerufen

Melden Sie sich bei der API Gateway Gateway-Konsole unter https://console.aws.amazon.com/apigatewayan.
Wählen Sie Ihre API aus.
Notieren Sie sich die Aufruf-URL Ihrer API. Sie wird auf der Seite Details unter Invoke URL (URL aufrufen) angezeigt.
Kopieren Sie die Aufruf-URL Ihrer API.

Die vollständige URL sieht folgendermaßen aus: https://abcdef123.execute-api.us-west-2.amazonaws.com.

Erstellen oder Aktualisieren eines Elements

Verwenden Sie den folgenden Befehl, um ein Element zu erstellen oder zu aktualisieren. Der Befehl enthält einen Anfragetext mit der ID, dem Preis und dem Namen des Elements.


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

Abrufen aller Elemente

Verwenden Sie den folgenden Befehl, um alle Elemente aufzulisten.


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

Abrufen eines Elements

Verwenden Sie den folgenden Befehl, um ein Element anhand seiner ID zu erhalten.


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

So löschen Sie einen Artikel

Verwenden Sie den folgenden Befehl, um ein Element zu löschen.


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

Rufen Sie alle Elemente ab, um zu überprüfen, ob das Element gelöscht wurde.


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

Schritt 8: Bereinigen

Um unnötige Kosten zu vermeiden, löschen Sie die Ressourcen, die Sie im Rahmen dieser Übung „Erste Schritte“ erstellt haben. In den folgenden Schritten werden Ihre HTTP-API, Ihre Lambda-Funktion und die zugehörigen Ressourcen gelöscht.

So löschen Sie eine DynamoDB-Tabelle

Öffnen Sie die DynamoDB-Konsole unter. https://console.aws.amazon.com/dynamodb/
Wählen Sie Ihre Tabelle aus.
Wählen Sie Delete Table (Tabelle löschen).
Bestätigen Sie Ihre Wahl und wählen Sie Delete (Löschen) aus.

So löschen Sie eine HTTP-API

Melden Sie sich bei der API Gateway Gateway-Konsole unter https://console.aws.amazon.com/apigatewayan.
Wählen Sie auf der APIsSeite eine API aus. Wählen Sie Actions und anschließend Delete.
Wählen Sie Delete (Löschen).

So löschen Sie eine Lambda-Funktion

Melden Sie sich bei der Lambda-Konsole unter https://console.aws.amazon.com/lambda an.
Wählen Sie auf der Seite Functions (Funktionen) eine Funktion aus. Wählen Sie Actions und anschließend Delete.
Wählen Sie Delete (Löschen).

So löschen Sie die Protokollgruppe einer Lambda-Funktion

Öffnen Sie in der CloudWatch Amazon-Konsole die Seite Protokollgruppen.
Wählen Sie auf der Seite Log groups (Protokollgruppen) die Protokollgruppe (/aws/lambda/http-crud-tutorial-function) der Funktion aus. Wählen Sie Actions (Aktionen) und dann Delete log group (Protokollgruppe löschen) aus.
Wählen Sie Delete (Löschen).

So löschen Sie die Ausführungsrolle einer Lambda-Funktion

Öffnen Sie in der AWS Identity and Access Management Konsole die Seite Rollen.
Wählen Sie die Rolle der Funktion aus, zum Beispie, http-crud-tutorial-role.
Wählen Sie Delete role (Rolle löschen) aus.
Wählen Sie Yes, delete (Ja, löschen) aus.

Nächste Schritte: Automatisieren Sie mit AWS SAM oder AWS CloudFormation

Sie können die Erstellung und Bereinigung von AWS Ressourcen automatisieren, indem Sie AWS CloudFormation oder AWS SAM verwenden. Ein Beispiel für eine AWS SAM -Vorlage für dieses Tutorial finden Sie unter template.yaml.

AWS CloudFormation Beispielvorlagen finden Sie unter AWS CloudFormation Beispielvorlagen.

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

HTTP API-Tutorials

Tutorial: Erstellen einer HTTP-API mit privater Integration für Amazon-ECS

Auf dieser Seite

Wählen Sie Ihre Cookie-Einstellungen aus