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.

# Verwenden von Aurora Serverless v2 mit AWS AppSync
<a name="tutorial-rds-resolvers"></a>

Connect Ihre GraphQL-API mit Aurora Serverless-Datenbanken mithilfe von. AWS AppSync Mit dieser Integration können Sie SQL-Anweisungen über GraphQL-Abfragen, -Mutationen und -Subskriptionen ausführen und so flexibel mit Ihren relationalen Daten interagieren.

**Anmerkung**  
Für dieses Tutorial wird die Region `US-EAST-1` verwendet.

**Vorteile**
+ Nahtlose Integration zwischen GraphQL und relationalen Datenbanken
+ Fähigkeit, SQL-Operationen über GraphQL-Schnittstellen durchzuführen
+ Serverlose Skalierbarkeit mit Aurora Serverless v2
+ Sicherer Datenzugriff über AWS Secrets Manager
+ Schutz vor SQL-Injection durch Eingabebereinigung
+ Flexible Abfragefunktionen, einschließlich Filter- und Bereichsoperationen

**Häufige Anwendungsfälle**
+ Entwicklung skalierbarer Anwendungen mit relationalen Datenanforderungen
+ Um APIs diese zu erstellen, sind sowohl GraphQL-Flexibilität als auch SQL-Datenbankfunktionen erforderlich
+ Verwaltung von Datenoperationen durch GraphQL-Mutationen und Abfragen
+ Implementierung sicherer Datenbankzugriffsmuster

In diesem Tutorial lernen Sie Folgendes.
+ Richten Sie einen Aurora Serverless v2-Cluster ein
+ Aktivieren Sie die Daten-API-Funktionalität
+ Datenbankstrukturen erstellen und konfigurieren
+ Definieren Sie GraphQL-Schemas für Datenbankoperationen
+ Implementieren Sie Resolver für Abfragen und Mutationen
+ Schützen Sie Ihren Datenzugriff durch eine angemessene Eingabebereinigung
+ Führen Sie verschiedene Datenbankoperationen über GraphQL-Schnittstellen aus

**Topics**
+ [Richten Sie Ihren Datenbankcluster ein](#create-cluster)
+ [Aktivieren der Daten-API](#enable-data-api)
+ [Datenbank und Tabelle erstellen](#create-database-and-table)
+ [GraphQL-Schema](#graphql-schema)
+ [Connect Sie Ihre API mit Datenbankoperationen](#configuring-resolvers)
+ [Ändern Sie Ihre Daten über die API](#run-mutations)
+ [Rufen Sie Ihre Daten ab](#run-queries)
+ [Schützen Sie Ihren Datenzugriff](#input-sanitization)

## Richten Sie Ihren Datenbankcluster ein
<a name="create-cluster"></a>

Bevor Sie eine Amazon RDS-Datenquelle hinzufügen AWS AppSync, müssen Sie zunächst eine Daten-API auf einem Aurora Serverless v2-Cluster aktivieren und **einen geheimen Schlüssel mithilfe von *AWS Secrets Manager*konfigurieren**. Sie können einen Aurora Serverless v2-Cluster erstellen, indem Sie: AWS CLI

```
aws rds create-db-cluster \
    --db-cluster-identifier appsync-tutorial \
    --engine aurora-mysql \
    --engine-version 8.0 \
    --serverless-v2-scaling-configuration MinCapacity=0,MaxCapacity=1 \
    --master-username USERNAME \
    --master-user-password COMPLEX_PASSWORD \
    --enable-http-endpoint
```

Dadurch wird ein ARN für den Cluster zurückgegeben.

Nachdem Sie den Cluster erstellt haben, müssen Sie mit dem folgenden Befehl eine Aurora Serverless v2-Instance hinzufügen.

```
aws rds create-db-instance \
    --db-cluster-identifier appsync-tutorial \
    --db-instance-identifier appsync-tutorial-instance-1 \
    --db-instance-class db.serverless \
    --engine aurora-mysql
```

**Anmerkung**  
Die Aktivierung dieser Endpunkte benötigt Zeit. Sie können ihren Status in der Amazon RDS-Konsole auf der Registerkarte **Konnektivität und Sicherheit** für den Cluster überprüfen. Sie können den Status Ihres Clusters auch mit dem folgenden AWS CLI Befehl überprüfen.   

```
aws rds describe-db-clusters \
    --db-cluster-identifier appsync-tutorial \
    --query "DBClusters[0].Status"
```

Sie können ein *Secret* mithilfe der AWS Secrets Manager Konsole oder AWS CLI mit einer Eingabedatei wie der folgenden erstellen, indem Sie die `USERNAME` und `COMPLEX_PASSWORD` aus dem vorherigen Schritt verwenden.

```
{
    "username": "USERNAME",
    "password": "COMPLEX_PASSWORD"
}
```

Übergeben Sie dies als Parameter an AWS CLI:

```
aws secretsmanager create-secret --name HttpRDSSecret --secret-string file://creds.json --region us-east-1
```

Dadurch wird ein ARN für das Secret zurückgegeben.

 **Notieren Sie sich den ARN** Ihres Aurora Serverless Clusters und Secret für die spätere Verwendung in der AppSync Konsole, wenn Sie eine Datenquelle erstellen.

## Aktivieren der Daten-API
<a name="enable-data-api"></a>

Die Daten-API können Sie auf Ihrem Cluster aktivieren, indem Sie die [folgende Anleitung aus der RDS-Dokumentation](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/data-api.html) ausführen. Die Daten-API muss aktiviert werden, bevor sie als AppSync Datenquelle hinzugefügt werden kann.

## Datenbank und Tabelle erstellen
<a name="create-database-and-table"></a>

Sobald Sie Ihre Daten-API aktiviert haben, können Sie sicherstellen, dass sie mit dem `aws rds-data execute-statement` Befehl in der funktioniert AWS CLI. Dadurch wird sichergestellt, dass Ihr Aurora Serverless-Cluster korrekt konfiguriert ist, bevor Sie ihn zu Ihrer AppSync API hinzufügen. Erstellen Sie zunächst eine Datenbank namens *TESTDB* mit dem folgenden `--sql` Parameter:

```
aws rds-data execute-statement --resource-arn "arn:aws:rds:us-east-1:123456789000:cluster:http-endpoint-test" \
--schema "mysql"  --secret-arn "arn:aws:secretsmanager:us-east-1:123456789000:secret:testHttp2-AmNvc1"  \
--region us-east-1 --sql "create DATABASE TESTDB"
```

Wenn dies fehlerfrei ausgeführt wird, fügen Sie mit dem Befehl *create table* eine Tabelle hinzu:

```
aws rds-data execute-statement --resource-arn "arn:aws:rds:us-east-1:123456789000:cluster:http-endpoint-test" \
 --schema "mysql"  --secret-arn "arn:aws:secretsmanager:us-east-1:123456789000:secret:testHttp2-AmNvc1" \
 --region us-east-1 \
 --sql "create table Pets(id varchar(200), type varchar(200), price float)" --database "TESTDB"
```

Wenn alles ohne Probleme gelaufen ist, können Sie den Cluster als Datenquelle zu Ihrer AppSync API hinzufügen.

## GraphQL-Schema
<a name="graphql-schema"></a>

Ihre Aurora Serverless-Daten-API ist eingerichtet und wird mit einer Tabelle ausgeführt. Jetzt erstellen wir ein GraphQL-Schema und fügen Resolver an, um Mutationen und Abonnements durchzuführen. Erstellen Sie eine neue API in der AWS AppSync Konsole, navigieren Sie zur **Schemaseite** und geben Sie Folgendes ein:

```
type Mutation {
    createPet(input: CreatePetInput!): Pet
    updatePet(input: UpdatePetInput!): Pet
    deletePet(input: DeletePetInput!): Pet
}

input CreatePetInput {
    type: PetType
    price: Float!
}

input UpdatePetInput {
id: ID!
    type: PetType
    price: Float!
}

input DeletePetInput {
    id: ID!
}

type Pet {
    id: ID!
    type: PetType
    price: Float
}

enum PetType {
    dog
    cat
    fish
    bird
    gecko
}

type Query {
    getPet(id: ID!): Pet
    listPets: [Pet]
    listPetsByPriceRange(min: Float, max: Float): [Pet]
}

schema {
    query: Query
    mutation: Mutation
}
```

 **Speichern** Sie Ihr Schema. Navigieren Sie zur Seite **Data Sources (Datenquellen)** und erstellen Sie eine neue Datenquelle. Wählen Sie für den Typ der Datenquelle **Relationale Datenbank** aus und geben Sie einen aussagekräftigen Namen ein. Verwenden Sie den im letzten Schritt erstellten Datenbanknamen und den darin erstellen **Cluster ARN (Cluster-ARN)**. Für die **Rolle** können Sie entweder eine neue Rolle AppSync erstellen lassen oder eine mit einer Richtlinie erstellen, die der folgenden ähnelt:

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

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "rds-data:BatchExecuteStatement",
                "rds-data:BeginTransaction",
                "rds-data:CommitTransaction",
                "rds-data:ExecuteStatement",
                "rds-data:RollbackTransaction"
            ],
            "Resource": [
                "arn:aws:rds:us-east-1:111122223333:cluster:mydbcluster",
                "arn:aws:rds:us-east-1:111122223333:cluster:mydbcluster:*"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
                "secretsmanager:GetSecretValue"
            ],
            "Resource": [
            "arn:aws:secretsmanager:us-east-1:111122223333:secret:mysecret",
            "arn:aws:secretsmanager:us-east-1:111122223333:secret:mysecret:*"
            ]
        }
    ]
}
```

------

Beachten Sie, dass diese Richtlinie zwei **Anweisungen** enthält, die den Zugriff der Rolle gewähren. Die erste **Ressource** ist Ihr Aurora Serverless-Cluster und die zweite ist Ihr AWS Secrets Manager ARN. Sie müssen **BEIDE** ARNs in der AppSync Datenquellenkonfiguration angeben, bevor Sie auf **Erstellen** klicken.

Übergeben Sie dies als Parameter an den AWS CLI.

```
aws secretsmanager create-secret \
  --name HttpRDSSecret \
  --secret-string file://creds.json \
  --region us-east-1
```

Dadurch wird ein ARN für das Secret zurückgegeben. Notieren Sie sich den ARN Ihres Aurora Serverless Clusters und Secret für später, wenn Sie eine Datenquelle in der AWS AppSync Konsole erstellen.

### Erstellen Sie Ihre Datenbankstruktur
<a name="create-database-and-table"></a>

Sobald Sie Ihre Daten-API aktiviert haben, können Sie sicherstellen, dass sie mit dem `aws rds-data execute-statement` Befehl in der funktioniert AWS CLI. Dadurch wird sichergestellt, dass Ihr Aurora Serverless v2-Cluster korrekt konfiguriert ist, bevor Sie ihn zu Ihrer AWS AppSync API hinzufügen. Erstellen Sie zunächst eine Datenbank namens *TESTDB* mit dem folgenden `--sql` Parameter.

```
aws rds-data execute-statement \
                --resource-arn "arn:aws:rds:us-east-1:111122223333:cluster:appsync-tutorial" \
                --secret-arn "arn:aws:secretsmanager:us-east-1:111122223333:secret:appsync-tutorial-rds-secret"  \
                --region us-east-1 \
                --sql "create DATABASE TESTDB"
```

Wenn dies ohne Fehler läuft, fügen Sie mit dem folgenden Befehl *create table eine Tabelle* hinzu.

```
aws rds-data execute-statement \
      --resource-arn "arn:aws:rds:us-east-1:111122223333:cluster:http-endpoint-test" \
      --secret-arn "arn:aws:secretsmanager:us-east-1:111122223333:secret:testHttp2-AmNvc1" \
      --region us-east-1 \
      --sql "create table Pets(id varchar(200), type varchar(200), price float)" \
      --database "TESTDB"
```

### Entwerfen Sie Ihre API-Schnittstelle
<a name="graphql-schema"></a>

Nachdem die Aurora Serverless v2 Data API mit einer Tabelle betriebsbereit ist, erstellen Sie ein GraphQL-Schema und hängen Sie Resolver an, um Mutationen und Abonnements durchzuführen. Erstellen Sie eine neue API in der AWS AppSync Konsole, navigieren Sie zur **Schemaseite** in der Konsole und geben Sie Folgendes ein.

```
type Mutation {
        createPet(input: CreatePetInput!): Pet
        updatePet(input: UpdatePetInput!): Pet
        deletePet(input: DeletePetInput!): Pet
    }
    
    input CreatePetInput {
        type: PetType
        price: Float!
    }
    
    input UpdatePetInput {
        id: ID!
        type: PetType
        price: Float!
    }
    
    input DeletePetInput {
        id: ID!
    }
    
    type Pet {
        id: ID!
        type: PetType
        price: Float
    }
    
    enum PetType {
        dog
        cat
        fish
        bird
        gecko
    }
    
    type Query {
        getPet(id: ID!): Pet
        listPets: [Pet]
        listPetsByPriceRange(min: Float, max: Float): [Pet]
    }
    
    schema {
        query: Query
        mutation: Mutation
    }
```

 **Speichern** Sie Ihr Schema. Navigieren Sie zur Seite **Data Sources (Datenquellen)** und erstellen Sie eine neue Datenquelle. Wählen Sie **Relationale Datenbank** als **Datenquellentyp** und geben Sie einen benutzerfreundlichen Namen ein. Verwenden Sie den im letzten Schritt erstellten Datenbanknamen und den darin erstellen **Cluster ARN (Cluster-ARN)**. Für die **Rolle** können Sie entweder eine neue Rolle AWS AppSync erstellen lassen oder eine mit einer Richtlinie erstellen, die der folgenden ähnelt.

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

****  

```
{
        "Version":"2012-10-17",		 	 	 
        "Statement": [
            {
                "Effect": "Allow",
                "Action": [
                    "rds-data:BatchExecuteStatement",
                    "rds-data:BeginTransaction",
                    "rds-data:CommitTransaction",
                    "rds-data:ExecuteStatement",
                    "rds-data:RollbackTransaction"
                ],
                "Resource": [
                    "arn:aws:rds:us-east-1:111122223333:cluster:mydbcluster",
                    "arn:aws:rds:us-east-1:111122223333:cluster:mydbcluster:*"
                ]
            },
            {
                "Effect": "Allow",
                "Action": [
                    "secretsmanager:GetSecretValue"
                ],
                "Resource": [
                "arn:aws:secretsmanager:us-east-1:111122223333:secret:mysecret",
                "arn:aws:secretsmanager:us-east-1:111122223333:secret:mysecret:*"
                ]
            }
        ]
    }
```

------

Beachten Sie, dass diese Richtlinie zwei **Anweisungen** enthält, die den Zugriff der Rolle gewähren. Die erste **Ressource** ist Ihr Aurora Serverless v2-Cluster und die zweite ist Ihr AWS Secrets Manager ARN. Sie müssen **BEIDE** ARNs in der AWS AppSync Datenquellenkonfiguration angeben, bevor Sie auf **Erstellen** klicken.

## Connect Sie Ihre API mit Datenbankoperationen
<a name="configuring-resolvers"></a>

Da wir nun ein gültiges GraphQL-Schema und eine RDS-Datenquelle haben, können Sie Resolver an die GraphQL-Felder Ihres Schemas anhängen. Unsere API bietet folgende Funktionen:

1. *erstellen Sie mit dem Feld Mutation.createPet ein Haustier*

1. *aktualisieren Sie ein Haustier mithilfe des Felds Mutation.UpdatePet*

1. *lösche ein Haustier mithilfe des Felds Mutation.deletePet*

1. *Holen Sie sich eine Single mithilfe des Felds Query.getPet*

1. *listet alle mithilfe des Felds query.listPets auf*

1. *listet mithilfe der Abfrage Haustiere in einer Preisklasse auf. listPetsByPriceRange*Feld

### Mutation.createPet
<a name="mutation-createpet"></a>

Wählen Sie im Schema-Editor in der AWS AppSync Konsole auf der rechten Seite **Attach Resolver** for `createPet(input: CreatePetInput!): Pet` aus. Wählen Sie Ihre RDS-Datenquelle aus. Fügen Sie die folgende Vorlage im Abschnitt **request mapping template (Zuweisungsvorlage für Anforderungen)** ein:

```
#set($id=$utils.autoId())
{
"version": "2018-05-29",
    "statements": [
        "insert into Pets VALUES (:ID, :TYPE, :PRICE)",
        "select * from Pets WHERE id = :ID"
    ],
    "variableMap": {
        ":ID": "$ctx.args.input.id",
        ":TYPE": $util.toJson($ctx.args.input.type),
        ":PRICE": $util.toJson($ctx.args.input.price)
    }
}
```

**Das System führt SQL-Anweisungen sequentiell aus, basierend auf der Reihenfolge im Anweisungsarray.** Die Ergebnisse werden wieder in derselben Reihenfolge zurückgegeben. Da es sich um eine Mutation handelt, führen Sie nach dem *Einfügen* eine *SELECT-Anweisung aus*, um die festgeschriebenen Werte abzurufen und die GraphQL-Antwortzuordnungsvorlage zu füllen.

Fügen Sie die folgende Vorlage im Abschnitt **response mapping template (Zuweisungsvorlage für Antworten)** ein:

```
$utils.toJson($utils.rds.toJsonObject($ctx.result)[1][0])
```

Da die *Anweisungen* zwei SQL-Abfragen enthalten, müssen wir das zweite Ergebnis in der Matrix, die aus der Datenbank zurückgegeben wird, wie folgt angeben: `$utils.rds.toJsonString($ctx.result))[1][0])`.

### Mutation.updatePet
<a name="mutation-updatepet"></a>

Wählen Sie im Schema-Editor in der AWS AppSync Konsole **Attach Resolver for** aus. `updatePet(input: UpdatePetInput!): Pet` Wählen Sie Ihre **RDS-Datenquelle aus**. Fügen **Sie im Abschnitt Vorlage für die Anforderungszuweisung** die folgende Vorlage hinzu.

```
{
"version": "2018-05-29",
    "statements": [
        $util.toJson("update Pets set type=:TYPE, price=:PRICE WHERE id=:ID"),
        $util.toJson("select * from Pets WHERE id = :ID")
    ],
    "variableMap": {
        ":ID": "$ctx.args.input.id",
        ":TYPE": $util.toJson($ctx.args.input.type),
        ":PRICE": $util.toJson($ctx.args.input.price)
    }
}
```

Fügen Sie im Abschnitt **Vorlage für die Antwortzuordnung** die folgende Vorlage hinzu.

```
$utils.toJson($utils.rds.toJsonObject($ctx.result)[1][0])
```

### Mutation.deletePet
<a name="mutation-deletepet"></a>

Wählen Sie im Schema-Editor in der AWS AppSync Konsole **Attach Resolver** for `deletePet(input: DeletePetInput!): Pet` aus. Wählen Sie Ihre **RDS-Datenquelle aus**. Fügen **Sie im Abschnitt Vorlage für die Anforderungszuweisung** die folgende Vorlage hinzu.

```
{
"version": "2018-05-29",
    "statements": [
        $util.toJson("select * from Pets WHERE id=:ID"),
        $util.toJson("delete from Pets WHERE id=:ID")
    ],
    "variableMap": {
        ":ID": "$ctx.args.input.id"
    }
}
```

Fügen Sie im Abschnitt **Vorlage für die Antwortzuordnung** die folgende Vorlage hinzu.

```
$utils.toJson($utils.rds.toJsonObject($ctx.result)[0][0])
```

### Query.getPet
<a name="query-getpet"></a>

Nachdem die Mutationen für Ihr Schema erstellt wurden, können Sie die drei Abfragen miteinander verbinden, um zu zeigen, wie Sie einzelne Elemente und Listen abrufen und SQL-Filter anwenden können. Wählen Sie im **Schema-Editor** in der AWS AppSync Konsole **Attach Resolver** for `getPet(id: ID!): Pet` aus. Wählen Sie Ihre **RDS-Datenquelle aus**. Fügen **Sie im Abschnitt Vorlage für die Anforderungszuweisung** die folgende Vorlage hinzu.

```
{
"version": "2018-05-29",
        "statements": [
            $util.toJson("select * from Pets WHERE id=:ID")
    ],
    "variableMap": {
        ":ID": "$ctx.args.id"
    }
}
```

Fügen Sie die folgende Vorlage im Abschnitt **response mapping template (Zuweisungsvorlage für Antworten)** ein:

```
$utils.toJson($utils.rds.toJsonObject($ctx.result)[0][0])
```

### Query.listPets
<a name="query-listpets"></a>

Wählen Sie im Schema-Editor in der AWS AppSync Konsole auf der rechten Seite **Attach Resolver** for `getPet(id: ID!): Pet` aus. Wählen Sie Ihre **RDS-Datenquelle aus**. Fügen **Sie im Abschnitt Vorlage für die Anforderungszuweisung** die folgende Vorlage hinzu.

```
{
    "version": "2018-05-29",
    "statements": [
        "select * from Pets"
    ]
}
```

Fügen Sie im Abschnitt **Vorlage für die Antwortzuordnung** die folgende Vorlage hinzu.

```
$utils.toJson($utils.rds.toJsonObject($ctx.result)[0])
```

### Abfrage. listPetsByPriceRange
<a name="query-listpetsbypricerange"></a>

Wählen Sie im Schema-Editor in der AWS AppSync Konsole auf der rechten Seite **Attach Resolver** for `getPet(id: ID!): Pet` aus. Wählen Sie Ihre **RDS-Datenquelle aus**. Fügen **Sie im Abschnitt Vorlage für die Anforderungszuweisung** die folgende Vorlage hinzu.

```
{
    "version": "2018-05-29",
    "statements": [
            "select * from Pets where price > :MIN and price < :MAX"
    ],

    "variableMap": {
        ":MAX": $util.toJson($ctx.args.max),
        ":MIN": $util.toJson($ctx.args.min)
    }
}
```

Fügen Sie die folgende Vorlage im Abschnitt **response mapping template (Zuweisungsvorlage für Antworten)** ein:

```
$utils.toJson($utils.rds.toJsonObject($ctx.result)[0])
```

## Ändern Sie Ihre Daten über die API
<a name="run-mutations"></a>

Nachdem Sie nun alle Resolver mit SQL-Anweisungen konfiguriert und Ihre GraphQL-API Ihrer Aurora Serverless-Daten-API zugewiesen haben, können Sie damit beginnen, Mutationen und Abfragen durchzuführen. Wählen Sie in der AWS AppSync Konsole den Tab **Abfragen** und geben Sie Folgendes ein, um ein Haustier zu erstellen:

```
mutation add {
    createPet(input : { type:fish, price:10.0 }){
        id
        type
        price
    }
}
```

Die Antwort enthält die *ID*, den *Typ* und den *Preis*. Beispiel:

```
{
  "data": {
    "createPet": {
      "id": "c6fedbbe-57ad-4da3-860a-ffe8d039882a",
      "type": "fish",
      "price": "10.0"
    }
  }
}
```

Sie können dieses Element verändern, indem Sie die Mutation *updatePet* ausführen:

```
mutation update {
    updatePet(input : {
        id: ID_PLACEHOLDER,
        type:bird,
        price:50.0
    }){
        id
        type
        price
    }
}
```

Beachten Sie, dass wir die *id* verwendet haben, die von der vorherigen *createPet*-Operation zurückgegeben wurde. Dies ist ein eindeutiger Wert für Ihren Datensatz, da der Resolver `$util.autoId()` verwendet hat. Auf ähnliche Weise können Sie einen Datensatz löschen:

```
mutation delete {
    deletePet(input : {id:ID_PLACEHOLDER}){
        id
        type
        price
    }
}
```

Erstellen Sie mit der ersten Mutation einige Datensätze mit unterschiedlichen Werten für *price* und führen Sie dann einige Abfragen aus.

## Rufen Sie Ihre Daten ab
<a name="run-queries"></a>

Verwenden Sie weiterhin auf der Registerkarte **Abfragen** der Konsole die folgende Anweisung, um alle von Ihnen erstellten Datensätze aufzulisten.

```
query allpets {
    listPets {
        id
        type
        price
    }
}
```

Nutzen Sie das SQL *WHERE-Prädikat*, das `where price > :MIN and price < :MAX` in unserer Zuordnungsvorlage für *Query enthalten war. listPetsByPriceRange*mit der folgenden GraphQL-Abfrage:

```
query petsByPriceRange {
    listPetsByPriceRange(min:1, max:11) {
        id
        type
        price
    }
}
```

Es werden nur Datensätze mit einem *Preis* über 1 \$1 und unter 10 \$1 angezeigt. Abschließend können Sie wie folgt Abfragen ausführen, um einzelne Datensätze abzurufen:

```
query onePet {
    getPet(id:ID_PLACEHOLDER){
        id
        type
        price
    }
}
```

## Schützen Sie Ihren Datenzugriff
<a name="input-sanitization"></a>

SQL Injection ist eine Sicherheitslücke in Datenbankanwendungen. Sie tritt auf, wenn Angreifer bösartigen SQL-Code über Benutzereingabefelder einfügen. Dies kann unbefugten Zugriff auf Datenbankdaten ermöglichen. Wir empfehlen Ihnen, alle Benutzereingaben vor der Verarbeitung sorgfältig zu überprüfen und zu bereinigen, um sich vor SQL-Injection-Angriffen zu schützen. `variableMap` Wenn Variablenzuordnungen nicht verwendet werden, sind Sie dafür verantwortlich, die Argumente ihrer GraphQL-Operationen zu bereinigen. Hierzu können Sie in der Anforderungszuweisungsvorlage eingabespezifische Validierungsschritte festlegen, bevor eine SQL-Anweisung für Ihre Daten-API ausgeführt wird. Sehen wir uns an, wie wir die Anforderungszuweisungsvorlage des Beispiels `listPetsByPriceRange` anpassen können. Statt sich ausschließlich auf die Benutzereingabe zu verlassen, können Sie wie folgt verfahren:

```
#set($validMaxPrice = $util.matches("\d{1,3}[,\\.]?(\\d{1,2})?",$ctx.args.maxPrice))

#set($validMinPrice = $util.matches("\d{1,3}[,\\.]?(\\d{1,2})?",$ctx.args.minPrice))


#if (!$validMaxPrice || !$validMinPrice)
    $util.error("Provided price input is not valid.")
#end
{
    "version": "2018-05-29",
    "statements": [
            "select * from Pets where price > :MIN and price < :MAX"
    ],

    "variableMap": {
        ":MAX": $util.toJson($ctx.args.maxPrice),
        ":MIN": $util.toJson($ctx.args.minPrice)
    }
}
```

Eine weitere Möglichkeit zum Schutz vor nicht autorisierten Eingaben beim Ausführen der Resolver gegen Ihre Daten-API bieten vorbereitete Anweisungen mit gespeicherter Prozedur und parametrisierten Eingaben. Beispiel: Definieren Sie im Resolver `listPets` die folgende Prozedur, die *Select* als vorbereitete Anweisung ausführt:

```
CREATE PROCEDURE listPets (IN type_param VARCHAR(200))
  BEGIN
     PREPARE stmt FROM 'SELECT * FROM Pets where type=?';
     SET @type = type_param;
     EXECUTE stmt USING @type;
     DEALLOCATE PREPARE stmt;
  END
```

Erstellen Sie dies in Ihrer Aurora Serverless v2-Instance.

```
aws rds-data execute-statement --resource-arn "arn:aws:rds:us-east-1:xxxxxxxxxxxx:cluster:http-endpoint-test" \
--schema "mysql"  --secret-arn "arn:aws:secretsmanager:us-east-1:xxxxxxxxxxxx:secret:httpendpoint-xxxxxx"  \
--region us-east-1  --database "DB_NAME" \
--sql "CREATE PROCEDURE listPets (IN type_param VARCHAR(200)) BEGIN PREPARE stmt FROM 'SELECT * FROM Pets where type=?'; SET @type = type_param; EXECUTE stmt USING @type; DEALLOCATE PREPARE stmt; END"
```

Der resultierende Resolver-Code für listPets wird vereinfacht, da wir jetzt einfach die gespeicherte Prozedur aufrufen. Als Mindestanforderung müssen bei jeder Zeichenfolgeneingabe einfache Anführungszeichen [durch Escape-Zeichen geschützt sein](#escaped).

```
#set ($validType = $util.isString($ctx.args.type) && !$util.isNullOrBlank($ctx.args.type))
#if (!$validType)
    $util.error("Input for 'type' is not valid.", "ValidationError")
#end

{
    "version": "2018-05-29",
    "statements": [
        "CALL listPets(:type)"
    ]
    "variableMap": {
        ":type": $util.toJson($ctx.args.type.replace("'", "''"))
    }
}
```

### Verwenden von Escape-Zeichenketten
<a name="escaped"></a>

Verwenden Sie einfache Anführungszeichen, um den Anfang und das Ende von Zeichenkettenliteralen in einer SQL-Anweisung zu markieren, z. `'some string value'`. Damit Zeichenfolgenwerte mit einem oder mehreren einfachen Anführungszeichen (`'`) innerhalb einer Zeichenfolge verwendet werden können, muss jedes durch zwei einfache Anführungszeichen (`''`) ersetzt werden. Lautet die Eingabezeichenfolge beispielsweise `Nadia's dog`, würden Sie sie für die SQL-Anweisung wie folgt durch Escape-Zeichen schützen:

```
update Pets set type='Nadia''s dog' WHERE id='1'
```