Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Utilizzo di AWS AppSync Private APIs
Se utilizzi Amazon Virtual Private Cloud (Amazon VPC), puoi creare AWS AppSync Private APIs, a APIs cui puoi accedere solo da un VPC. Con un'API privata, puoi limitare l'accesso dell'API alle tue applicazioni interne e connetterti agli endpoint GraphQL e Realtime senza esporre i dati pubblicamente.
Per stabilire una connessione privata tra il tuo VPC e il AWS AppSync servizio, devi creare endpoint VPC di interfaccia. Gli endpoint di interfaccia sono alimentati da [AWS PrivateLink](https://aws.amazon.com/privatelink), il che consente di accedere in modo privato AWS AppSync APIs senza un gateway Internet, un dispositivo NAT, una connessione VPN o una connessione. Direct Connect Le istanze del tuo VPC non necessitano di indirizzi IP pubblici con cui comunicare. AWS AppSync APIs Il traffico tra il tuo VPC e AWS AppSync non esce dalla AWS rete.
AWS AppSync supporta AWS PrivateLink le operazioni sia sul piano dati che sul piano di controllo:
+ **Data plane endpoint** (`com.amazonaws.{region}.appsync-api`): fornisce accesso privato a GraphQL e APIs Real-time per interrogazioni, mutazioni e sottoscrizioni.
+ **Control plane endpoint** (`com.amazonaws.{region}.appsync`): fornisce l'accesso privato alle operazioni di AWS AppSync gestione come la creazione APIs, l'aggiornamento di schemi e la configurazione delle fonti di dati.
![\[Cloud AWS architecture showing VPC with public and private subnets connecting to AWS AppSync via PrivateLink.\]](http://docs.aws.amazon.com/it_it/appsync/latest/devguide/images/private-api-architecture.png)
Ci sono alcuni fattori aggiuntivi da considerare prima di abilitare le funzionalità dell'API privata:
+ La configurazione degli endpoint dell'interfaccia VPC AWS AppSync con le funzionalità DNS private abilitate impedirà alle risorse del VPC di richiamare altri AWS AppSync utenti pubblici utilizzando l'URL API generato. APIs AWS AppSync Ciò è dovuto al fatto che la richiesta all'API pubblica viene instradata tramite l'endpoint dell'interfaccia, cosa che non è consentita per il pubblico. APIs Per richiamare public APIs in questo scenario, si consiglia di configurare nomi di dominio personalizzati su public APIs, che possono quindi essere utilizzati dalle risorse nel VPC per richiamare l'API pubblica.
+ Il tuo AWS AppSync account privato APIs sarà disponibile solo dal tuo VPC. L'editor di query della AWS AppSync console sarà in grado di raggiungere l'API solo se la configurazione di rete del browser è in grado di indirizzare il traffico verso il VPC (ad esempio, connessione tramite VPN o superiore Direct Connect).
+ Con un endpoint di interfaccia VPC per AWS AppSync, puoi accedere a qualsiasi API privata nello stesso AWS account e nella stessa regione. Per limitare ulteriormente l'accesso a Private APIs, puoi prendere in considerazione le seguenti opzioni:
+ Garantire che solo gli amministratori necessari possano creare interfacce endpoint VPC per. AWS AppSync
+ Utilizzo di policy personalizzate per gli endpoint VPC per limitare quali elementi APIs possono essere richiamati dalle risorse del VPC.
+ Per le risorse nel VPC, ti consigliamo di utilizzare l'autorizzazione IAM per l'invocazione AWS AppSync APIs assicurandoti che alle risorse vengano assegnati ruoli limitati a. APIs
+ Quando si creano o si utilizzano policy che limitano i principi IAM, è necessario impostare il `authorizationType` metodo su o. `AWS_IAM` `NONE`
## Creazione di contenuti privati AWS AppSync APIs
I seguenti passaggi mostrano come creare Private APIs nel AWS AppSync servizio.
**avvertimento**
È possibile abilitare le funzionalità dell'API privata solo durante la creazione dell'API. Questa impostazione non può essere modificata su un' AWS AppSync API o un'API AWS AppSync privata dopo la sua creazione.
1. Accedi a Console di gestione AWS e apri la [AppSync console](https://console.aws.amazon.com/appsync/).
1. Nel **pannello di controllo**, scegliere **Create API (Crea API)**.
1. Scegli **Progetta un'API da zero**, quindi scegli **Avanti**.
1. Nella sezione **API privata**, scegli **Usa le funzionalità dell'API privata**.
1. Configura il resto delle opzioni, esamina i dati dell'API, quindi scegli **Crea**.
Prima di poter utilizzare l'API AWS AppSync privata, devi configurare gli endpoint di interfaccia per AWS AppSync il tuo VPC. Tieni presente che sia l'API privata che il VPC devono trovarsi nello stesso AWS account e nella stessa regione.
## Creazione di endpoint di interfaccia per AWS AppSync
Puoi creare endpoint di interfaccia per AWS AppSync utilizzare la console Amazon VPC o AWS Command Line Interface ().AWS CLI A seconda del caso d'uso, potrebbe essere necessario creare uno o entrambi i tipi di endpoint:
+ **Endpoint del piano dati**: necessario per accedere a Private APIs dal tuo VPC
+ **Endpoint Control Plane**: necessario per gestire AWS AppSync le risorse dal VPC utilizzando o AWS CLI SDKs
Per ulteriori informazioni, consultare [Creazione di un endpoint di interfaccia](https://docs.aws.amazon.com/vpc/latest/privatelink/vpce-interface.html#create-interface-endpoint) nella *Guida per l’utente di Amazon VPC*.
**Nota**
Assicurati di selezionare il servizio di endpoint VPC giusto; ce ne sono due per AppSync: `com.amazonaws.{region}.appsync-api` è quello richiesto per il servizio privato APIs mentre `com.amazonaws.{region}.appsync` viene utilizzato per la gestione delle API.
------
#### [ Console ]
1. Accedi Console di gestione AWS e apri la pagina [Endpoints](https://console.aws.amazon.com/vpc/home?#Endpoints) della console Amazon VPC.
1. Seleziona **Crea endpoint**.
1. Nel campo **Categoria di servizio**, verifica che **AWS i servizi siano selezionati**.
1. Nella tabella **Servizi**, scegli uno dei seguenti servizi:
+ Per l'accesso al piano dati: `com.amazonaws.{region}.appsync-api`
+ Per l'accesso al piano di controllo: `com.amazonaws.{region}.appsync`
Verificare che il valore della colonna **Type** sia`Interface`.
1. Nel campo **VPC, scegli un VPC** e le relative sottoreti.
1. **Per abilitare le funzionalità DNS private per l'endpoint dell'interfaccia, seleziona la casella di controllo Abilita nome DNS.**
1. Nel campo **Gruppo di sicurezza**, scegli uno o più gruppi di sicurezza.
1. Seleziona **Crea endpoint**.
1. Ripeti la procedura per creare il secondo tipo di endpoint, se necessario.
------
#### [ CLI ]
Utilizzare il comando `[create-vpc-endpoint](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-vpc-endpoint.html)` e specificare l'ID VPC, il tipo di endpoint VPC (interfaccia), il nome del servizio, le sottoreti per utilizzare l'endpoint e i gruppi di sicurezza da associare alle interfacce di rete dell'endpoint.
**Crea un endpoint del piano dati:**
```
$ 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
```
**Crea un endpoint del piano di controllo:**
```
$ 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
```
------
Per utilizzare l'opzione DNS privato, devi impostare `enableDnsSupportattributes` i valori `enableDnsHostnames` and del tuo VPC. Per ulteriori informazioni, consulta [Visualizzazione e aggiornamento del supporto DNS per il VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-updating) nella *Guida per l'utente di Amazon VPC*. Se abiliti le funzionalità DNS private per l'endpoint di interfaccia, puoi effettuare richieste all'endpoint API AWS AppSync GraphQL e Real-time utilizzando gli endpoint DNS pubblici predefiniti utilizzando il formato seguente:
```
https://{api_url_identifier}.appsync-api.{region}.amazonaws.com/graphql
```
Per le operazioni del piano di controllo, puoi utilizzare l'endpoint di servizio standard: AWS AppSync
```
https://appsync.{region}.amazonaws.com
```
*Per ulteriori informazioni sugli endpoint di servizio, vedere [Service endpoints and quotas](https://docs.aws.amazon.com/general/latest/gr/aws-service-information.html) nel General Reference.AWS *
Per ulteriori informazioni sulle interazioni dei servizi con gli endpoint di interfaccia, consulta [Accedere a un servizio tramite un endpoint di interfaccia](https://docs.aws.amazon.com/vpc/latest/privatelink/vpce-interface.html#access-service-though-endpoint) nella Amazon *VPC* User Guide.
*Per informazioni sulla creazione e configurazione di un endpoint utilizzando AWS CloudFormation, consulta la risorsa [AWS: :EC2::](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-vpcendpoint.html) nella Guida per l'utente. VPCEndpoint AWS CloudFormation *
## Esempi avanzati di
Se abiliti le funzionalità DNS private per l'endpoint di interfaccia, puoi effettuare richieste all'endpoint API AWS AppSync GraphQL e Real-time utilizzando gli endpoint DNS pubblici predefiniti utilizzando il formato seguente:
```
https://{api_url_identifier}.appsync-api.{region}.amazonaws.com/graphql
```
Utilizzando i nomi di host DNS pubblici degli endpoint VPC dell'interfaccia, l'URL di base per richiamare l'API sarà nel seguente formato:
```
https://{vpc_endpoint_id}-{endpoint_dns_identifier}.appsync-api.{region}.vpce.amazonaws.com/graphql
```
Puoi anche utilizzare il nome host DNS specifico per AZ se hai distribuito un endpoint nell'AZ:
```
https://{vpc_endpoint_id}-{endpoint_dns_identifier}-{az_id}.appsync-api.{region}.vpce.amazonaws.com/graphql.
```
L'utilizzo del nome DNS pubblico dell'endpoint VPC richiederà il passaggio del nome host dell'endpoint AWS AppSync API come `Host` o come intestazione alla richiesta. ` x-appsync-domain` [Questi esempi utilizzano uno schema creato nella `TodoAPI` guida Launch a sample schema:](https://docs.aws.amazon.com/appsync/latest/devguide/quickstart-launch-a-sample-schema.html)
```
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"}}}'
```
Negli esempi seguenti, utilizzeremo l'app *Todo* generata nella guida [allo schema di esempio Launch a](https://docs.aws.amazon.com/appsync/latest/devguide/quickstart-launch-a-sample-schema.html). Per testare l'API Todo di esempio, utilizzeremo il DNS privato per richiamare l'API. [Puoi usare qualsiasi strumento da riga di comando a tua scelta; questo esempio usa [curl](https://curl.se/) per inviare domande e mutazioni e wscat per configurare gli abbonamenti.](https://www.npmjs.com/package/wscat) Per emulare il nostro esempio, sostituisci i valori tra parentesi nei comandi seguenti con i valori `{ }` corrispondenti del tuo account. AWS
**Test dell'operazione di mutazione — Richiesta `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"}}}'
```
**Test dell'operazione di mutazione — Risposta `createTodo`**
```
{
"data": {
"createTodo": {
"id": "",
"name": "My first GraphQL task",
"where": "Day 1",
"when": "Friday Night",
"description": "Learn more about GraphQL"
}
}
}
```
**Operazione di interrogazione di test — `listTodos` Richiesta**
```
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"}}}'
```
**Operazione di interrogazione di test — `listTodos` Richiesta**
```
{
"data": {
"listTodos": {
"items": [
{
"description": "Learn more about GraphQL",
"id": "",
"name": "My first GraphQL task",
"when": "Friday night",
"where": "Day 1"
}
]
}
}
}
```
**Test del funzionamento dell'abbonamento — Iscrizione alla `createTodo` mutazione**
Per configurare gli abbonamenti GraphQL in AWS AppSync, consulta [Creazione di un](https://docs.aws.amazon.com/appsync/latest/devguide/real-time-websocket-client.html) client in tempo reale. WebSocket [Da un'istanza Amazon EC2 in un VPC, puoi testare il tuo endpoint di abbonamento a AWS AppSync Private API utilizzando wscat.](https://github.com/websockets/wscat) L'esempio seguente utilizza un per l'autorizzazione. `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"}
```
In alternativa, usa il nome di dominio dell'endpoint VPC assicurandoti di specificare l'intestazione **Host** nel `wscat` comando per stabilire il websocket:
```
$ 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"}
```
Esegui il codice di mutazione seguente:
```
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"}}}'
```
Successivamente, viene attivato un abbonamento e la notifica del messaggio viene visualizzata come mostrato di seguito:
```
< {"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"}}}}
```
## Esempi di piani di controllo
Con l'endpoint VPC del piano di controllo configurato, puoi gestire AWS AppSync le risorse dall'interno del tuo VPC utilizzando o. AWS CLI SDKs Ecco alcuni esempi di operazioni comuni sul piano di controllo:
**Creazione di un'API utilizzando AWS CLI**
```
aws appsync create-graphql-api \
--name "MyPrivateAPI" \
--authentication-type API_KEY \
--visibility PRIVATE
```
**Aggiornamento di uno schema**
```
aws appsync start-schema-creation \
--api-id {api-id} \
--definition file://schema.graphql
```
**Creazione di una fonte di dati**
```
aws appsync create-data-source \
--api-id {api-id} \
--name "MyDataSource" \
--type AWS_LAMBDA \
--lambda-config lambdaFunctionArn=arn:aws:lambda:{region}:{account}:function:MyFunction
```
Quando si utilizza l'endpoint del piano di controllo con DNS privato abilitato, questi comandi verranno instradati automaticamente attraverso l'endpoint VPC. Se il DNS privato non è abilitato, puoi specificare l'URL dell'endpoint:
```
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
```
## Utilizzo delle policy IAM per limitare la creazione di API pubbliche
AWS AppSync supporta [`Condition`le istruzioni](https://docs.aws.amazon.com/service-authorization/latest/reference/reference_policies_actions-resources-contextkeys.html) IAM da utilizzare con Private APIs. Il `visibility` campo può essere incluso nelle dichiarazioni politiche di IAM per l'`appsync:CreateGraphqlApi`operazione volta a controllare quali ruoli e utenti IAM possono creare elementi privati e pubblici APIs. Ciò offre a un amministratore IAM la possibilità di definire una policy IAM che consenta solo a un utente di creare un'API GraphQL privata. Un utente che tenta di creare un'API pubblica riceverà un messaggio non autorizzato.
Ad esempio, un amministratore IAM potrebbe creare la seguente dichiarazione di policy IAM per consentire la creazione di Private: APIs
```
{
"Sid": "AllowPrivateAppSyncApis",
"Effect": "Allow",
"Action": "appsync:CreateGraphqlApi",
"Resource": "*",
"Condition": {
"ForAnyValue:StringEquals": {
"appsync:Visibility": "PRIVATE"
}
}
}
```
Un amministratore IAM può anche aggiungere la seguente [politica di controllo del servizio](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps.html) per impedire a tutti gli utenti di un' AWS organizzazione di creare qualcosa di AWS AppSync APIs diverso da Private APIs:
```
{
"Sid": "BlockNonPrivateAppSyncApis",
"Effect": "Deny",
"Action": "appsync:CreateGraphqlApi",
"Resource": "*",
"Condition": {
"ForAnyValue:StringNotEquals": {
"appsync:Visibility": "PRIVATE"
}
}
}
```
## Supporto VPC PrivateLink
Il supporto per VPC PrivateLink è disponibile in. AWS AppSync PrivateLink consente di utilizzare e interagire con un AWS Servizio senza che il traffico esca dalla rete. AWS
AWS AppSync supporta AWS PrivateLink le operazioni sia sul piano dati che sul piano di controllo.
+ **VPCE endpoint** (`appsync..vpce.amazonaws.com`): fornisce l'accesso VPC alle operazioni del piano dati e del piano di controllo come segue:
+ **appsync** per le operazioni sul piano di controllo
+ **appsync-api** per le operazioni sul piano dati