Verwenden der Introspektionsfunktion (Konsole)Verwendung der Introspektionsfunktion (API)

RDS-Introspektion

AWS AppSyncmacht das Erstellen von APIs aus vorhandenen relationalen Datenbanken einfach. Das Introspektionsprogramm kann Modelle aus Datenbanktabellen erkennen und GraphQL-Typen vorschlagen. Der Create API Wizard der AWS AppSync Konsole kann sofort eine API aus einer Aurora MySQL- oder PostgreSQL-Datenbank generieren. Er erstellt automatisch Typen und JavaScript Resolver zum Lesen und Schreiben von Daten.

AWS AppSyncbietet direkte Integration mit Amazon Aurora Aurora-Datenbanken über die Amazon RDS Data API. Anstatt eine persistente Datenbankverbindung zu benötigen, bietet die Amazon RDS-Daten-API einen sicheren HTTP-Endpunkt, AWS AppSync mit dem eine Verbindung hergestellt wird, um SQL Anweisungen auszuführen. Sie können dies verwenden, um eine relationale Datenbank-API für Ihre MySQL- und PostgreSQL-Workloads auf Aurora zu erstellen.

Das Erstellen einer API für Ihre relationale Datenbank mit hat mehrere Vorteile: AWS AppSync

Ihre Datenbank ist nicht direkt für Clients zugänglich, wodurch der Access Point von der Datenbank selbst entkoppelt wird.
Sie können speziell entwickelte APIs erstellen, die auf die Bedürfnisse verschiedener Anwendungen zugeschnitten sind, sodass keine benutzerdefinierte Geschäftslogik in Frontends erforderlich ist. Dies entspricht dem Backend-For-Frontend-Muster (BFF).
Autorisierung und Zugriffskontrolle können auf der AWS AppSync Ebene implementiert werden, wobei verschiedene Autorisierungsmodi zur Zugriffskontrolle verwendet werden. Für die Verbindung mit der Datenbank sind keine zusätzlichen Rechenressourcen erforderlich, z. B. das Hosten eines Webservers oder Proxyverbindungen.
Echtzeitfunktionen können über Abonnements hinzugefügt werden, wobei Datenmutationen AppSync automatisch an die verbundenen Clients übertragen werden.
Clients können über HTTPS eine Verbindung zur API herstellen, indem sie gemeinsame Ports wie 443 verwenden.

AWS AppSyncmacht das Erstellen von APIs aus vorhandenen relationalen Datenbanken einfach. Das Introspektionsprogramm kann Modelle aus Datenbanktabellen erkennen und GraphQL-Typen vorschlagen. Der Create API Wizard der AWS AppSync Konsole kann sofort eine API aus einer Aurora MySQL- oder PostgreSQL-Datenbank generieren. Er erstellt automatisch Typen und JavaScript Resolver zum Lesen und Schreiben von Daten.

AWS AppSyncbietet integrierte JavaScript Hilfsprogramme, um das Schreiben von SQL-Anweisungen in Resolvern zu vereinfachen. Sie können die AWS AppSync sql Tag-Vorlagen für statische Anweisungen mit dynamischen Werten oder die rds Modul-Dienstprogramme verwenden, um Anweisungen programmgesteuert zu erstellen. Weitere Informationen finden Sie in der Resolver-Funktionsreferenz für RDS-Datenquellen und integrierte Module.

Verwenden der Introspektionsfunktion (Konsole)

Ein ausführliches Tutorial und eine Anleitung für die ersten Schritte finden Sie unter Tutorial: Aurora PostgreSQL Serverless with Data API.

Mit der AWS AppSync Konsole können Sie in nur wenigen Minuten eine AWS AppSync GraphQL-API aus Ihrer vorhandenen Aurora-Datenbank erstellen, die mit der Daten-API konfiguriert ist. Dadurch wird schnell ein Betriebsschema generiert, das auf Ihrer Datenbankkonfiguration basiert. Sie können die API unverändert verwenden oder darauf aufbauen, um Funktionen hinzuzufügen.

Melden Sie sich bei der AWS Management Console an und öffnen Sie die AppSync-Konsole.
1. Wählen Sie im Dashboard Create API (API erstellen) aus.
Wählen Sie unter API-Optionen die Option GraphQL APIs, Mit einem Amazon Aurora Aurora-Cluster beginnen und dann Weiter aus.
1. Geben Sie einen API-Namen ein. Dieser wird als ID für die API in der Konsole verwendet.
2. Für Kontaktinformationen können Sie eine Kontaktstelle angeben, um einen Manager für die API zu identifizieren. Dies ist ein optionales Feld.
3. Unter Private API-Konfiguration können Sie private API-Funktionen aktivieren. Auf eine private API kann nur von einem konfigurierten VPC-Endpunkt (VPCE) aus zugegriffen werden. Weitere Informationen finden Sie unter Private APIs.
  
  Wir empfehlen, diese Funktion für dieses Beispiel nicht zu aktivieren. Wählen Sie „Weiter“, nachdem Sie Ihre Eingaben überprüft haben.
Wählen Sie auf der Datenbankseite die Option Datenbank auswählen aus.
1. Sie müssen Ihre Datenbank aus Ihrem Cluster auswählen. Der erste Schritt besteht darin, die Region auszuwählen, in der Ihr Cluster existiert.
2. Wählen Sie den Aurora-Cluster aus der Drop-down-Liste aus. Beachten Sie, dass Sie eine entsprechende Daten-API erstellt und aktiviert haben müssen, bevor Sie die Ressource verwenden können.
3. Als Nächstes müssen Sie dem Dienst die Anmeldeinformationen für Ihre Datenbank hinzufügen. Dies erfolgt hauptsächlich mitAWS Secrets Manager. Wählen Sie die Region, in der Ihr Geheimnis existiert. Weitere Informationen zum Abrufen geheimer Informationen finden Sie unter Geheimnisse finden oder Geheimnisse abrufen.
4. Fügen Sie Ihr Geheimnis aus der Drop-down-Liste hinzu. Beachten Sie, dass der Benutzer über Leseberechtigungen für Ihre Datenbank verfügen muss.

Wählen Sie Importieren aus.

AWS AppSyncbeginnt mit der Introspektion Ihrer Datenbank und entdeckt Tabellen, Spalten, Primärschlüssel und Indizes. Es prüft, ob die erkannten Tabellen in einer GraphQL-API unterstützt werden können. Beachten Sie, dass Tabellen zur Unterstützung der Erstellung neuer Zeilen einen Primärschlüssel benötigen, der mehrere Spalten verwenden kann. AWS AppSyncordnet Tabellenspalten wie folgt Typfeldern zu:

Datentyp	Feldtyp
VARCHAR	String
CHAR	String
BINARY	String
VARBINARY	String
TINYBLOB	String
TINYTEXT	String
TEXT	String
BLOB	String
MEDIUMTEXT	String
MEDIUMBLOB	String
LONGTEXT	String
LONGBLOB	String
BOOL	Boolean
BOOLEAN	Boolean
BIT	Int
TINYINT	Int
SMALLINT	Int
MEDIUMINT	Int
INT	Int
INTEGER	Int
BIGINT	Int
YEAR	Int
FLOAT	Float
DOUBLE	Float
DECIMAL	Float
DEC	Float
NUMERIC	Float
DATE	AWSDate
TIMESTAMP	String
DATETIME	String
TIME	AWSTime
JSON	AWSJson
ENUM	ENUM

Sobald die Tabellenerkennung abgeschlossen ist, wird der Datenbankbereich mit Ihren Informationen gefüllt. Im neuen Abschnitt Datenbanktabellen sind die Daten aus der Tabelle möglicherweise bereits aufgefüllt und in einen Typ für Ihr Schema konvertiert. Wenn Sie einige der erforderlichen Daten nicht sehen, können Sie nach ihnen suchen, indem Sie Tabellen hinzufügen auswählen, im angezeigten Modal auf die Kontrollkästchen für diese Typen klicken und dann Hinzufügen auswählen.

Um einen Typ aus dem Abschnitt Datenbanktabellen zu entfernen, klicken Sie auf das Kontrollkästchen neben dem Typ, den Sie entfernen möchten, und wählen Sie dann Entfernen. Die entfernten Typen werden im Modal Tabellen hinzufügen platziert, falls Sie sie später wieder hinzufügen möchten.

Beachten Sie, dass die Tabellennamen als Typnamen AWS AppSync verwendet werden, aber Sie können sie umbenennen, z. B. indem Sie einen Plural-Tabellennamen wie Filme in den Typnamen Film ändern. Um einen Typ im Abschnitt Datenbanktabellen umzubenennen, klicken Sie auf das Kontrollkästchen des Typs, den Sie umbenennen möchten, und klicken Sie dann in der Spalte Typname auf das Stiftsymbol.

Um eine Vorschau des Schemainhalts auf der Grundlage Ihrer Auswahl anzuzeigen, wählen Sie Schemavorschau. Beachten Sie, dass dieses Schema nicht leer sein darf. Sie müssen also mindestens eine Tabelle in einen Typ konvertieren lassen. Außerdem darf dieses Schema eine Größe von 1 MB nicht überschreiten.
1. Wählen Sie unter Servicerolle aus, ob Sie eine neue Servicerolle speziell für diesen Import erstellen oder eine vorhandene Rolle verwenden möchten.
Wählen Sie Weiter.
Wählen Sie als Nächstes aus, ob Sie eine schreibgeschützte API (nur Abfragen) oder eine API zum Lesen und Schreiben von Daten (mit Abfragen und Mutationen) erstellen möchten. Letzteres unterstützt auch Echtzeitabonnements, die durch Mutationen ausgelöst werden.
Wählen Sie Weiter.
Überprüfen Sie Ihre Auswahl und wählen Sie dann Create API. AWS AppSyncerstellt die API und hängt Resolver an Abfragen und Mutationen an. Die generierte API ist voll funktionsfähig und kann nach Bedarf erweitert werden.

Verwendung der Introspektionsfunktion (API)

Sie können die StartDataSourceIntrospection Introspektion-API verwenden, um Modelle in Ihrer Datenbank programmgesteuert zu erkennen. Weitere Informationen zu diesem Befehl finden Sie unter Verwenden der API. StartDataSourceIntrospection

Geben Sie zur Verwendung StartDataSourceIntrospection den Amazon-Ressourcennamen (ARN) Ihres Aurora-Clusters, den Datenbanknamen und den AWS Secrets Manager geheimen ARN an. Der Befehl startet den Introspektionsprozess. Sie können die Ergebnisse mit dem GetDataSourceIntrospection Befehl abrufen. Sie können angeben, ob der Befehl die SDL-Zeichenfolge (Storage Definition Language) für die erkannten Modelle zurückgeben soll. Dies ist nützlich, um eine SDL-Schemadefinition direkt aus den erkannten Modellen zu generieren.

Wenn Sie beispielsweise die folgende DDL-Anweisung (Data Definition Language) für eine einfache Todos Tabelle haben:


create table if not exists public.todos  
(  
id serial constraint todos_pk primary key,  
description text,  
due timestamp,  
"createdAt" timestamp default now()  
);

Sie beginnen die Introspektion mit dem Folgenden.


aws appsync start-data-source-introspection \ 
  --rds-data-api-config resourceArn=<cluster-arn>,secretArn=<secret-arn>,databaseName=database

Verwenden Sie als Nächstes den GetDataSourceIntrospection Befehl, um das Ergebnis abzurufen.


aws appsync get-data-source-introspection \
  --introspection-id a1234567-8910-abcd-efgh-identifier \
  --include-models-sdl

Dies gibt das folgende Ergebnis zurück.


{
    "introspectionId": "a1234567-8910-abcd-efgh-identifier",
    "introspectionStatus": "SUCCESS",
    "introspectionStatusDetail": null,
    "introspectionResult": {
        "models": [
            {
                "name": "todos",
                "fields": [
                    {
                        "name": "description",
                        "type": {
                            "kind": "Scalar",
                            "name": "String",
                            "type": null,
                            "values": null
                        },
                        "length": 0
                    },
                    {
                        "name": "due",
                        "type": {
                            "kind": "Scalar",
                            "name": "AWSDateTime",
                            "type": null,
                            "values": null
                        },
                        "length": 0
                    },
                    {
                        "name": "id",
                        "type": {
                            "kind": "NonNull",
                            "name": null,
                            "type": {
                                "kind": "Scalar",
                                "name": "Int",
                                "type": null,
                                "values": null
                            },
                            "values": null
                        },
                        "length": 0
                    },
                    {
                        "name": "createdAt",
                        "type": {
                            "kind": "Scalar",
                            "name": "AWSDateTime",
                            "type": null,
                            "values": null
                        },
                        "length": 0
                    }
                ],
                "primaryKey": {
                    "name": "PRIMARY_KEY",
                    "fields": [
                        "id"
                    ]
                },
                "indexes": [],
                "sdl": "type todos\n{\ndescription: String\n\ndue: AWSDateTime\n\nid: Int!\n\ncreatedAt: AW
SDateTime\n}\n"
            }
        ],
        "nextToken": null
    }
}

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

Zusammengeführte APIs

Erstellen einer Client-Anwendung