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.
# AWS AppSync Private verwenden APIs
Wenn Sie Amazon Virtual Private Cloud (Amazon VPC) verwenden, können Sie AWS AppSync Private erstellen, d. h. APIs, auf die nur von einer VPC aus zugegriffen werden kann. APIs Mit einer privaten API können Sie den API-Zugriff auf Ihre internen Anwendungen einschränken und eine Verbindung zu Ihren GraphQL- und Realtime-Endpunkten herstellen, ohne Daten öffentlich zugänglich zu machen.
Um eine private Verbindung zwischen Ihrer VPC und dem AWS AppSync Service herzustellen, müssen Sie VPC-Schnittstellen-Endpunkte erstellen. Schnittstellenendpunkte werden mit Strom versorgt [AWS PrivateLink](https://aws.amazon.com/privatelink), sodass Sie AWS AppSync APIs ohne Internet-Gateway, NAT-Gerät, VPN-Verbindung oder Verbindung privat darauf zugreifen können. Direct Connect Instances in Ihrer VPC benötigen keine öffentlichen IP-Adressen für die Kommunikation. AWS AppSync APIs Datenverkehr zwischen Ihrer VPC und verlässt das AWS Netzwerk AWS AppSync nicht.
AWS AppSync unterstützt sowohl AWS PrivateLink den Betrieb auf der Datenebene als auch auf der Steuerebene:
+ **Endpunkt der Datenebene** (`com.amazonaws.{region}.appsync-api`): Bietet privaten Zugriff auf Ihr GraphQL und Echtzeit APIs für Abfragen, Mutationen und Abonnements.
+ **Endpunkt der Steuerungsebene** (`com.amazonaws.{region}.appsync`): Ermöglicht privaten Zugriff auf AWS AppSync Verwaltungsvorgänge wie das Erstellen APIs, Aktualisieren von Schemas und Konfigurieren von Datenquellen.
![\[AWS Cloud architecture showing VPC with public and private subnets connecting to AWS AppSync via PrivateLink.\]](http://docs.aws.amazon.com/de_de/appsync/latest/devguide/images/private-api-architecture.png)
Vor der Aktivierung der Funktionen der privaten API müssen einige zusätzliche Faktoren berücksichtigt werden:
+ Durch die Einrichtung von VPC-Schnittstellenendpunkten für AWS AppSync aktivierte private DNS-Funktionen wird verhindert, dass Ressourcen in der VPC APIs mithilfe der generierten API-URL andere AWS AppSync öffentliche Daten aufrufen können. AWS AppSync Dies liegt daran, dass die Anfrage an die öffentliche API über den Schnittstellenendpunkt weitergeleitet wird, was öffentlich nicht zulässig ist. APIs Um APIs in diesem Szenario public aufzurufen, wird empfohlen, benutzerdefinierte Domainnamen auf public zu konfigurieren APIs, die dann von Ressourcen in der VPC zum Aufrufen der öffentlichen API verwendet werden können.
+ APIs Ihr AWS AppSync Privatkonto ist nur in Ihrer VPC verfügbar. Der Abfrage-Editor der AWS AppSync Konsole kann Ihre API nur erreichen, wenn die Netzwerkkonfiguration Ihres Browsers den Datenverkehr zu Ihrer VPC weiterleiten kann (z. B. Verbindung über VPN oder über Direct Connect).
+ Mit einem VPC-Schnittstellenendpunkt für AWS AppSync können Sie auf jede private API in demselben AWS Konto und derselben Region zugreifen. Um den Zugriff auf Private weiter einzuschränken APIs, können Sie die folgenden Optionen in Betracht ziehen:
+ Stellen Sie sicher, dass nur die erforderlichen Administratoren VPC-Endpunktschnittstellen für AWS AppSync erstellen können.
+ Verwenden von benutzerdefinierten VPC-Endpunktrichtlinien, um einzuschränken, welche von Ressourcen in der VPC aufgerufen werden APIs können.
+ Für Ressourcen in der VPC empfehlen wir, die IAM-Autorisierung zum Aufrufen zu verwenden, AWS AppSync APIs indem Sie sicherstellen, dass den Ressourcen abgegrenzte Rollen zugewiesen werden. APIs
+ Wenn Sie Richtlinien erstellen oder verwenden, die IAM-Prinzipale einschränken, müssen Sie die Methode auf oder setzen. `authorizationType` `AWS_IAM` `NONE`
## Private erstellen AWS AppSync APIs
Die folgenden Schritte zeigen Ihnen, wie Sie Private APIs im AWS AppSync Service erstellen.
**Warnung**
Sie können private API-Funktionen nur während der Erstellung der API aktivieren. Diese Einstellung kann für eine AWS AppSync API oder eine AWS AppSync private API nicht geändert werden, nachdem sie erstellt wurde.
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die [AppSync Konsole](https://console.aws.amazon.com/appsync/).
1. Wählen Sie im **Dashboard** **Create API (API erstellen)** aus.
1. Wählen Sie „**Eine API von Grund auf neu entwerfen**“ und anschließend „**Weiter**“.
1. Wähle im Abschnitt **Private API** die Option **Private API-Funktionen verwenden** aus.
1. Konfigurieren Sie die restlichen Optionen, überprüfen Sie die Daten Ihrer API und wählen Sie dann **Erstellen** aus.
Bevor Sie Ihre AWS AppSync private API verwenden können, müssen Sie Schnittstellenendpunkte für AWS AppSync in Ihrer VPC konfigurieren. Beachten Sie, dass sich sowohl die Private API als auch die VPC im selben AWS Konto und in derselben Region befinden müssen.
## Schnittstellen-Endpunkte erstellen für AWS AppSync
Sie können Schnittstellen-Endpunkte für die AWS AppSync Verwendung entweder der Amazon VPC-Konsole oder der AWS Command Line Interface ()AWS CLI erstellen. Abhängig von Ihrem Anwendungsfall müssen Sie möglicherweise einen oder beide Endpunkttypen erstellen:
+ **Endpunkt der Datenebene**: Erforderlich für den Zugriff auf Private APIs von Ihrer VPC
+ **Endpunkt der Kontrollebene**: Erforderlich für die Verwaltung von AWS AppSync Ressourcen aus Ihrer VPC mit dem oder AWS CLI SDKs
Weitere Informationen finden Sie unter [Erstellung eines Schnittstellenendpunkts](https://docs.aws.amazon.com/vpc/latest/privatelink/vpce-interface.html#create-interface-endpoint) im *Benutzerhandbuch für Amazon VPC*.
**Anmerkung**
Stellen Sie sicher, dass Sie den richtigen VPC-Endpunktdienst auswählen. Es gibt zwei für AppSync: `com.amazonaws.{region}.appsync-api` ist der Dienst für den privaten Dienst erforderlich, APIs während er für das API-Management verwendet `com.amazonaws.{region}.appsync` wird.
------
#### [ Console ]
1. Melden Sie sich auf der Seite [Endpoints](https://console.aws.amazon.com/vpc/home?#Endpoints) der Amazon VPC-Konsole an AWS-Managementkonsole und öffnen Sie sie.
1. Wählen Sie **Endpunkt erstellen** aus.
1. Vergewissern Sie sich, dass im Feld **Servicekategorie AWS ** **Dienste ausgewählt** sind.
1. Wählen Sie in der Tabelle **Dienste** einen der folgenden Dienste aus:
+ Für den Zugriff auf die Datenebene: `com.amazonaws.{region}.appsync-api`
+ Für den Zugriff auf die Steuerebene: `com.amazonaws.{region}.appsync`
Stellen Sie sicher, dass der Wert in der Spalte **Typ** lautet`Interface`.
1. Wählen Sie im Feld **VPC** eine VPC und ihre Subnetze aus.
1. Um private DNS-Funktionen für den Schnittstellenendpunkt zu aktivieren, aktivieren Sie das Kontrollkästchen **DNS-Name aktivieren**.
1. Wählen Sie im Feld **Sicherheitsgruppe** eine oder mehrere Sicherheitsgruppen aus.
1. Wählen Sie **Endpunkt erstellen** aus.
1. Wiederholen Sie den Vorgang, um bei Bedarf den zweiten Endpunkttyp zu erstellen.
------
#### [ CLI ]
Verwenden Sie den `[create-vpc-endpoint](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-vpc-endpoint.html)`-Befehl und geben Sie die VPC-ID an, den VPC-Endpunkttyp (Schnittstelle), den Servicenamen, die Subnetze, die den Endpunkt verwenden sollen, sowie die Sicherheitsgruppen, die den Endpunktnetzwerkschnittstellen zugeordnet werden sollen.
**Endpunkt der Datenebene erstellen:**
```
$ aws ec2 create-vpc-endpoint —vpc-id vpc-ec43eb89 \
—vpc-endpoint-type Interface \
—service-name com.amazonaws.{region}.appsync-api \
—subnet-id subnet-abababab —security-group-id sg-1a2b3c4d
```
**Endpunkt der Steuerungsebene erstellen:**
```
$ aws ec2 create-vpc-endpoint —vpc-id vpc-ec43eb89 \
—vpc-endpoint-type Interface \
—service-name com.amazonaws.{region}.appsync \
—subnet-id subnet-abababab —security-group-id sg-1a2b3c4d
```
------
Um die private DNS-Option zu verwenden, müssen Sie die `enableDnsSupportattributes` Werte `enableDnsHostnames` und für Ihre VPC festlegen. Weitere Informationen finden Sie unter [Anzeigen und Aktualisieren der DNS-Unterstützung für Ihre VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-updating) im *Amazon-VPC-Benutzerhandbuch*. Wenn Sie private DNS-Funktionen für den Schnittstellenendpunkt aktivieren, können Sie mithilfe der standardmäßigen öffentlichen DNS-Endpunkte Anfragen an Ihren AWS AppSync API-GraphQL- und Echtzeit-Endpunkt stellen. Verwenden Sie dazu das folgende Format:
```
https://{api_url_identifier}.appsync-api.{region}.amazonaws.com/graphql
```
Für den Betrieb auf der Kontrollebene können Sie den AWS AppSync Standarddienstendpunkt verwenden:
```
https://appsync.{region}.amazonaws.com
```
Weitere Informationen zu Dienstendpunkten finden Sie unter [Dienstendpunkte und Kontingente](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) in der *AWS Allgemeinen* Referenz.
Weitere Informationen zu Serviceinteraktionen mit Schnittstellenendpunkten finden Sie unter [Zugreifen auf einen Service über einen Schnittstellenendpunkt](https://docs.aws.amazon.com/vpc/latest/privatelink/vpce-interface.html#access-service-though-endpoint) im *Amazon VPC-Benutzerhandbuch*.
*Informationen zum Erstellen und Konfigurieren eines Endpunkts mithilfe AWS CloudFormation von finden Sie in der VPCEndpoint Ressource [AWS: :EC2::](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcendpoint.html) im Benutzerhandbuch.AWS CloudFormation *
## Fortschrittliche -Beispiele
Wenn Sie private DNS-Funktionen für den Schnittstellenendpunkt aktivieren, können Sie mithilfe der standardmäßigen öffentlichen DNS-Endpunkte Anfragen an Ihren AWS AppSync API-GraphQL- und Echtzeit-Endpunkt stellen. Verwenden Sie dazu das folgende Format:
```
https://{api_url_identifier}.appsync-api.{region}.amazonaws.com/graphql
```
Unter Verwendung der öffentlichen DNS-Hostnamen des VPC-Endpunkts der Schnittstelle hat die Basis-URL zum Aufrufen der API das folgende Format:
```
https://{vpc_endpoint_id}-{endpoint_dns_identifier}.appsync-api.{region}.vpce.amazonaws.com/graphql
```
Sie können auch den AZ-spezifischen DNS-Hostnamen verwenden, wenn Sie einen Endpunkt in der AZ bereitgestellt haben:
```
https://{vpc_endpoint_id}-{endpoint_dns_identifier}-{az_id}.appsync-api.{region}.vpce.amazonaws.com/graphql.
```
Wenn Sie den öffentlichen DNS-Namen des VPC-Endpunkts verwenden, muss der Hostname des AWS AppSync API-Endpunkts als `Host` oder als ` x-appsync-domain` Header an die Anfrage übergeben werden. In diesen Beispielen wird ein verwendet`TodoAPI`, das im Leitfaden [Launch a sample schema](https://docs.aws.amazon.com/appsync/latest/devguide/quickstart-launch-a-sample-schema.html) erstellt wurde:
```
curl https://{vpc_endpoint_id}-{endpoint_dns_identifier}.appsync-api.{region}.vpce.amazonaws.com/graphql \
-H "Content-Type:application/graphql" \
-H "x-api-key:da2-{xxxxxxxxxxxxxxxxxxxxxxxxxx}" \
-H "Host:{api_url_identifier}.appsync-api.{region}.amazonaws.com" \
-d '{"query":"mutation add($createtodoinput: CreateTodoInput!) {\n createTodo(input: $createtodoinput) {\n id\n name\n where\n when\n description\n }\n}","variables":{"createtodoinput":{"name":"My first GraphQL task","when":"Friday Night","where":"Day 1","description":"Learn more about GraphQL"}}}'
```
In den folgenden Beispielen verwenden wir die *Todo-App*, die im Leitfaden [Launch a sample schema](https://docs.aws.amazon.com/appsync/latest/devguide/quickstart-launch-a-sample-schema.html) generiert wurde. Um die Todo-Beispiel-API zu testen, werden wir das Private DNS verwenden, um die API aufzurufen. Sie können jedes Befehlszeilentool Ihrer Wahl verwenden. In diesem Beispiel wird [curl](https://curl.se/) zum Senden von Abfragen und Mutationen und [wscat](https://www.npmjs.com/package/wscat) zum Einrichten von Abonnements verwendet. Um unser Beispiel zu emulieren, ersetzen Sie die Werte in Klammern `{ }` in den folgenden Befehlen durch die entsprechenden Werte aus Ihrem Konto. AWS
**Mutationsoperation testen — Anfrage `createTodo`**
```
curl https://{api_url_identifier}.appsync-api.{region}.amazonaws.com/graphql \
-H "Content-Type:application/graphql" \
-H "x-api-key:da2-{xxxxxxxxxxxxxxxxxxxxxxxxxx}" \
-d '{"query":"mutation add($createtodoinput: CreateTodoInput!) {\n createTodo(input: $createtodoinput) {\n id\n name\n where\n when\n description\n }\n}","variables":{"createtodoinput":{"name":"My first GraphQL task","when":"Friday Night","where":"Day 1","description":"Learn more about GraphQL"}}}'
```
**Mutationsoperation testen — `createTodo` Antwort**
```
{
"data": {
"createTodo": {
"id": "",
"name": "My first GraphQL task",
"where": "Day 1",
"when": "Friday Night",
"description": "Learn more about GraphQL"
}
}
}
```
**Abfragevorgang testen — `listTodos` Anfrage**
```
curl https://{api_url_identifier}.appsync-api.{region}.amazonaws.com/graphql \
-H "Content-Type:application/graphql" \
-H "x-api-key:da2-{xxxxxxxxxxxxxxxxxxxxxxxxxx}" \
-d '{"query":"query ListTodos {\n listTodos {\n items {\n description\n id\n name\n when\n where\n }\n }\n}\n","variables":{"createtodoinput":{"name":"My first GraphQL task","when":"Friday Night","where":"Day 1","description":"Learn more about GraphQL"}}}'
```
**Abfragevorgang testen — `listTodos` Anfrage**
```
{
"data": {
"listTodos": {
"items": [
{
"description": "Learn more about GraphQL",
"id": "",
"name": "My first GraphQL task",
"when": "Friday night",
"where": "Day 1"
}
]
}
}
}
```
**Testen des Abonnementvorgangs — Mutation abonnieren `createTodo`**
Informationen zum Einrichten von GraphQL-Abonnements finden Sie unter [Erstellen eines WebSocket Echtzeitclients](https://docs.aws.amazon.com/appsync/latest/devguide/real-time-websocket-client.html). AWS AppSync[Von einer Amazon EC2 EC2-Instance in einer VPC aus können Sie Ihren AWS AppSync privaten API-Abonnementendpunkt mit wscat testen.](https://github.com/websockets/wscat) Das folgende Beispiel verwendet eine für die Autorisierung. `API KEY`
```
$ header=`echo '{"host":"{api_url_identifier}.appsync-api.{region}.amazonaws.com","x-api-key":"da2-{xxxxxxxxxxxxxxxxxxxxxxxxxx}"}' | base64 | tr -d '\n'`
$ wscat -p 13 -s graphql-ws -c "wss://{api_url_identifier}.appsync-realtime-api.us-west-2.amazonaws.com/graphql?header=$header&payload=e30="
Connected (press CTRL+C to quit)
> {"type": "connection_init"}
< {"type":"connection_ack","payload":{"connectionTimeoutMs":300000}}
< {"type":"ka"}
> {"id":"f7a49717","payload":{"data":"{\"query\":\"subscription onCreateTodo {onCreateTodo {description id name where when}}\",\"variables\":{}}","extensions":{"authorization":{"x-api-key":"da2-{xxxxxxxxxxxxxxxxxxxxxxxxxx}","host":"{api_url_identifier}.appsync-api.{region}.amazonaws.com"}}},"type":"start"}
< {"id":"f7a49717","type":"start_ack"}
```
Verwenden Sie alternativ den Domainnamen des VPC-Endpunkts und stellen Sie sicher, dass Sie den **Host-Header** im `wscat` Befehl angeben, um den Websocket einzurichten:
```
$ header=`echo '{"host":"{api_url_identifier}.appsync-api.{region}.amazonaws.com","x-api-key":"da2-{xxxxxxxxxxxxxxxxxxxxxxxxxx}"}' | base64 | tr -d '\n'`
$ wscat -p 13 -s graphql-ws -c "wss://{vpc_endpoint_id}-{endpoint_dns_identifier}.appsync-api.{region}.vpce.amazonaws.com/graphql?header=$header&payload=e30=" --header Host:{api_url_identifier}.appsync-realtime-api.us-west-2.amazonaws.com
Connected (press CTRL+C to quit)
> {"type": "connection_init"}
< {"type":"connection_ack","payload":{"connectionTimeoutMs":300000}}
< {"type":"ka"}
> {"id":"f7a49717","payload":{"data":"{\"query\":\"subscription onCreateTodo {onCreateTodo {description id priority title}}\",\"variables\":{}}","extensions":{"authorization":{"x-api-key":"da2-{xxxxxxxxxxxxxxxxxxxxxxxxxx}","host":"{api_url_identifier}.appsync-api.{region}.amazonaws.com"}}},"type":"start"}
< {"id":"f7a49717","type":"start_ack"}
```
Führen Sie den folgenden Mutationscode aus:
```
curl https://{api_url_identifier}.appsync-api.{region}.amazonaws.com/graphql \
-H "Content-Type:application/graphql" \
-H "x-api-key:da2-{xxxxxxxxxxxxxxxxxxxxxxxxxx}" \
-d '{"query":"mutation add($createtodoinput: CreateTodoInput!) {\n createTodo(input: $createtodoinput) {\n id\n name\n where\n when\n description\n }\n}","variables":{"createtodoinput":{"name":"My first GraphQL task","when":"Friday Night","where":"Day 1","description":"Learn more about GraphQL"}}}'
```
Danach wird ein Abonnement ausgelöst und die Nachrichtenbenachrichtigung wird wie folgt angezeigt:
```
< {"id":"f7a49717","type":"data","payload":{"data":{"onCreateTodo":{"description":"Go to the shops","id":"169ce516-b7e8-4a6a-88c1-ab840184359f","priority":5,"title":"Go to the shops"}}}}
```
## Beispiele für Steuerungsebenen
Wenn der VPC-Endpunkt der Steuerungsebene konfiguriert ist, können Sie AWS AppSync Ressourcen von Ihrer VPC aus mithilfe der AWS CLI Option oder verwalten. SDKs Im Folgenden finden Sie Beispiele für gängige Operationen auf der Kontrollebene:
**Erstellen einer API mit dem AWS CLI**
```
aws appsync create-graphql-api \
--name "MyPrivateAPI" \
--authentication-type API_KEY \
--visibility PRIVATE
```
**Aktualisierung eines Schemas**
```
aws appsync start-schema-creation \
--api-id {api-id} \
--definition file://schema.graphql
```
**Eine Datenquelle erstellen**
```
aws appsync create-data-source \
--api-id {api-id} \
--name "MyDataSource" \
--type AWS_LAMBDA \
--lambda-config lambdaFunctionArn=arn:aws:lambda:{region}:{account}:function:MyFunction
```
Wenn Sie den Endpunkt der Kontrollebene mit aktiviertem privaten DNS verwenden, werden diese Befehle automatisch über Ihren VPC-Endpunkt weitergeleitet. Wenn privates DNS nicht aktiviert ist, können Sie die Endpunkt-URL angeben:
```
aws appsync create-graphql-api \
--endpoint-url https://{vpc_endpoint_id}-{endpoint_dns_identifier}.appsync.{region}.vpce.amazonaws.com \
--name "MyPrivateAPI" \
--authentication-type API_KEY \
--visibility PRIVATE
```
## Verwendung von IAM-Richtlinien zur Beschränkung der Erstellung öffentlicher APIs
AWS AppSync unterstützt [`Condition`IAM-Anweisungen](https://docs.aws.amazon.com/service-authorization/latest/reference/reference_policies_actions-resources-contextkeys.html) zur Verwendung mit Private. APIs Das `visibility` Feld kann in die IAM-Richtlinienanweisungen aufgenommen werden, um zu steuern, welche IAM-Rollen und Benutzer private und öffentliche IAM-Rollen erstellen können. `appsync:CreateGraphqlApi` APIs Dies gibt einem IAM-Administrator die Möglichkeit, eine IAM-Richtlinie zu definieren, die es einem Benutzer nur ermöglicht, eine private GraphQL-API zu erstellen. Ein Benutzer, der versucht, eine öffentliche API zu erstellen, erhält eine nicht autorisierte Nachricht.
Ein IAM-Administrator könnte beispielsweise die folgende IAM-Richtlinienerklärung erstellen, um die Erstellung von Private zu ermöglichen: APIs
```
{
"Sid": "AllowPrivateAppSyncApis",
"Effect": "Allow",
"Action": "appsync:CreateGraphqlApi",
"Resource": "*",
"Condition": {
"ForAnyValue:StringEquals": {
"appsync:Visibility": "PRIVATE"
}
}
}
```
Ein IAM-Administrator könnte auch die folgende [Dienststeuerungsrichtlinie](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps.html) hinzufügen, um zu verhindern, dass alle Benutzer in einer AWS Organisation etwas AWS AppSync APIs anderes als privat erstellen: APIs
```
{
"Sid": "BlockNonPrivateAppSyncApis",
"Effect": "Deny",
"Action": "appsync:CreateGraphqlApi",
"Resource": "*",
"Condition": {
"ForAnyValue:StringNotEquals": {
"appsync:Visibility": "PRIVATE"
}
}
}
```
## VPC-Unterstützung PrivateLink
VPC Privatelink-Support ist verfügbar in. AWS AppSync PrivateLink ermöglicht es Ihnen, einen AWS Dienst zu nutzen und mit ihm zu interagieren, ohne dass Datenverkehr das Netzwerk verlässt. AWS
AWS AppSync unterstützt sowohl AWS PrivateLink den Betrieb auf der Datenebene als auch auf der Steuerebene.
+ **VPCE-Endpunkt** (`appsync..vpce.amazonaws.com`): Ermöglicht VPC-Zugriff auf Operationen der Daten- und Steuerungsebene wie folgt:
+ **Appsync für den Betrieb auf der Kontrollebene**
+ **appsync-api** für Operationen auf Datenebene