Verwenden von Aurora Serverless v2 mit AWS AppSync

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.

Richten Sie Ihren Datenbankcluster ein

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

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

Die Daten-API können Sie auf Ihrem Cluster aktivieren, indem Sie die folgende Anleitung aus der RDS-Dokumentation ausführen. Die Daten-API muss aktiviert werden, bevor sie als AppSync Datenquelle hinzugefügt werden kann.

Datenbank und Tabelle erstellen

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

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:

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

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

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.

{
        "Version": "2012-10-17",
        "Statement": [
            {
                "Effect": "Allow",
                "Action": [
                    "rds-data:DeleteItems",
                    "rds-data:ExecuteSql",
                    "rds-data:ExecuteStatement",
                    "rds-data:GetItems",
                    "rds-data:InsertItems",
                    "rds-data:UpdateItems"
                ],
                "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

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:

Mutation.createPet

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

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

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

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

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

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

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

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. listPetsByPriceRangemit der folgenden GraphQL-Abfrage:

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

Es werden nur Datensätze mit einem Preis über 1 $ und unter 10 $ 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

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.

#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

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'