

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.

# Tutorial: Erstellen einer CRUD-HTTP-API mit Lambda und DynamoDB
<a name="http-api-dynamo-db"></a>

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](https://aws.amazon.com/free/) durchgehen.

Zunächst erstellen Sie mit der DynamoDB-Konsole eine [DynamoDB-Tabelle](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html). Dann erstellen Sie mit der AWS Lambda Konsole eine [Lambda-Funktion](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html). 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.\]](http://docs.aws.amazon.com/de_de/apigateway/latest/developerguide/images/ddb-crud.png)


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](setting-up.md).

In diesem Tutorial wird AWS-Managementkonsole verwendet. Eine AWS SAM Vorlage, mit der diese API und alle zugehörigen Ressourcen erstellt werden, finden Sie unter [samples/http-dynamo-tutorial.zip](samples/http-dynamo-tutorial.zip).

**Topics**
+ [Schritt 1: Erstellen einer DynamoDB-Tabelle](#http-api-dynamo-db-create-table)
+ [Schritt 2: Erstellen einer Lambda-Funktion](#http-api-dynamo-db-create-function)
+ [Schritt 3: HTTP-API erstellen](#http-api-dynamo-db-create-api)
+ [Schritt 4: Routen erstellen](#http-api-dynamo-db-create-routes)
+ [Schritt 5: Eine Integration erstellen](#http-api-dynamo-db-create-integration)
+ [Schritt 6: Ihre Integration an Routen anfügen](#http-api-dynamo-db-attach-integrations)
+ [Schritt 7: Ihre API testen](#http-api-dynamo-db-invoke-api)
+ [Schritt 8: Bereinigen](#http-api-dynamo-db-cleanup)
+ [Nächste Schritte: Automatisieren Sie mit AWS SAM oder CloudFormation](#http-api-dynamo-db-next-steps)

## Schritt 1: Erstellen einer DynamoDB-Tabelle
<a name="http-api-dynamo-db-create-table"></a>

Sie verwenden eine [DynamoDB-Tabelle](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html), um Daten für Ihre API zu speichern. 

Jedes Element hat eine eindeutige ID, die wir als [Partitionsschlüssel](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.PrimaryKey) für die Tabelle verwenden.

**So erstellen Sie eine DynamoDB-Tabelle**

1. Öffnen Sie die DynamoDB-Konsole unter. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/)

1. Wählen Sie **Create table** aus.

1. Geben Sie für **Table name** (Tabellenname) **http-crud-tutorial-items** ein.

1. Geben Sie unter **Partitionsschlüssel** den Wert **id** ein.

1. Wählen Sie **Create table** (Tabelle erstellen) aus.

## Schritt 2: Erstellen einer Lambda-Funktion
<a name="http-api-dynamo-db-create-function"></a>

Sie erstellen eine [Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html)-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](http-api-develop-integrations-lambda.md#http-api-develop-integrations-lambda.proxy-format), 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](https://serverlessland.com/content/service/lambda/guides/aws-lambda-operator-guide/monolith).

**So erstellen Sie eine Lambda-Funktion**

1. Melden Sie sich bei der Lambda-Konsole unter [https://console.aws.amazon.com/lambda](https://console.aws.amazon.com/lambda) an.

1. Wählen Sie **Create function (Funktion erstellen)**.

1. Geben Sie für **Function name (Funktionsname)** **http-crud-tutorial-function** ein.

1. Wählen Sie für **Laufzeit** die neueste unterstützte **Node.js**- oder **Python**-Laufzeit aus.

1. Wählen Sie unter **Berechtigungen** die Option **Standard-Ausführungsrolle ändern** aus.

1. Wählen Sie **Neue Rolle aus Richtlinienvorlagen erstellen aus AWS **.

1. Geben Sie für **Role name (Rollenname)** den Namen **http-crud-tutorial-role** ein.

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

1. Wählen Sie **Create function (Funktion erstellen)**.

1. Ö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
```

------

## Schritt 3: HTTP-API erstellen
<a name="http-api-dynamo-db-create-api"></a>

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

1. Melden Sie sich bei der API Gateway Gateway-Konsole unter [https://console.aws.amazon.com/apigatewayan](https://console.aws.amazon.com/apigateway).

1. Wählen Sie **Create API (API erstellen)** und dann für **HTTP API** die Option **Build (Erstellen)** aus.

1. Geben Sie unter **API name (API-Name)** **http-crud-tutorial-api** ein.

1. Wählen Sie als **IP-Adresstyp** die Option. **IPv4**

1. Wählen Sie **Next**.

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

1. Überprüfen Sie die Phase, die API Gateway für Sie erstellt, und wählen Sie dann **Next (Weiter)** aus.

1. Wählen Sie **Create** aus.

## Schritt 4: Routen erstellen
<a name="http-api-dynamo-db-create-routes"></a>

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

1. Melden Sie sich bei der API Gateway Gateway-Konsole unter [https://console.aws.amazon.com/apigatewayan](https://console.aws.amazon.com/apigateway).

1. Wählen Sie Ihre API aus.

1. Wählen Sie **Routes (Routen)** aus.

1. Wählen Sie **Create** aus.

1. Wählen Sie für **Methode** **GET** aus.

1. Für den Pfad geben Sie ei **/items/\$1id\$1**. `{id}` am Ende des Pfads ist ein Pfadparameter, den API Gateway vom Anforderungspfad abruft, wenn ein Client eine Anforderung stellt.

1. Wählen Sie **Create** aus.

1. 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.\]](http://docs.aws.amazon.com/de_de/apigateway/latest/developerguide/images/ddb-create-routes.png)


## Schritt 5: Eine Integration erstellen
<a name="http-api-dynamo-db-create-integration"></a>

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

1. Melden Sie sich bei der API Gateway Gateway-Konsole unter [https://console.aws.amazon.com/apigatewayan](https://console.aws.amazon.com/apigateway).

1. Wählen Sie Ihre API aus.

1. Wähle Sie **Integrations (Integrationen)** aus.

1. Wählen Sie **Manage integrations (Integrationen verwalten)** und dann **Create (Erstellen)** aus.

1. Ü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.

1. Für **Integration type (Integrationstyp)** wählen Sie **Lambda Function (Lambda-Funktion)** aus.

1. Geben Sie für die **Lambda function (Lambda-Funktion)** **http-crud-tutorial-function** ein.

1. Wählen Sie **Create** aus.

## Schritt 6: Ihre Integration an Routen anfügen
<a name="http-api-dynamo-db-attach-integrations"></a>

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

1. Melden Sie sich bei der API Gateway Gateway-Konsole unter [https://console.aws.amazon.com/apigatewayan](https://console.aws.amazon.com/apigateway).

1. Wählen Sie Ihre API aus.

1. Wähle Sie **Integrations (Integrationen)** aus.

1. Wählen Sie eine Route aus.

1. Wählen Sie unter **Choose an existing integration (Eine vorhandene Integration auswählen) ** **http-crud-tutorial-function** aus.

1. Wählen Sie **Attach integration (Integration anhängen)** aus.

1. 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.\]](http://docs.aws.amazon.com/de_de/apigateway/latest/developerguide/images/ddb-attach-integrations.png)


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

## Schritt 7: Ihre API testen
<a name="http-api-dynamo-db-invoke-api"></a>

Um sicherzustellen, dass Ihre API funktioniert, verwenden Sie [curl](https://curl.se).

**So wird die URL zum Aufrufen Ihrer API abgerufen**

1. Melden Sie sich bei der API Gateway Gateway-Konsole unter [https://console.aws.amazon.com/apigatewayan](https://console.aws.amazon.com/apigateway).

1. Wählen Sie Ihre API aus.

1. Notieren Sie sich die Aufruf-URL Ihrer API. Sie wird auf der Seite **Details** unter **Invoke URL (URL aufrufen)** angezeigt.  
![\[Nachdem Sie Ihre API erstellt haben, zeigt die Konsole die Aufruf-URL Ihrer API an.\]](http://docs.aws.amazon.com/de_de/apigateway/latest/developerguide/images/ddb-invoke-url.png)

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

1. 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
   ```

1. 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
<a name="http-api-dynamo-db-cleanup"></a>

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

1. Öffnen Sie die DynamoDB-Konsole unter. [https://console.aws.amazon.com/dynamodb/](https://console.aws.amazon.com/dynamodb/)

1. Wählen Sie Ihre Tabelle aus.

1. Wählen Sie **Delete Table (Tabelle löschen)**.

1. Bestätigen Sie Ihre Wahl und wählen Sie **Delete (Löschen)** aus.

**So löschen Sie eine HTTP-API**

1. Melden Sie sich bei der API Gateway Gateway-Konsole unter [https://console.aws.amazon.com/apigatewayan](https://console.aws.amazon.com/apigateway).

1. Wählen Sie auf der **APIs**Seite eine API aus. Wählen Sie **Actions** und anschließend **Delete**.

1. Wählen Sie **Delete (Löschen)**.

**So löschen Sie eine Lambda-Funktion**

1. Melden Sie sich bei der Lambda-Konsole unter [https://console.aws.amazon.com/lambda](https://console.aws.amazon.com/lambda) an.

1. Wählen Sie auf der Seite **Functions (Funktionen)** eine Funktion aus. Wählen Sie **Actions** und anschließend **Delete**.

1. Wählen Sie **Delete (Löschen)**.

**So löschen Sie die Protokollgruppe einer Lambda-Funktion**

1. Öffnen Sie in der CloudWatch Amazon-Konsole die [Seite Protokollgruppen](https://console.aws.amazon.com/cloudwatch/home#logs:).

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

1. Wählen Sie **Delete (Löschen)**.

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

1. Öffnen Sie in der AWS Identity and Access Management Konsole die [Seite Rollen](https://console.aws.amazon.com/iam/home?#/roles).

1. Wählen Sie die Rolle der Funktion aus, zum Beispiel, `http-crud-tutorial-role`.

1. Wählen Sie **Delete role (Rolle löschen)** aus.

1. Wählen Sie **Yes, delete (Ja, löschen)** aus.

## Nächste Schritte: Automatisieren Sie mit AWS SAM oder CloudFormation
<a name="http-api-dynamo-db-next-steps"></a>

Sie können die Erstellung und Bereinigung von AWS Ressourcen automatisieren, indem Sie CloudFormation oder AWS SAM verwenden. Ein Beispiel für eine AWS SAM -Vorlage für dieses Tutorial finden Sie unter [samples/http-dynamo-tutorial.zip](samples/http-dynamo-tutorial.zip).

 CloudFormation Beispielvorlagen finden Sie unter [CloudFormation Beispielvorlagen](https://github.com/awsdocs/amazon-api-gateway-developer-guide/tree/main/cloudformation-templates).