Wie verwende ich AWS AppSync, um auf private Ressourcen in meiner VPC zuzugreifen?

Kurzbeschreibung

Um auf Amazon-VPC-Ressourcen von einer AWS AppSync GraphQL-API aus zuzugreifen, führe die folgenden Schritte aus:

1. Erstelle eine AWS-Lambda-Funktion, die innerhalb derselben Amazon VPC ausgeführt wird wie die Ressourcen, auf die du zugreifen möchtest.
2. Erstelle eine AWS-AppSync-API und hänge dann die Lambda-Funktion als Datenquelle an.
3. Konfiguriere das AWS-AppSync-API-Schema.
4. Schließe entweder einen Lambda-Resolver oder einen direkten Lambda-Resolver an das GraphQL-Zielfeld an.
5. Teste das GraphQL-Feld.

Wenn du eine Lambda-Funktion für die Verbindung mit privaten Subnetzen in einer Amazon VPC konfigurierst, kannst du auf die privaten Ressourcen in der Amazon VPC zugreifen. Die Ergebnisse der nachgelagerten privaten Ressourcen werden dann an die AWS-AppSync-GraphQL-API weiter- und an den Client zurückgegeben. Zu den privaten Ressourcen gehören Datenbanken, Container, private APIs, private Amazon-OpenSearch-Service-Domains oder andere private Services hinter einer Anwendung oder einem Network Load Balancer.

AWS AppSync ruft die Lambda-API über Lambda-Endpunkte für öffentliche Services auf. Die aufgerufene API wird durch den Signatur-Version-4-Signaturprozess gesichert. Dadurch kann AWS AppSync eine AWS-Identity-and-Access-Management-Rolle (IAM) mit Berechtigungen zum Aufrufen der Ziel-Lambda-Funktion übernehmen. Informationen zu Lambda-Funktionen, die für den Zugriff auf Ihre Amazon VPC konfiguriert sind, findest du unter VPC-Netzwerk für Lambda.

Hinweis:

• Es werden nur öffentliche Endpunkte von AWS AppSync unterstützt. Um dieses Problem zu umgehen, verwende Lambda-Resolver als Einstiegspunkt für Amazon-VPC-Ressourcen.
• Durch Hinzufügen einer Lambda-Funktion zwischen deinen privaten Amazon-VPC-Ressourcen und der AWS-AppSync-API wird eine neue Anwendungsebene mit einem geringen Latenzaufwand eingeführt.
• Wenn du eine Amazon VPC mit Lambda-Funktionen verwendest, fallen zusätzliche Kosten an. Weitere Informationen findest du unter Lambda – Preise.

Auflösung

Hinweis: Wenn du beim Ausführen von AWS-CLI-Befehlen Fehlermeldungen erhältst, stelle sicher, dass du die neueste AWS-CLI-Version verwendest.

Erstelle eine AWS-Lambda-Funktion, die in derselben Amazon VPC ausgeführt wird wie die Ressourcen, auf die du zugreifen möchtest

Im folgenden Beispielszenario wird ein vorhandener interner Application Load Balancer von einer Python-Lambda-Funktion aufgerufen. Ein ID-Wert wird aus dem Arguments-Parameter abgerufen, der im Ereignisobjekt übergeben wird, das der AWS-AppSync-Aufruf an Lambda sendet.

import urllib.request
import json

def lambda_handler(event, context):
  URL = 'http://XXXXXXXXXXX.us-east-1.elb.amazonaws.com/' + event['arguments']['id']  
  #Open the JSON reponse, read it, convert it to JSON object and return it
  response = urllib.request.urlopen(URL)
  raw_json = response.read()
  loaded_json = json.loads(raw_json) 
  return loaded_json

Hinweis: Bei direkten Lambda-Resolvern erhält die Funktion eine Payload, die aus dem gesamten Kontextobjekt besteht.

Beispielantwort der Lambda-Funktion:

{
  "id": "25",
  "name": "hamburger",
  "available": true
}

Erstelle eine AWS-AppSync-API und füge die Lambda-Funktion als Datenquelle hinzu

Verwenden der AWS-Managementkonsole

So erstellest du die GraphQL-API in AWS AppSync:

1. Öffne die AWS-AppSync-Konsole.
2. Wähle im Dashboard die Option API erstellen.
3. Wähle auf der Seite Erste Schritte unter Anpassen Ihrer API oder Import aus Amazon DynamoDB die Option Von Grund auf neu erstellen aus.
4. Klicke auf Starten.
5. Gib im Feld API-Name einen Namen für die API ein.
6. Wähle Erstellen aus.

Hinweis: Mit den vorherigen Schritten wird automatisch ein API-Schlüssel für die Autorisierung erstellt, der sieben Tage gültig ist. Du kannst jedoch jeden Autorisierungstyp verwenden.

So erstellest du die Lambda-Datenquelle:

1. Öffne die AWS-AppSync-Konsole.
2. Wähle Datenquellen.
3. Wähle Datenquelle erstellen.
4. Gib unter Neue Datenquelle erstellen den Datenquellennamen ein, den du definieren möchtest.
   Wähle als Datenquellentyp die Amazon-Lambda-Funktion aus.
   Wähle als Region die AWS-Region aus, die die Lambda-Funktion enthält.
   Wähle als Funktions-ARN die Funktion aus, die du erstellt hast.
5. Gib eine vorhandene Rolle an, damit AWS AppSync die Lambda-Funktion verwalten kann. Diese kannst du auch vom Assistenten erstellen lassen.
6. Wähle Erstellen.

Verwenden der AWS Command Line Interface (AWS CLI)

1.    Erstelle die GraphQL-API mit API_KEY als Standardauthentifizierungstyp für Tests:

$ aws appsync create-graphql-api --name api-name --authentication-type API_KEY

Hinweis: Ersetze den API-Namen durch den Namen deiner API.

2.    Erstelle einen API-Schlüssel:

$ aws appsync create-api-key --api-id apiId

Hinweis: Ersetze apiId durch die ID deiner API.

3.    Erstelle die IAM-Rolle, die von der Datenquelle verwendet wird, und füge dann die Vertrauensrichtlinie hinzu, mit der AWS AppSync die Rolle übernehmen kann:

$ aws iam create-role --role-name Test-Role-for-AppSync --assume-role-policy-document file://trustpolicy.json

Vertrauensrichtlinie JSON:

{
  "Version": "2012-10-17",
  "Statement": [
      {
          "Effect": "Allow",
          "Principal": {
              "Service": "appsync.amazonaws.com"
          },   
         "Action": "sts:AssumeRole"
      }
  ]
}

4.    Bette die Berechtigungsrichtlinie in die Rolle ein:

$ aws iam put-role-policy --role-name Test-Role-for-AppSync --policy-name Permissions-Policy-For-AppSync --policy-document file://permissionspolicy.json

Berechtigungsrichtlinie JSON:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "AllowFunctionInvocation",
      "Effect": "Allow",
      "Action": "lambda:InvokeFunction",
      "Resource": [
        "lambda-ARN"
      ]
    }
  ]
}

Hinweis: Ersetze die Lambda-ARN durch deine Lambda-ARN.

5.    Erstelle die Datenquelle und gib den ARN der IAM-Rolle und der Lambda-Funktion an:

$ aws appsync create-data-source --api-id apiId \
--name LambdaDataSourceName \
--type AWS_LAMBDA \
--service-role-arn IAM-role-ARN \
--lambda-config lambdaFunctionArn=Lambda-function-ARN

Hinweis: Ersetze LambdaDataSourceName durch den Namen deiner Datenquelle, apiId durch die ID deiner API, IAM-Rollen-ARNdurch den ARN deiner IAM-Rolle und Lambda-function-ARN durch den ARN deiner Lambda-Funktion.

Konfiguriere das AWS-AppSync API-Schema

Verwenden der AWS-Managementkonsole

Konfigurieren Sie die GraphQL-Schemadefinition für den Zugriff auf die Antwort der Lambda-Funktion:

1.    Öffne die AWS-AppSync-Konsole.

2.    Wähle im linken Bereich Schema.

3.    Kopiere das bereitgestellte Schema und füge es in den Editor ein.

Das folgende Beispielschema enthält eine Antwortabfrage, die Daten mit der Produkttypstruktur zurückgibt:

type Product {
    id: ID!
    name: String
    available: Boolean
}

type Query {
    response(id: ID!): Product
}

schema {
    query: Query
}

4.    Wähle Schema speichern.

Verwendung der AWS CLI

1.    Speichere das vorhergehende GraphQL-Schema als schema.graphql.

2.    Erstelle das Schema in AWS AppSync:

$ aws appsync start-schema-creation --api-id "apiId" --definition fileb://schema.graphql

Hinweis: Ersetze apiId durch die ID deiner API.

Füge entweder einen Lambda-Resolver oder einen direkten Lambda-Resolver an ein GraphQL-Feld an

Verwenden der AWS-Managementkonsole

Anhängen des Resolvers:

1. Öffne die AWS-AppSync-Konsole.
2. Scrolle auf der Seite Schema deiner API unter Resolver zur Antwortabfrage. Oder filtere nach Abfrage in den Resolvertypen.
3. Wähle neben dem Feld Antwort die Option Anhängen.
4. Wähle auf der Seite Neuen Resolver erstellen für Datenquellenname den Namen der Lambda-Datenquelle aus. Hinweis: Für das Beispielszenario wird die direkte Lambda-Integration verwendet, sodass die Konfiguration der Mapping-Vorlagen nicht erforderlich ist.
5. Wähle Resolver speichern.

Verwendung der AWS CLI

Erstelle den direkten Lambda-Resolver und gebe den Datenquellennamen aus den vorherigen Schritten an:

$ aws appsync create-resolver \
--field-name response \
--type-name Query \
--api-id "apiId" \
--data-source-name LambdaDataSourceName

Hinweis: Ersetze ApiId durch die ID deiner API und LambdaDataSourceName durch den Namen der erstellten Datenquelle.

Teste das GraphQL-Feld

So testest du das GraphQL-Feld:

1.    Öffne die AWS-AppSync-Konsole.

2.    Wähle im linken Navigationsbereich Abfragen.

3.    Entwirf deine GraphQL-Abfrage im Abfrage-Editor.

Beispiel für eine GraphQL-Abfrage:

query MyQuery {
  response(id: "1") {
    available
    name
    id
  }
}

Die vorhergehende Abfrage ruft die Produkt-ID 1 vom Application Load Balancer ab.

4.    Um die Testabfrage auszuführen, wähle Abspielen.

Beispielantwort von der API:

{
  "data": {
    "response": {
      "available": false,
      "id": "1",
      "name": "pizza"
    }
  }
}

Verwenden des Terminals

Führe die Abfrage durch Aufrufen der POST-Methode aus. Im folgenden Beispiel wird der Befehl curl verwendet:

$ curl --request POST 'https://<Grapqhl-API-endpoint>/graphql' \
--header 'Content-Type: application/graphql' \
--header 'x-api-key: api-key' \
--data-raw '{"query":"query MyQuery {\n  response(id: \"1\") {\n available\n    id\n    name\n  }\n}\n","variables":{}}'

Hinweis: Ersetze api-key durch deinen API-Schlüssel.

---

Relevante Informationen

Vereinfache den Zugriff auf mehrere Microservices mit AWS AppSync und AWS Amplify

Aufbau einer Präsenz-API mit AWS AppSync, AWS Lambda, Amazon ElastiCache und Amazon EventBridge

Bewährte Sicherheitsmethoden für AWS AppSync

Bereitgestellte Parallelität für Lambda-Funktionen