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 abbonamenti per applicazioni di dati in tempo reale in AWS AppSync
<a name="aws-appsync-real-time-data"></a>

**Importante**  
A partire dal 13 marzo 2025, puoi creare un' PubSub API in tempo reale basata su Events. WebSockets AWS AppSync Per ulteriori informazioni, consulta [Pubblicare eventi tramite WebSocket](https://docs.aws.amazon.com/appsync/latest/eventapi/publish-websocket.html) nella *AWS AppSync Events Developer Guide*.

AWS AppSyncconsente di utilizzare gli abbonamenti per implementare aggiornamenti in tempo reale delle applicazioni, notifiche push, ecc. Quando i client richiamano le operazioni di sottoscrizione GraphQL, viene stabilita e gestita automaticamente una connessione WebSocket sicura da. AWS AppSync Le applicazioni possono quindi distribuire i dati in tempo reale da una fonte di dati agli abbonati, gestendo al contempo AWS AppSync i requisiti di connessione e scalabilità dell'applicazione. Le seguenti sezioni ti mostreranno come funzionano gli abbonamenti. AWS AppSync

## Direttive di sottoscrizione allo schema GraphQL
<a name="graphql-schema-subscription-directives"></a>

Le sottoscrizioni in AWS AppSync vengono richiamate come risposta a una mutazione. Ciò significa che puoi creare qualsiasi fonte di dati in tempo AWS AppSync reale specificando una direttiva dello schema GraphQL su una mutazione.

Le librerie AWS Amplify client gestiscono automaticamente la gestione delle connessioni in abbonamento. Le librerie utilizzano pure WebSockets come protocollo di rete tra il client e il servizio.

**Nota**  
Per controllare l'autorizzazione al momento della connessione a un abbonamento, puoi utilizzare AWS Identity and Access Management (IAM) AWS Lambda, i pool di identità di Amazon Cognito o i pool di utenti Amazon Cognito per l'autorizzazione a livello di campo. Per controlli di accesso dettagliati sugli abbonamenti, puoi collegare resolver ai campi di abbonamento ed eseguire la logica utilizzando l'identità del chiamante e le fonti di dati. AWS AppSync Per ulteriori informazioni, consulta [Configurazione dell'autorizzazione e dell'autenticazione per proteggere GraphQL APIs](security-authz.md).

Le sottoscrizioni vengono attivate da mutazioni e il set di selezioni delle mutazioni viene inviato ai sottoscrittori.

L'esempio seguente mostra come usare sottoscrizioni GraphQL. Non specifica un'origine dati perché l'origine dati potrebbe essere Lambda, Amazon DynamoDB o Amazon Service. OpenSearch 

Per iniziare con gli abbonamenti, devi aggiungere un punto di ingresso dell'abbonamento allo schema come segue:

```
schema {
    query: Query
    mutation: Mutation
    subscription: Subscription
}
```

Supponiamo di avere un sito di post di blog e di voler sottoscrivere nuovi blog e le modifiche a blog esistenti. A questo scopo, aggiungere la definizione `Subscription` seguente allo schema:

```
type Subscription {
    addedPost: Post
    updatedPost: Post
    deletedPost: Post
}
```

Supponiamo inoltre di avere le mutazioni seguenti:

```
type Mutation {
    addPost(id: ID! author: String! title: String content: String url: String): Post!
    updatePost(id: ID! author: String! title: String content: String url: String ups: Int! downs: Int! expectedVersion: Int!): Post!
    deletePost(id: ID!): Post!
}
```

Puoi impostare questi campi come elementi in tempo reale aggiungendo una direttiva `@aws_subscribe(mutations: ["mutation_field_1", "mutation_field_2"])` per ognuna delle sottoscrizioni per cui vuoi ricevere notifiche, in questo modo:

```
type Subscription {
    addedPost: Post
    @aws_subscribe(mutations: ["addPost"])
    updatedPost: Post
    @aws_subscribe(mutations: ["updatePost"])
    deletedPost: Post
    @aws_subscribe(mutations: ["deletePost"])
}
```

Poiché `@aws_subscribe(mutations: ["",..,""])` richiede una serie di input di mutazione, è possibile specificare più mutazioni, che avviano una sottoscrizione. Se esegui la sottoscrizione da un client, la query GraphQL può essere simile alla seguente:

```
subscription NewPostSub {
    addedPost {
        __typename
        version
        title
        content
        author
        url
    }
}
```

Questa richiesta di sottoscrizione è necessaria per le connessioni e gli strumenti dei client.

Con il WebSockets client puro, il filtraggio del set di selezione viene eseguito per client, poiché ogni client può definire il proprio set di selezione. In questo caso, il set di selezione della sottoscrizione deve essere un sottoinsieme del set di selezione delle mutazioni. Ad esempio, un abbonamento `addedPost{author title}` collegato alla mutazione `addPost(...){id author title url version}` riceve solo l'autore e il titolo del post. Non riceve gli altri campi. Tuttavia, se per la mutazione manca l'autore nel set di selezione, il sottoscrittore ottiene un valore `null` per il campo autore (o un errore nel caso in cui il campo autore sia definito come richiesto/non-null nello schema).

Il set di selezione dell'abbonamento è essenziale quando si utilizza pure WebSockets. Se un campo non è definito in modo esplicito nell'abbonamento, AWS AppSync non restituisce il campo.

Nell'esempio precedente, le sottoscrizioni non dispongono di argomenti. Supponiamo che lo schema sia simile al seguente:

```
type Subscription {
    updatedPost(id:ID! author:String): Post
    @aws_subscribe(mutations: ["updatePost"])
}
```

In questo caso, il client definisce una sottoscrizione come segue:

```
subscription UpdatedPostSub {
    updatedPost(id:"XYZ", author:"ABC") {
        title
        content
    }
}
```

Il tipo restituito di un campo `subscription` nello schema deve corrispondere al tipo restituito del campo della mutazione corrispondente. Questo è stato mostrato nell'esempio precedente, in quanto sia `addPost` sia `addedPost` hanno restituito `Post` come tipo.

Per configurare gli abbonamenti sul client, consulta. [Creazione di un'applicazione client utilizzando il client Amplify](building-a-client-app.md)

## Utilizzo degli argomenti di sottoscrizione
<a name="using-subscription-arguments"></a>

Una parte importante dell'utilizzo degli abbonamenti GraphQL è capire quando e come utilizzare gli argomenti. È possibile apportare lievi modifiche per modificare come e quando notificare ai client le mutazioni che si sono verificate. A tale scopo, consultate lo schema di esempio tratto dal capitolo quickstart, che crea «Todos». Per questo schema di esempio, vengono definite le seguenti mutazioni:

```
type Mutation {
    createTodo(input: CreateTodoInput!): Todo
    updateTodo(input: UpdateTodoInput!): Todo
    deleteTodo(input: DeleteTodoInput!): Todo
}
```

Nell'esempio predefinito, i client possono sottoscrivere gli aggiornamenti di any `Todo` utilizzando il comando `onUpdateTodo` `subscription` senza argomenti:

```
subscription OnUpdateTodo {
  onUpdateTodo {
    description
    id
    name
    when
  }
}
```

Puoi filtrare i tuoi `subscription` utilizzando i relativi argomenti. Ad esempio, per attivare a solo `subscription` quando `ID` viene aggiornato un `todo` con uno specifico, specifica il `ID` valore:

```
subscription OnUpdateTodo {
  onUpdateTodo(id: "a-todo-id") {
    description
    id
    name
    when
  }
}
```

Puoi anche passare più argomenti. Ad esempio, quanto segue `subscription` dimostra come ricevere notifiche di eventuali `Todo` aggiornamenti in un luogo e in un'ora specifici:

```
subscription todosAtHome {
  onUpdateTodo(when: "tomorrow", where: "at home") {
    description
    id
    name
    when
    where
  }
}
```

Nota che tutti gli argomenti sono opzionali. Se non specifichi alcun argomento nel tuo`subscription`, sarai iscritto a tutti `Todo` gli aggiornamenti che avvengono nella tua applicazione. Tuttavia, puoi aggiornare la definizione `subscription` del campo per richiedere l'`ID`argomento. Ciò forzerebbe la risposta di uno specifico `todo` anziché di tutti i `todo` s:

```
onUpdateTodo(
  id: ID!,
  name: String,
  when: String,
  where: String,
  description: String
): Todo
```

### Il valore null dell'argomento ha un significato
<a name="argument-null-value-has-meaning"></a>

Quando si effettua una query di sottoscrizione AWS AppSync, un valore di `null` argomento filtrerà i risultati in modo diverso rispetto all'omissione completa dell'argomento.

Torniamo all'esempio di API todos in cui potremmo creare todos. Vedi lo schema di esempio tratto dal capitolo quickstart.

Modifichiamo il nostro schema per includere un nuovo `owner` campo, sul `Todo` tipo, che descriva chi è il proprietario. Il `owner` campo non è obbligatorio e può essere solo impostato`UpdateTodoInput`. Vedi la seguente versione semplificata dello schema:

```
type Todo {
  id: ID!
  name: String!
  when: String!
  where: String!
  description: String!
  owner: String
}

input CreateTodoInput {
  name: String!
  when: String!
  where: String!
  description: String!
}

input UpdateTodoInput {
  id: ID!
  name: String
  when: String
  where: String
  description: String
  owner: String
}

type Subscription {
    onUpdateTodo(
        id: ID,
        name: String,
        when: String,
        where: String,
        description: String
    ): Todo @aws_subscribe(mutations: ["updateTodo"])
}
```

Il seguente abbonamento restituisce tutti gli `Todo` aggiornamenti:

```
subscription MySubscription {
  onUpdateTodo {
    description
    id
    name
    when
    where
  }
}
```

Se modifichi la sottoscrizione precedente per aggiungere l'argomento del campo`owner: null`, ora stai facendo una domanda diversa. Questo abbonamento ora consente al cliente di ricevere una notifica di tutti gli `Todo` aggiornamenti per i quali non è stato fornito alcun proprietario.

```
subscription MySubscription {
  onUpdateTodo(owner: null) {
    description
    id
    name
    when
    where
  }
}
```

**Nota**  
**A partire dal 1° gennaio 2022, MQTT over non WebSockets è più disponibile come protocollo per gli abbonamenti GraphQL in. AWS AppSync APIs Pure WebSockets è l'unico protocollo supportato in. AWS AppSync**  
I client basati sull' AWS AppSync SDK o sulle librerie Amplify, rilasciati dopo novembre 2019, utilizzano automaticamente pure per impostazione predefinita. WebSockets L'aggiornamento dei client alla versione più recente consente loro di utilizzare il motore puro. AWS AppSync WebSockets   
Pure offre una dimensione del payload più grande (240 KB), una più ampia varietà di opzioni client e metriche WebSockets migliorate. CloudWatch Per ulteriori informazioni sull'utilizzo dei WebSocket client pure, consulta. [ WebSocket Creazione di un client in tempo reale in AWS AppSync](real-time-websocket-client.md)

# Creazione di sistemi generici con pub/sub APIs tecnologia serverless in WebSockets AWS AppSync
<a name="aws-appsync-real-time-create-generic-api-serverless-websocket"></a>

**Importante**  
A partire dal 13 marzo 2025, puoi creare un' PubSub API in tempo reale basata su WebSockets AWS AppSync Events. Per ulteriori informazioni, consulta [Pubblicare eventi tramite WebSocket](https://docs.aws.amazon.com/appsync/latest/eventapi/publish-websocket.html) nella *AWS AppSync Events Developer Guide*.

Alcune applicazioni richiedono solo che WebSocket APIs i clienti ascoltino un canale o un argomento specifico. I dati JSON generici senza una forma specifica o requisiti fortemente tipizzati possono essere inviati ai clienti che ascoltano uno di questi canali secondo uno schema di pubblicazione (pub/sub) puro e semplice.

Utilizzalo AWS AppSync per implementare soluzioni semplici pub/sub WebSocket APIs con poca o nessuna conoscenza di GraphQL in pochi minuti generando automaticamente codice GraphQL sia sul backend dell'API che sul lato client.

## Crea e configura pub-sub APIs
<a name="aws-appsync-real-time-enhanced-filtering-using-pub-sub-apis"></a>

Per iniziare, procedi come segue: 

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. Nella schermata successiva, scegli **Crea un'API in tempo reale**, quindi scegli **Avanti**.

1. Inserisci un nome descrittivo per la tua pub/sub API.

1. Puoi abilitare le funzionalità [API private](https://docs.aws.amazon.com/appsync/latest/devguide/using-private-apis.html), ma per ora ti consigliamo di tenerla disattivata. Scegli **Next (Successivo)**.

1. Puoi scegliere di generare automaticamente un' pub/sub API funzionante utilizzando WebSockets. Ti consigliamo di tenere disattivata questa funzionalità anche per ora. Scegli **Next (Successivo)**.

1. Scegli **Crea API** e attendi un paio di minuti. Nel tuo account verrà creata una nuova API AWS AppSync pub/sub preconfigurata. AWS 

L'API utilizza i AWS AppSync resolver locali integrati (per ulteriori informazioni sull'utilizzo dei [resolver locali, consulta Tutorial: Local Resolvers nella *AWS AppSync Developer Guide*) per gestire più pub/sub canali e WebSocket connessioni temporanee, che distribuiscono e filtrano automaticamente i dati ai client abbonati solo in base](https://docs.aws.amazon.com/appsync/latest/devguide/tutorial-local-resolvers-js.html) al nome del canale. Le chiamate API sono autorizzate con una chiave API.

Dopo l'implementazione dell'API, ti vengono presentati un paio di passaggi aggiuntivi per generare il codice client e integrarlo con l'applicazione client. Per un esempio su come integrare rapidamente un client, questa guida utilizzerà una semplice applicazione web React.

1. Inizia creando un'app React standard usando [NPM](https://www.npmjs.com/get-npm) sul tuo computer locale:

   ```
   $ npx create-react-app mypubsub-app 
   $ cd mypubsub-app
   ```
**Nota**  
Questo esempio utilizza le librerie [Amplify](https://docs.amplify.aws/lib/) per connettere i client all'API di backend. Tuttavia non è necessario creare un progetto Amplify CLI localmente. Sebbene React sia il client preferito in questo esempio, le librerie Amplify supportano anche i client iOS, Android e Flutter, fornendo le stesse funzionalità in questi diversi runtime. [I client Amplify supportati forniscono semplici astrazioni per interagire con i backend dell'API AWS AppSync GraphQL con poche righe di codice, incluse WebSocket funzionalità integrate completamente compatibili con il protocollo in tempo reale:AWS AppSync WebSocket ](https://docs.aws.amazon.com/appsync/latest/devguide/real-time-websocket-client.html)  

   ```
   $ npm install @aws-amplify/api
   ```

1. Nella AWS AppSync console, seleziona **JavaScript**, quindi **Scarica per scaricare** un singolo file con i dettagli di configurazione dell'API e il codice operativo GraphQL generato.

1. Copia il file scaricato `/src` nella cartella del tuo progetto React.

1. Quindi, sostituisci il contenuto del `src/App.js` file boilerplate esistente con il codice client di esempio disponibile nella console.

1. Utilizzate il seguente comando per avviare l'applicazione localmente:

   ```
   $ npm start
   ```

1. Per testare l'invio e la ricezione di dati in tempo reale, apri due finestre del browser e accedi*localhost:3000*. L'applicazione di esempio è configurata per inviare dati JSON generici a un canale codificato denominato. *robots*

1.  **In una delle finestre del browser, inserisci il seguente blob JSON nella casella di testo, quindi fai clic su Invia:** 

   ```
   {
     "robot":"r2d2",
     "planet": "tatooine"
   }
   ```

Entrambe le istanze del browser sono iscritte al *robots* canale e ricevono i dati pubblicati in tempo reale, visualizzati nella parte inferiore dell'applicazione web:

![\[Esempio di app React per API pub/sub\]](http://docs.aws.amazon.com/it_it/appsync/latest/devguide/images/pub-sub-react.png)


Tutto il codice API GraphQL necessario, inclusi lo schema, i resolver e le operazioni, viene generato automaticamente per consentire un caso d'uso generico. pub/sub Sul backend, i dati vengono pubblicati sull'endpoint in tempo reale AWS AppSync dell'utente con una mutazione GraphQL come la seguente:

```
mutation PublishData {
    publish(data: "{\"msg\": \"hello world!\"}", name: "channel") {
        data
        name
    }
}
```

Gli abbonati accedono ai dati pubblicati inviati al canale temporaneo specifico con un abbonamento GraphQL correlato:

```
subscription SubscribeToData {
    subscribe(name:"channel") {
        name
        data
    }
}
```

## Implementazione di pub-sub APIs nelle applicazioni esistenti
<a name="aws-appsync-real-time-enhanced-filtering-existing-apps"></a>

Nel caso in cui sia sufficiente implementare una funzionalità in tempo reale in un'applicazione esistente, questa configurazione pub/sub API generica può essere facilmente integrata in qualsiasi applicazione o tecnologia API. Sebbene vi siano vantaggi nell'utilizzare un singolo endpoint API per accedere, manipolare e combinare in modo sicuro i dati provenienti da una o più fonti di dati in una singola chiamata di rete con GraphQL, non è necessario convertire o ricostruire da zero un'applicazione esistente basata su REST per sfruttare le funzionalità in tempo reale di GraphQL. AWS AppSync Ad esempio, potresti avere un carico di lavoro CRUD esistente in un endpoint API separato con i client che inviano e ricevono messaggi o eventi dall'applicazione esistente all' pub/sub API generica solo in tempo reale e per pub/sub scopi. 

# Definizione di filtri di sottoscrizione avanzati in AWS AppSync
<a name="aws-appsync-real-time-enhanced-filtering"></a>

**Importante**  
A partire dal 13 marzo 2025, puoi creare un' PubSub API in tempo reale basata su WebSockets AWS AppSync Events. Per ulteriori informazioni, consulta [Pubblicare eventi tramite WebSocket](https://docs.aws.amazon.com/appsync/latest/eventapi/publish-websocket.html) nella *AWS AppSync Events Developer Guide*.

Inoltre AWS AppSync, puoi definire e abilitare la logica aziendale per il filtraggio dei dati sul backend direttamente nei resolver di sottoscrizione dell'API GraphQL utilizzando filtri che supportano operatori logici aggiuntivi. È possibile configurare questi filtri, a differenza degli argomenti di sottoscrizione definiti nella query di sottoscrizione nel client. Per ulteriori informazioni sull'utilizzo degli argomenti di sottoscrizione, vedere[Utilizzo degli argomenti di sottoscrizione](aws-appsync-real-time-data.md#using-subscription-arguments). Per un elenco degli operatori, vedere[AWS AppSync riferimento all'utilità del modello di mappatura del resolver](resolver-util-reference.md).

Ai fini di questo documento, suddividiamo il filtraggio dei dati in tempo reale nelle seguenti categorie:
+ **Filtraggio di base**: filtraggio basato su argomenti definiti dal client nella query di sottoscrizione.
+ **Filtraggio avanzato: filtraggio** basato sulla logica definita centralmente nel backend del servizio. AWS AppSync 

Le sezioni seguenti spiegano come configurare i filtri di abbonamento avanzati e ne mostrano l'uso pratico.

## Definizione degli abbonamenti nello schema GraphQL
<a name="aws-appsync-real-time-enhanced-filtering-using-subscription-filters"></a>

Per utilizzare i filtri di sottoscrizione avanzati, è necessario definire l'abbonamento nello schema GraphQL, quindi definire il filtro avanzato utilizzando un'estensione di filtro. Per illustrare come funziona il filtraggio avanzato degli abbonamenti AWS AppSync, usa il seguente schema GraphQL, che definisce un'API del sistema di gestione dei ticket, come esempio:

```
type Ticket {
	id: ID
	createdAt: AWSDateTime
	content: String
	severity: Int
	priority: Priority
	category: String
	group: String
	status: String
	
}

type Mutation {
	createTicket(input: TicketInput): Ticket
}

type Query {
	getTicket(id: ID!): Ticket
}

type Subscription {
	onSpecialTicketCreated: Ticket @aws_subscribe(mutations: ["createTicket"])
	onGroupTicketCreated(group: String!): Ticket @aws_subscribe(mutations: ["createTicket"])
}



enum Priority {
	none
	lowest
	low
	medium
	high
	highest
}

input TicketInput {
	content: String
	severity: Int
	priority: Priority
	category: String
	group: String
```

Supponete di creare una fonte di `NONE` dati per la vostra API, quindi di collegare un resolver alla mutazione utilizzando questa fonte di dati. `createTicket` I tuoi gestori potrebbero avere questo aspetto:

```
import { util } from '@aws-appsync/utils';

export function request(ctx) {
	return {
		payload: {
			id: util.autoId(),
			createdAt: util.time.nowISO8601(),
			status: 'pending',
			...ctx.args.input,
		},
	};
}

export function response(ctx) {
	return ctx.result;
}
```

**Nota**  
I filtri avanzati sono abilitati nel gestore del resolver GraphQL in un determinato abbonamento. [Per ulteriori informazioni, consulta Resolver reference.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

Per implementare il comportamento del filtro avanzato, è necessario utilizzare la `extensions.setSubscriptionFilter()` funzione per definire un'espressione di filtro valutata rispetto ai dati pubblicati da una mutazione GraphQL che potrebbe interessare i client sottoscritti. [Per ulteriori informazioni sulle estensioni di filtraggio, consulta Estensioni.](https://docs.aws.amazon.com//appsync/latest/devguide/extensions-js.html)

La sezione seguente spiega come utilizzare le estensioni di filtraggio per implementare filtri avanzati.

## Creazione di filtri di abbonamento avanzati utilizzando estensioni di filtraggio
<a name="aws-appsync-real-time-enhanced-filtering-defining-filters"></a>

I filtri avanzati sono scritti in JSON nel gestore delle risposte dei resolver dell'abbonamento. I filtri possono essere raggruppati in un elenco chiamato a. `filterGroup` I filtri vengono definiti utilizzando almeno una regola, ciascuna con campi, operatori e valori. Definiamo un nuovo resolver `onSpecialTicketCreated` che imposta un filtro avanzato. È possibile configurare più regole in un filtro che vengono valutate utilizzando la logica AND, mentre più filtri in un gruppo di filtri vengono valutati utilizzando la logica OR:

```
import { util, extensions } from '@aws-appsync/utils';

export function request(ctx) {
	// simplfy return null for the payload
	return { payload: null };
}

export function response(ctx) {
	const filter = {
		or: [
			{ severity: { ge: 7 }, priority: { in: ['high', 'medium'] } },
			{ category: { eq: 'security' }, group: { in: ['admin', 'operators'] } },
		],
	};
	extensions.setSubscriptionFilter(util.transform.toSubscriptionFilter(filter));

  // important: return null in the response
	return null;
}
```

In base ai filtri definiti nell'esempio precedente, i ticket importanti vengono automaticamente inviati ai client API sottoscritti se viene creato un ticket con:
+ `priority`livello o `high` `medium`

  AND 
+ `severity`livello maggiore o uguale a `7` (`ge`)

O 
+ `classification`biglietto impostato su `Security` 

  AND 
+ `group`assegnazione impostata su o `admin` `operators`

![\[Esempio che mostra una query di filtraggio dei ticket\]](http://docs.aws.amazon.com/it_it/appsync/latest/devguide/images/aws-priority-example.png)


I filtri definiti nel resolver di sottoscrizione (filtro avanzato) hanno la precedenza sui filtri basati solo sugli argomenti di sottoscrizione (filtro di base). [Per ulteriori informazioni sull'utilizzo degli argomenti di sottoscrizione, vedere Utilizzo degli argomenti di sottoscrizione).](https://docs.aws.amazon.com//appsync/latest/devguide/aws-appsync-real-time-data.html#using-subscription-arguments)

Se un argomento è definito e richiesto nello schema GraphQL dell'abbonamento, il filtraggio basato sull'argomento specificato avviene solo se l'argomento è definito come regola nel metodo del resolver. `extensions.setSubscriptionFilter()` Tuttavia, se non sono presenti metodi di `extensions` filtraggio nel resolver di sottoscrizione, gli argomenti definiti nel client vengono utilizzati solo per il filtraggio di base. Non è possibile utilizzare contemporaneamente il filtro di base e il filtro avanzato.

Puoi utilizzare la [`context`variabile](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html) nella logica di estensione del filtro dell'abbonamento per accedere alle informazioni contestuali sulla richiesta. Ad esempio, quando utilizzi gli autorizzatori personalizzati Amazon Cognito User Pools, OIDC o Lambda per l'autorizzazione, puoi recuperare informazioni sui tuoi utenti nel momento in cui viene stabilito l'abbonamento. `context.identity` Puoi utilizzare queste informazioni per stabilire filtri in base all'identità degli utenti.

Supponiamo ora di voler implementare il comportamento di filtro avanzato per`onGroupTicketCreated`. L'`onGroupTicketCreated`abbonamento richiede un `group` nome obbligatorio come argomento. Una volta creati, ai ticket viene assegnato automaticamente uno `pending` stato. Puoi impostare un filtro di abbonamento per ricevere solo i biglietti appena creati che appartengono al gruppo fornito:

```
import { util, extensions } from '@aws-appsync/utils';

export function request(ctx) {
	// simplfy return null for the payload
	return { payload: null };
}

export function response(ctx) {
	const filter = { group: { eq: ctx.args.group }, status: { eq: 'pending' } };
	extensions.setSubscriptionFilter(util.transform.toSubscriptionFilter(filter));

	return null;
}
```

Quando i dati vengono pubblicati utilizzando una mutazione come nell'esempio seguente:

```
mutation CreateTicket {
  createTicket(input: {priority: medium, severity: 2, group: "aws"}) {
    id
    priority
    severity
    status
    group
    createdAt
  }
}
```

I clienti abbonati attendono che i dati vengano trasmessi automaticamente non WebSockets appena viene creato un ticket con la mutazione: `createTicket`

```
subscription OnGroup {
  onGroupTicketCreated(group: "aws") {
    category
    status
    severity
    priority
    id
    group
    createdAt
    content
  }
}
```

I client possono essere sottoscritti senza argomenti perché la logica di filtraggio è implementata nel AWS AppSync servizio con un filtraggio avanzato, che semplifica il codice client. I client ricevono i dati solo se vengono soddisfatti i criteri di filtro definiti.

## Definizione di filtri avanzati per i campi dello schema annidati
<a name="aws-appsync-real-time-enhanced-filters-nested-schema-fields.title"></a>

È possibile utilizzare il filtro di sottoscrizione avanzato per filtrare i campi dello schema annidati. Supponiamo di aver modificato lo schema della sezione precedente per includere i tipi di posizione e indirizzo:

```
type Ticket {
	id: ID
	createdAt: AWSDateTime
	content: String
	severity: Int
	priority: Priority
	category: String
	group: String
	status: String
	location: ProblemLocation
}

type Mutation {
	createTicket(input: TicketInput): Ticket
}

type Query {
	getTicket(id: ID!): Ticket
}

type Subscription {
	onSpecialTicketCreated: Ticket @aws_subscribe(mutations: ["createTicket"])
	onGroupTicketCreated(group: String!): Ticket @aws_subscribe(mutations: ["createTicket"])
}

type ProblemLocation {
	address: Address
}

type Address {
	country: String
}

enum Priority {
	none
	lowest
	low
	medium
	high
	highest
}

input TicketInput {
	content: String
	severity: Int
	priority: Priority
	category: String
	group: String
	location: AWSJSON
```

Con questo schema, è possibile utilizzare un `.` separatore per rappresentare la nidificazione. L'esempio seguente aggiunge una regola di filtro per un campo dello schema annidato in. `location.address.country` L'abbonamento verrà attivato se l'indirizzo del ticket è impostato su: `USA`

```
import { util, extensions } from '@aws-appsync/utils';

export const request = (ctx) => ({ payload: null });

export function response(ctx) {
	const filter = {
		or: [
			{ severity: { ge: 7 }, priority: { in: ['high', 'medium'] } },
			{ category: { eq: 'security' }, group: { in: ['admin', 'operators'] } },
			{ 'location.address.country': { eq: 'USA' } },
		],
	};
	extensions.setSubscriptionFilter(util.transform.toSubscriptionFilter(filter));
	return null;
}
```

Nell'esempio precedente, `location` rappresenta il livello di nidificazione uno, `address` rappresenta il livello di nidificazione due e `country` rappresenta il livello di nidificazione tre, tutti separati dal separatore. `.`

Puoi testare questo abbonamento usando la mutazione: `createTicket`

```
mutation CreateTicketInUSA {
  createTicket(input: {location: "{\"address\":{\"country\":\"USA\"}}"}) {
    category
    content
    createdAt
    group
    id
    location {
      address {
        country
      }
    }
    priority
    severity
    status
  }
}
```

## Definizione di filtri avanzati dal client
<a name="aws-appsync-real-time-enhanced-filtering-defining-from-client"></a>

È possibile utilizzare il filtraggio di base in GraphQL [con](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-real-time-data.html#using-subscription-arguments) argomenti di sottoscrizione. Il client che effettua la chiamata nella query di sottoscrizione definisce i valori degli argomenti. Quando i filtri avanzati sono abilitati in un resolver di AWS AppSync sottoscrizione con il `extensions` filtro, i filtri di backend definiti nel resolver hanno la precedenza e la priorità.

Configura filtri avanzati dinamici e definiti dal client utilizzando un argomento nella sottoscrizione. `filter` Quando configuri questi filtri, devi aggiornare lo schema GraphQL in modo che rifletta il nuovo argomento:

```
...
type Subscription {
    onSpecialTicketCreated(filter: String): Ticket
        @aws_subscribe(mutations: ["createTicket"])
}
...
```

Il client può quindi inviare una richiesta di sottoscrizione come nell'esempio seguente:

```
subscription onSpecialTicketCreated($filter: String) {
     onSpecialTicketCreated(filter: $filter) {
        id
        group
        description
        priority
        severity
     }
 }
```

È possibile configurare la variabile di query come nell'esempio seguente:

```
{"filter" : "{\"severity\":{\"le\":2}}"}
```

L'utilità `util.transform.toSubscriptionFilter()` resolver può essere implementata nel modello di mappatura delle risposte all'abbonamento per applicare il filtro definito nell'argomento dell'abbonamento per ogni client:

```
import { util, extensions } from '@aws-appsync/utils';

export function request(ctx) {
	// simplfy return null for the payload
	return { payload: null };
}

export function response(ctx) {
	const filter = ctx.args.filter;
	extensions.setSubscriptionFilter(util.transform.toSubscriptionFilter(filter));
	return null;
}
```

Con questa strategia, i clienti possono definire i propri filtri che utilizzano una logica di filtraggio avanzata e operatori aggiuntivi. I filtri vengono assegnati quando un determinato client richiama la query di sottoscrizione in una connessione sicura. WebSocket [Per ulteriori informazioni sull'utilità di trasformazione per un filtraggio avanzato, incluso il formato del payload della variabile di `filter` query, consulta la panoramica sui resolver. JavaScript](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html)

## Restrizioni di filtraggio avanzate aggiuntive
<a name="aws-appsync-real-time-enhanced-filtering-additional-restrictions"></a>

Di seguito sono riportati diversi casi d'uso in cui vengono applicate restrizioni aggiuntive ai filtri avanzati:
+ I filtri avanzati non supportano il filtraggio per gli elenchi di oggetti di primo livello. In questo caso d'uso, i dati pubblicati relativi alla mutazione verranno ignorati per gli abbonamenti avanzati.
+ AWS AppSync supporta fino a cinque livelli di nidificazione. I filtri sui campi dello schema che hanno superato il quinto livello di nidificazione verranno ignorati. Prendi la risposta GraphQL qui sotto. Il `continent` field in ingresso `venue.address.country.metadata.continent` è consentito perché si tratta di un nido di livello cinque. Tuttavia, `financial` `venue.address.country.metadata.capital.financial` è un nido di livello sei, quindi il filtro non funzionerà:

  ```
  {
      "data": {
          "onCreateFilterEvent": {
              "venue": {
                  "address": {
                      "country": {
                          "metadata": {
                              "capital": {
                                  "financial": "New York"
                              },
                              "continent" : "North America"
                          }
                      },
                      "state": "WA"
                  },
                  "builtYear": 2023
              },
              "private": false,
          }
      }
  }
  ```

# Annullamento dell'iscrizione alle WebSocket connessioni utilizzando i filtri in AWS AppSync
<a name="aws-appsync-real-time-invalidation"></a>

**Importante**  
A partire dal 13 marzo 2025, puoi creare un' PubSub API in tempo reale basata su WebSockets AWS AppSync Events. Per ulteriori informazioni, consulta [Pubblicare eventi tramite WebSocket](https://docs.aws.amazon.com/appsync/latest/eventapi/publish-websocket.html) nella *AWS AppSync Events Developer Guide*.

In AWS AppSync, puoi annullare forzatamente l'iscrizione e chiudere (invalidare) una WebSocket connessione da un client connesso in base a una logica di filtro specifica. Ciò è utile in scenari relativi all'autorizzazione, ad esempio quando si rimuove un utente da un gruppo.

L'invalidazione dell'abbonamento si verifica in risposta a un payload definito in una mutazione. Ti consigliamo di considerare le mutazioni utilizzate per invalidare le connessioni di sottoscrizione come operazioni amministrative nell'API e di definire di conseguenza le autorizzazioni limitandone l'uso a un utente amministratore, un gruppo o un servizio di backend. Ad esempio, utilizzando direttive di autorizzazione dello schema come o. `@aws_auth(cognito_groups: ["Administrators"])` `@aws_iam` Per ulteriori informazioni, vedere [Utilizzo di modalità di autorizzazione aggiuntive](https://docs.aws.amazon.com/appsync/latest/devguide/security-authz.html#using-additional-authorization-modes).

I filtri di invalidazione utilizzano la stessa sintassi e logica dei filtri di sottoscrizione [avanzati](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-real-time-enhanced-filtering.html). Definite questi filtri utilizzando le seguenti utilità:
+ `extensions.invalidateSubscriptions()`— Definito nel gestore di risposte del resolver GraphQL per una mutazione.
+ `extensions.setSubscriptionInvalidationFilter()`— Definito nel gestore delle risposte del resolver GraphQL degli abbonamenti collegati alla mutazione.

[Per ulteriori informazioni sulle estensioni di filtro di invalidazione, consulta la panoramica dei resolver. JavaScript](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html)

## Utilizzo dell'invalidazione dell'abbonamento
<a name="aws-appsync-real-time-invalidation-using-invalidations"></a>

Per vedere come funziona l'invalidazione dell'abbonamento AWS AppSync, usa il seguente schema GraphQL:

```
type User {
  userId: ID!
  groupId: ID!
}
    
type Group {
  groupId: ID!
  name: String!
  members: [ID!]!
}

type GroupMessage {
  userId: ID!
  groupId: ID!
  message: String!
}

type Mutation {
    createGroupMessage(userId: ID!, groupId : ID!, message: String!): GroupMessage
    removeUserFromGroup(userId: ID!, groupId : ID!) : User @aws_iam
}

type Subscription {
    onGroupMessageCreated(userId: ID!, groupId : ID!): GroupMessage
        @aws_subscribe(mutations: ["createGroupMessage"])
}

type Query {
	none: String
}
```

Definisci un filtro di invalidazione nel codice del mutation resolver: `removeUserFromGroup`

```
import { extensions } from '@aws-appsync/utils';

export function request(ctx) {
	return { payload: null };
}

export function response(ctx) {
	const { userId, groupId } = ctx.args;
	extensions.invalidateSubscriptions({
		subscriptionField: 'onGroupMessageCreated',
		payload: { userId, groupId },
	});
	return { userId, groupId };
}
```

Quando viene richiamata la mutazione, i dati definiti nell'`payload`oggetto vengono utilizzati per annullare l'iscrizione definita in. `subscriptionField` Un filtro di invalidazione è inoltre definito nel modello di mappatura delle risposte dell'`onGroupMessageCreated`abbonamento. 

Se il `extensions.invalidateSubscriptions()` payload contiene un ID che corrisponde a quello del IDs client sottoscritto come definito nel filtro, l'abbonamento corrispondente viene annullato. Inoltre, la connessione è chiusa. WebSocket Definisci il codice del resolver di sottoscrizione per l'`onGroupMessageCreated`abbonamento:

```
import { util, extensions } from '@aws-appsync/utils';

export function request(ctx) {
	// simplfy return null for the payload
	return { payload: null };
}

export function response(ctx) {
	const filter = { groupId: { eq: ctx.args.groupId } };
	extensions.setSubscriptionFilter(util.transform.toSubscriptionFilter(filter));

	const invalidation = { groupId: { eq: ctx.args.groupId }, userId: { eq: ctx.args.userId } };
	extensions.setSubscriptionInvalidationFilter(util.transform.toSubscriptionFilter(invalidation));

	return null;
}
```

Tieni presente che il gestore della risposta alla sottoscrizione può avere sia filtri di sottoscrizione che filtri di invalidazione definiti contemporaneamente.

Ad  esempio, supponiamo che il client A iscriva un nuovo utente con l'ID `user-1` al gruppo con l'ID `group-1` utilizzando la seguente richiesta di iscrizione:

```
onGroupMessageCreated(userId : "user-1", groupId: :"group-1"){...}
```

AWS AppSync esegue il resolver di sottoscrizione, che genera filtri di sottoscrizione e invalidazione come definito nel precedente modello di mappatura delle risposte. `onGroupMessageCreated` Per il client A, i filtri di sottoscrizione consentono l'invio dei dati solo a`group-1`, mentre i filtri di invalidazione sono definiti per entrambi e. `user-1` `group-1`

Supponiamo ora che il client B sottoscriva un utente con l'ID `user-2` a un gruppo con l'ID `group-2` utilizzando la seguente richiesta di iscrizione:

```
onGroupMessageCreated(userId : "user-2", groupId: :"group-2"){...}
```

AWS AppSync esegue il resolver di sottoscrizione, che genera filtri di sottoscrizione e invalidazione. Per il client B, i filtri di sottoscrizione consentono l'invio dei dati solo a`group-2`, mentre i filtri di invalidazione sono definiti per entrambi e. `user-2` `group-2`

Quindi, supponiamo che un nuovo messaggio di gruppo con l'ID `message-1` venga creato utilizzando una richiesta di mutazione come nell'esempio seguente:

```
createGroupMessage(id: "message-1", groupId :
      "group-1", message: "test message"){...}
```

I client abbonati che corrispondono ai filtri definiti ricevono automaticamente il seguente payload di dati tramite: WebSockets

```
{
  "data": {
    "onGroupMessageCreated": {
      "id": "message-1",
      "groupId": "group-1",
      "message": "test message",
    }
  }
}
```

Il client A riceve il messaggio perché i criteri di filtraggio corrispondono al filtro di sottoscrizione definito. Tuttavia, il client B non riceve il messaggio, in quanto l'utente non ne fa parte`group-1`. Inoltre, la richiesta non corrisponde al filtro di sottoscrizione definito nel resolver di sottoscrizione.

Infine, supponiamo che `user-1` venga rimosso dall'`group-1`utilizzo della seguente richiesta di mutazione:

```
removeUserFromGroup(userId: "user-1", groupId : "group-1"){...}
```

La mutazione avvia un'invalidazione dell'abbonamento come definito nel codice del gestore della risposta del resolver. `extensions.invalidateSubscriptions()` AWS AppSync quindi annulla l'iscrizione al client A e chiude la sua connessione. WebSocket Il client B non è interessato, poiché il payload di invalidazione definito nella mutazione non corrisponde al suo utente o gruppo.

Quando AWS AppSync invalida una connessione, il client riceve un messaggio che conferma che l'iscrizione è stata annullata:

```
{
  "message": "Subscription complete."
}
```

## Utilizzo di variabili di contesto nei filtri di invalidazione delle sottoscrizioni
<a name="aws-appsync-real-time-invalidation-context"></a>

Come per i filtri di sottoscrizione avanzati, puoi utilizzare la [`context`variabile](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html) nell'estensione del filtro di invalidazione dell'abbonamento per accedere a determinati dati.

Ad esempio, è possibile configurare un indirizzo e-mail come payload di invalidazione nella mutazione, quindi confrontarlo con l'attributo email o la dichiarazione di un utente abbonato autorizzato con i pool di utenti di Amazon Cognito o OpenID Connect. Il filtro di invalidazione definito nell'invalidatore dell'`extensions.setSubscriptionInvalidationFilter()`abbonamento verifica se l'indirizzo e-mail impostato dal `extensions.invalidateSubscriptions()` payload della mutazione corrisponde all'indirizzo e-mail recuperato dal token JWT dell'utente`context.identity.claims.email`, avviando l'invalidazione.

# WebSocket Creazione di un client in tempo reale in AWS AppSync
<a name="real-time-websocket-client"></a>

**Importante**  
A partire dal 13 marzo 2025, puoi creare un' PubSub API in tempo reale basata su WebSockets AWS AppSync Events. Per ulteriori informazioni, consulta [Pubblicare eventi tramite WebSocket](https://docs.aws.amazon.com/appsync/latest/eventapi/publish-websocket.html) nella *AWS AppSync Events Developer Guide*.

AWS AppSyncil WebSocket client in tempo reale abilita gli abbonamenti GraphQL attraverso un processo in più fasi. Il client stabilisce innanzitutto una WebSocket connessione con l'endpoint AWS AppSync in tempo reale, invia un messaggio di inizializzazione della connessione e attende la conferma. Dopo una connessione riuscita, il client registra gli abbonamenti inviando messaggi di avvio con query uniche e IDs GraphQL. AWS AppSync conferma gli abbonamenti eseguiti con successo con messaggi di conferma. Il client ascolta quindi gli eventi di sottoscrizione, che vengono attivati dalle mutazioni corrispondenti. Per mantenere la connessione, AWS AppSync invia messaggi keep-alive periodici. Al termine, il client annulla la registrazione degli abbonamenti inviando messaggi di arresto. Questo sistema supporta più abbonamenti su una singola WebSocket connessione e supporta varie modalità di autorizzazione, tra cui chiavi API, pool di utenti Amazon Cognito, IAM e Lambda.

## Implementazione WebSocket client in tempo reale per gli abbonamenti GraphQL
<a name="appsynclong-real-time-websocket-client-implementation-guide-for-graphql-subscriptions"></a>

Il diagramma di sequenza e i passaggi seguenti mostrano il flusso di lavoro degli abbonamenti in tempo reale tra il WebSocket client, il client HTTP e. AWS AppSync

![\[Sequence diagram showing WebSocket client, AppSync endpoints, and HTTP client interactions for real-time subscriptions.\]](http://docs.aws.amazon.com/it_it/appsync/latest/devguide/images/realtime-client-flow.png)


1. Il client stabilisce una WebSocket connessione con l'endpoint in tempo reale. AWS AppSync Se si verifica un errore di rete, il client dovrebbe eseguire un backoff esponenziale jittered. Per ulteriori informazioni, consulta [Exponential backoff and jitter](https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/) sul blog di architettura. AWS 

1. (Facoltativo) Dopo aver stabilito correttamente la WebSocket connessione, il client invia un messaggio. `connection_init`

1. Se `connection_init` viene inviato, il client attende un `connection_ack` messaggio da AWS AppSync. Questo messaggio include un `connectionTimeoutMs` parametro, che è il tempo di attesa massimo in millisecondi per un messaggio `"ka"` (keep-alive).

1. AWS AppSync `"ka"`invia messaggi periodicamente. Il client tiene traccia dell'ora in cui ha ricevuto ogni `"ka"` messaggio. Se il client non riceve un `"ka"` messaggio entro `connectionTimeoutMs` millisecondi, deve chiudere la connessione.

1. Il client registra la sottoscrizione inviando un messaggio di sottoscrizione `start`. Una singola WebSocket connessione supporta più abbonamenti, anche se sono in modalità di autorizzazione diverse.

1. Il client attende l'invio di `start_ack` messaggi AWS AppSync per confermare l'avvenuta sottoscrizione. Se c'è un errore, AWS AppSync restituisce un `"type": "error"` messaggio.

1. Il client ascolta gli eventi di sottoscrizione, che vengono inviati dopo la chiamata di una mutazione corrispondente. Le interrogazioni e le mutazioni vengono generalmente inviate `https://` all'endpoint GraphQL AWS AppSync . Le sottoscrizioni fluiscono attraverso l'endpoint AWS AppSync in tempo reale utilizzando secure (). WebSocket `wss://`

1. Il client annulla la registrazione della sottoscrizione inviando un messaggio di sottoscrizione `stop`.

1. Dopo aver annullato la registrazione di tutti gli abbonamenti e aver verificato che non vi siano messaggi trasferiti tramite il WebSocket, il client può disconnettersi dalla connessione. WebSocket 

## Stabilisci i dettagli della stretta di mano per stabilire la connessione WebSocket
<a name="handshake-details-to-establish-the-websocket-connection"></a>

Per connettersi e avviare una stretta di mano di successo con AWS AppSync, un WebSocket client deve disporre di quanto segue:
+ L' AWS AppSync endpoint in tempo reale
+ Intestazioni: contengono informazioni relative all' AWS AppSync endpoint e all'autorizzazione. AWS AppSync supporta i seguenti tre metodi per fornire le intestazioni: 
  + Intestazioni tramite stringa di query
    + Le informazioni sull'intestazione sono codificate come una stringa base64, derivata da un oggetto JSON con stringhe. Questo oggetto JSON contiene dettagli relativi all'endpoint e all'autorizzazione. AWS AppSync Il contenuto dell'oggetto JSON varia a seconda della modalità di autorizzazione.
  + Intestazioni tramite `Sec-WebSocket-Protocol`
    + Una stringa con codifica Base64URL proveniente dall'oggetto JSON con stringhe che contiene informazioni relative all' AWS AppSyncendpoint e all'autorizzazione viene passata come protocollo nell'intestazione. `Sec-WebSocket-Protocol` Il contenuto dell'oggetto JSON varia a seconda della modalità di autorizzazione.
  + Intestazioni tramite intestazioni HTTP standard:
    + Le intestazioni possono essere passate come intestazioni HTTP standard nella richiesta di connessione, in modo simile a come vengono passate le intestazioni per le query e le mutazioni GraphQL. AWS AppSync Tuttavia, il passaggio di intestazioni tramite intestazioni HTTP standard non è supportato per le richieste di connessione API private.
+  `payload`— Stringa codificata in Base64 di. `payload` Il payload è necessario solo se le intestazioni vengono fornite utilizzando la stringa di query

Con questi requisiti, un WebSocket client può connettersi all'URL, che contiene l'endpoint in tempo reale con la stringa di query, utilizzato `graphql-ws` come protocollo. WebSocket 

### Rilevamento dell'endpoint in tempo reale dall'endpoint GraphQL
<a name="discovering-the-appsync-real-time-endpoint-from-the-appsync-graphql-endpoint"></a>

L'endpoint AWS AppSync GraphQL e l'endpoint AWS AppSync in tempo reale sono leggermente diversi nel protocollo e nel dominio. È possibile recuperare l'endpoint GraphQL utilizzando AWS Command Line Interface il AWS CLI comando (). `aws appsync get-graphql-api`

****AWS AppSync Endpoint GraphQL:****  
 `https://example1234567890000.appsync-api.us-east-1.amazonaws.com/graphql`

****AWS AppSync endpoint in tempo reale:****  
 `wss://example1234567890000.appsync-realtime-api.us-east-1.amazonaws.com/graphql`

Le applicazioni possono connettersi all'endpoint AWS AppSync GraphQL (`https://`) utilizzando qualsiasi client HTTP per query e mutazioni. Le applicazioni possono connettersi all'endpoint AWS AppSync in tempo reale (`wss://`) utilizzando qualsiasi client per le sottoscrizioni. WebSocket 

Con i nomi di dominio personalizzati, puoi interagire con entrambi gli endpoint utilizzando un unico dominio. Ad esempio, se configuri `api.example.com` come dominio personalizzato, puoi interagire con GraphQL e gli endpoint in tempo reale utilizzando questi: URLs

**AWS AppSync endpoint GraphQL di dominio personalizzato:**  
`https://api.example.com/graphql`

**AWS AppSync endpoint in tempo reale con dominio personalizzato:**  
`wss://api.example.com/graphql/realtime`

## Formato dei parametri di intestazione basato sulla modalità di autorizzazione AWS AppSync API
<a name="header-parameter-format-based-on-appsync-api-authorization-mode"></a>

Il formato dell'`header`oggetto utilizzato nella stringa di query di connessione varia a seconda della modalità di autorizzazione dell' AWS AppSync API. Il `host` campo nell'oggetto si riferisce all'endpoint AWS AppSync GraphQL, che viene utilizzato per convalidare la connessione anche se la `wss://` chiamata viene effettuata sull'endpoint in tempo reale. Per avviare l'handshake e stabilire la connessione autorizzata, `payload` deve essere un oggetto JSON vuoto. Il payload è necessario solo se le intestazioni vengono passate tramite una stringa di query.

Le sezioni seguenti mostrano i formati di intestazione per ciascuna modalità di autorizzazione.

### Chiave API
<a name="api-key"></a>

#### Intestazione della chiave API
<a name="api-key-list"></a>

**Contenuto dell'intestazione**
+  `"host": <string>`: l'host per l'endpoint AWS AppSync GraphQL o il nome di dominio personalizzato.
+  `"x-api-key": <string>`: la chiave API configurata per l' AWS AppSync API.

**Esempio**

```
{
    "host":"example1234567890000.appsync-api.us-east-1.amazonaws.com",
    "x-api-key":"da2-12345678901234567890123456"
}
```

**Intestazioni tramite stringa di query**

Innanzitutto, un oggetto JSON contenente `host` and the `x-api-key` viene convertito in una stringa. Successivamente, questa stringa viene codificata utilizzando la codifica base64. La stringa risultante con codifica base64 viene aggiunta come parametro di query denominato all' WebSocketURL per stabilire la connessione con l'endpoint `header` in tempo reale. AWS AppSync L'URL della richiesta risultante assume il formato seguente:

```
wss://example1234567890000.appsync-realtime-api.us-east-1.amazonaws.com/graphql?header=eyJob3N0IjoiZXhhbXBsZTEyMzQ1Njc4OTAwMDAuYXBwc3luYy1hcGkudXMtZWFzdC0xLmFtYXpvbmF3cy5jb20iLCJ4LWFtei1kYXRlIjoiMjAyMDA0MDFUMDAxMDEwWiIsIngtYXBpLWtleSI6ImRhMi16NHc0NHZoczV6Z2MzZHRqNXNranJsbGxqaSJ9&payload=e30=
```

È importante notare che oltre all'oggetto header con codifica base64, anche un oggetto JSON vuoto \$1\$1 è codificato in base64 e incluso come parametro di query separato denominato nell'URL. `payload` WebSocket

**Intestazioni tramite `Sec-WebSocket-Protocol`**

Un oggetto JSON contenente `host` and the `x-api-key` viene convertito in una stringa e quindi codificato utilizzando la codifica Base64url. La stringa con codifica Base64URL risultante ha il prefisso. `header-` Questa stringa con prefisso viene quindi utilizzata come nuovo sottoprotocollo oltre che nell'`Sec-WebSocket-Protocol`intestazione quando si stabilisce la connessione con l'`graphql-ws`endpoint in tempo reale. WebSocket AWS AppSync 

L'URL della richiesta risultante assume il seguente formato:

```
wss://example1234567890000.appsync-realtime-api.us-east-1.amazonaws.com/graphql
```

L'`Sec-WebSocket-Protocol`intestazione contiene il seguente valore:

```
"sec-websocket-protocol" : ["graphql-ws", "header-ewogICAgImhvc3QiOiJleGFtcGxlMTIzNDU2Nzg5MDAwMC5hcHBzeW5jLWFwaS51cy1lYXN0LTEuYW1hem9uYXdzLmNvbSIsCiAgICAieC1hcGkta2V5IjoiZGEyLTEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Igp9"]
```

**Intestazioni tramite intestazioni HTTP standard**

In questo metodo, le informazioni sull'host e sulla chiave API vengono trasmesse utilizzando intestazioni HTTP standard quando si stabilisce la WebSocket connessione con l' AWS AppSync endpoint in tempo reale. L'URL della richiesta risultante assume il seguente formato:

```
wss://example1234567890000.appsync-realtime-api.us-east-1.amazonaws.com/graphql
```

Le intestazioni della richiesta includerebbero quanto segue:

```
"sec-websocket-protocol" : ["graphql-ws"]
"host":"example1234567890000.appsync-api.us-east-1.amazonaws.com",
"x-api-key":"da2-12345678901234567890123456"
```

### Pool di utenti Amazon Cognito e OpenID Connect (OIDC)
<a name="amazon-cognito-user-pools-and-openid-connect-oidc"></a>

#### Amazon Cognito e header OIDC
<a name="amazon-cognito-user-pools-and-openid-connect-oidc-list"></a>

Contenuti dell'intestazione:
+  `"Authorization": <string>`: Un token ID JWT. L'intestazione può utilizzare uno schema [Bearer](https://datatracker.ietf.org/doc/html/rfc6750#section-2.1).
+  `"host": <string>`: l'host per l'endpoint AWS AppSync GraphQL o il nome di dominio personalizzato.

Esempio:

```
{
    "Authorization":"eyEXAMPLEiJjbG5xb3A5eW5MK09QYXIrMTJHWEFLSXBieU5WNHhsQjEXAMPLEnM2WldvPSIsImFsZyI6IlEXAMPLEn0.eyEXAMPLEiJhNmNmMjcwNy0xNjgxLTQ1NDItOWYxOC1lNjY0MTg2NjlkMzYiLCJldmVudF9pZCI6ImVkMzM5MmNkLWNjYTMtNGM2OC1hNDYyLTJlZGI3ZTNmY2FjZiIsInRva2VuX3VzZSI6ImFjY2VzcyIsInNjb3BlIjoiYXdzLmNvZ25pdG8uc2lnbmluLnVzZXIuYWRtaW4iLCJhdXRoX3RpbWUiOjE1Njk0NTc3MTgsImlzcyI6Imh0dHBzOlwvXC9jb2duaXRvLWlkcC5hcC1zb3V0aGVhc3QtMi5hbWF6b25hd3MuY29tXC9hcC1zb3V0aGVhc3QtMl83OHY0SVZibVAiLCJleHAiOjE1Njk0NjEzMjAsImlhdCI6MTU2OTQ1NzcyMCwianRpIjoiNTgzZjhmYmMtMzk2MS00YzA4LWJhZTAtYzQyY2IxMTM5NDY5IiwiY2xpZW50X2lkIjoiM3FlajVlMXZmMzd1N3RoZWw0dG91dDJkMWwiLCJ1c2VybmFtZSI6ImVsb3EXAMPLEn0.B4EXAMPLEFNpJ6ikVp7e6DRee95V6Qi-zEE2DJH7sHOl2zxYi7f-SmEGoh2AD8emxQRYajByz-rE4Jh0QOymN2Ys-ZIkMpVBTPgu-TMWDyOHhDUmUj2OP82yeZ3wlZAtr_gM4LzjXUXmI_K2yGjuXfXTaa1mvQEBG0mQfVd7SfwXB-jcv4RYVi6j25qgow9Ew52ufurPqaK-3WAKG32KpV8J4-Wejq8t0c-yA7sb8EnB551b7TU93uKRiVVK3E55Nk5ADPoam_WYE45i3s5qVAP_-InW75NUoOCGTsS8YWMfb6ecHYJ-1j-bzA27zaT9VjctXn9byNFZmEXAMPLExw",
    "host":"example1234567890000.appsync-api.us-east-1.amazonaws.com"
}
```

**Intestazioni tramite stringa di query**

Innanzitutto, un oggetto JSON contenente `host` and the `Authorization` viene convertito in una stringa. Successivamente, questa stringa viene codificata utilizzando la codifica base64. La stringa risultante con codifica base64 viene aggiunta come parametro di query denominato all' WebSocket URL per stabilire la connessione con l'endpoint `header` in tempo reale. AWS AppSync L'URL della richiesta risultante assume il formato seguente:

```
wss://example1234567890000.appsync-realtime-api.us-east-1.amazonaws.com/graphql?header=eyJBdXRob3JpemF0aW9uIjoiZXlKcmFXUWlPaUpqYkc1eGIzQTVlVzVNSzA5UVlYSXJNVEpIV0VGTFNYQmllVTVXTkhoc1FqaFBWVzlZTW5NMldsZHZQU0lzSW1Gc1p5STZJbEpUTWpVMkluMC5leUp6ZFdJaU9pSmhObU5tTWpjd055MHhOamd4TFRRMU5ESXRPV1l4T0MxbE5qWTBNVGcyTmpsa016WWlMQ0psZG1WdWRGOXBaQ0k2SW1Wa016TTVNbU5rTFdOallUTXROR00yT0MxaE5EWXlMVEpsWkdJM1pUTm1ZMkZqWmlJc0luUnZhMlZ1WDNWelpTSTZJbUZqWTJWemN5SXNJbk5qYjNCbElqb2lZWGR6TG1OdloyNXBkRzh1YzJsbmJtbHVMblZ6WlhJdVlXUnRhVzRpTENKaGRYUm9YM1JwYldVaU9qRTFOamswTlRjM01UZ3NJbWx6Y3lJNkltaDBkSEJ6T2x3dlhDOWpiMmR1YVhSdkxXbGtjQzVoY0MxemIzVjBhR1ZoYzNRdE1pNWhiV0Y2YjI1aGQzTXVZMjl0WEM5aGNDMXpiM1YwYUdWaGMzUXRNbDgzT0hZMFNWWmliVkFpTENKbGVIQWlPakUxTmprME5qRXpNakFzSW1saGRDSTZNVFUyT1RRMU56Y3lNQ3dpYW5ScElqb2lOVGd6WmpobVltTXRNemsyTVMwMFl6QTRMV0poWlRBdFl6UXlZMkl4TVRNNU5EWTVJaXdpWTJ4cFpXNTBYMmxrSWpvaU0zRmxhalZsTVhabU16ZDFOM1JvWld3MGRHOTFkREprTVd3aUxDSjFjMlZ5Ym1GdFpTSTZJbVZzYjNKNllXWmxJbjAuQjRjZEp0aDNLRk5wSjZpa1ZwN2U2RFJlZTk1VjZRaS16RUUyREpIN3NIT2wyenhZaTdmLVNtRUdvaDJBRDhlbXhRUllhakJ5ei1yRTRKaDBRT3ltTjJZcy1aSWtNcFZCVFBndS1UTVdEeU9IaERVbVVqMk9QODJ5ZVozd2xaQXRyX2dNNEx6alhVWG1JX0syeUdqdVhmWFRhYTFtdlFFQkcwbVFmVmQ3U2Z3WEItamN2NFJZVmk2ajI1cWdvdzlFdzUydWZ1clBxYUstM1dBS0czMktwVjhKNC1XZWpxOHQwYy15QTdzYjhFbkI1NTFiN1RVOTN1S1JpVlZLM0U1NU5rNUFEUG9hbV9XWUU0NWkzczVxVkFQXy1Jblc3NU5Vb09DR1RzUzhZV01mYjZlY0hZSi0xai1iekEyN3phVDlWamN0WG45YnlORlptS0xwQTJMY3h3IiwiaG9zdCI6ImV4YW1wbGUxMjM0NTY3ODkwMDAwLmFwcHN5bmMtYXBpLnVzLWVhc3QtMS5hbWF6b25hd3MuY29tIn0=&payload=e30=
```

È importante notare che oltre all'oggetto header con codifica base64, anche un oggetto JSON vuoto \$1\$1 è codificato in base64 e incluso come parametro di query separato denominato nell'URL. `payload` WebSocket

**Intestazioni tramite `Sec-WebSocket-Protocol`**

Un oggetto JSON contenente `host` and the `Authorization` viene convertito in una stringa e quindi codificato utilizzando la codifica Base64url. La stringa con codifica Base64URL risultante ha il prefisso. `header-` Questa stringa con prefisso viene quindi utilizzata come nuovo sottoprotocollo oltre che nell'`Sec-WebSocket-Protocol`intestazione quando si stabilisce la connessione con l'`graphql-ws`endpoint in tempo reale. WebSocket AWS AppSync 

L'URL della richiesta risultante assume il seguente formato:

```
wss://example1234567890000.appsync-realtime-api.us-east-1.amazonaws.com/graphql
```

L'`Sec-WebSocket-Protocol`intestazione contiene il seguente valore:

```
"sec-websocket-protocol" : ["graphql-ws", "header-ewogICAgImhvc3QiOiJleGFtcGxlMTIzNDU2Nzg5MDAwMC5hcHBzeW5jLWFwaS51cy1lYXN0LTEuYW1hem9uYXdzLmNvbSIsCiAgICAieC1hcGkta2V5IjoiZGEyLTEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Igp9"]
```

**Intestazioni tramite intestazioni HTTP standard**

In questo metodo, le informazioni sull'host e sull'autorizzazione vengono trasmesse utilizzando intestazioni HTTP standard quando si stabilisce la WebSocket connessione con l' AWS AppSync endpoint in tempo reale. L'URL della richiesta risultante assume il seguente formato:

```
wss://example1234567890000.appsync-realtime-api.us-east-1.amazonaws.com/graphql
```

Le intestazioni della richiesta includerebbero quanto segue:

```
"sec-websocket-protocol" : ["graphql-ws"]
"Authorization":"eyEXAMPLEiJjbG5xb3A5eW5MK09QYXIrMTJHWEFLSXBieU5WNHhsQjEXAMPLEnM2WldvPSIsImFsZyI6IlEXAMPLEn0.eyEXAMPLEiJhNmNmMjcwNy0xNjgxLTQ1NDItOWYxOC1lNjY0MTg2NjlkMzYiLCJldmVudF9pZCI6ImVkMzM5MmNkLWNjYTMtNGM2OC1hNDYyLTJlZGI3ZTNmY2FjZiIsInRva2VuX3VzZSI6ImFjY2VzcyIsInNjb3BlIjoiYXdzLmNvZ25pdG8uc2lnbmluLnVzZXIuYWRtaW4iLCJhdXRoX3RpbWUiOjE1Njk0NTc3MTgsImlzcyI6Imh0dHBzOlwvXC9jb2duaXRvLWlkcC5hcC1zb3V0aGVhc3QtMi5hbWF6b25hd3MuY29tXC9hcC1zb3V0aGVhc3QtMl83OHY0SVZibVAiLCJleHAiOjE1Njk0NjEzMjAsImlhdCI6MTU2OTQ1NzcyMCwianRpIjoiNTgzZjhmYmMtMzk2MS00YzA4LWJhZTAtYzQyY2IxMTM5NDY5IiwiY2xpZW50X2lkIjoiM3FlajVlMXZmMzd1N3RoZWw0dG91dDJkMWwiLCJ1c2VybmFtZSI6ImVsb3EXAMPLEn0.B4EXAMPLEFNpJ6ikVp7e6DRee95V6Qi-zEE2DJH7sHOl2zxYi7f-SmEGoh2AD8emxQRYajByz-rE4Jh0QOymN2Ys-ZIkMpVBTPgu-TMWDyOHhDUmUj2OP82yeZ3wlZAtr_gM4LzjXUXmI_K2yGjuXfXTaa1mvQEBG0mQfVd7SfwXB-jcv4RYVi6j25qgow9Ew52ufurPqaK-3WAKG32KpV8J4-Wejq8t0c-yA7sb8EnB551b7TU93uKRiVVK3E55Nk5ADPoam_WYE45i3s5qVAP_-InW75NUoOCGTsS8YWMfb6ecHYJ-1j-bzA27zaT9VjctXn9byNFZmEXAMPLExw",
"host":"example1234567890000.appsync-api.us-east-1.amazonaws.com"
```

### IAM
<a name="iam"></a>

#### Intestazione IAM
<a name="iam-list"></a>

**Contenuto dell'intestazione**
+  `"accept": "application/json, text/javascript"`: un parametro `<string>` costante.
+  `"content-encoding": "amz-1.0"`: un parametro `<string>` costante.
+  `"content-type": "application/json; charset=UTF-8"`: un parametro `<string>` costante.
+  `"host": <string>`: Questo è l'host per l'endpoint AWS AppSync GraphQL.
  + `"x-amz-date": <string>`: Il timestamp deve essere in UTC e nel seguente formato ISO 8601: YYYYMMDD'T'HHMMSS'Z'. Ad esempio, 20150830T123600Z è un timestamp valido. Non includere i millisecondi nel time stamp. Per ulteriori informazioni[, vedere Gestione delle date *Riferimenti generali di AWS*nella](https://docs.aws.amazon.com/general/latest/gr/sigv4-date-handling.html) versione 4 di Signature in.
  +  `"X-Amz-Security-Token": <string>`: Il token di AWS sessione, necessario quando si utilizzano credenziali di sicurezza temporanee. Per ulteriori informazioni, consulta [Utilizzo di credenziali temporanee con le risorse AWS](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_credentials_temp_use-resources.html) nella *Guida per l'utente IAM*.
  +  `"Authorization": <string>`: Signature Version 4 (SigV4): informazioni di firma per l'endpoint. AWS AppSync Per ulteriori informazioni sul processo di firma, vedere [Attività 4: aggiungere la firma alla richiesta HTTP](https://docs.aws.amazon.com/general/latest/gr/sigv4-add-signature-to-request.html) in. *Riferimenti generali di AWS*

La richiesta HTTP di firma Sigv4 include un URL canonico, che è l'endpoint AWS AppSync GraphQL con `/connect` aggiunto. La AWS regione dell'endpoint del servizio è la stessa regione in cui stai utilizzando l' AWS AppSync API e il nome del servizio è «appsync». La richiesta HTTP da firmare è la seguente:

```
{
  url: "https://example1234567890000.appsync-api.us-east-1.amazonaws.com/graphql/connect",
  data: "{}",
  method: "POST",
  headers: {
    "accept": "application/json, text/javascript",
    "content-encoding": "amz-1.0",
    "content-type": "application/json; charset=UTF-8",
  }
}
```

**Esempio**

```
{
  "accept": "application/json, text/javascript",
  "content-encoding": "amz-1.0",
  "content-type": "application/json; charset=UTF-8",
  "host": "example1234567890000.appsync-api.us-east-1.amazonaws.com",
  "x-amz-date": "20200401T001010Z",
  "X-Amz-Security-Token": "AgEXAMPLEZ2luX2VjEAoaDmFwLXNvdXRoZWFEXAMPLEcwRQIgAh97Cljq7wOPL8KsxP3YtDuyc/9hAj8PhJ7Fvf38SgoCIQDhJEXAMPLEPspioOztj++pEagWCveZUjKEn0zyUhBEXAMPLEjj//////////8BEXAMPLExODk2NDgyNzg1NSIMo1mWnpESWUoYw4BkKqEFSrm3DXuL8w+ZbVc4JKjDP4vUCKNR6Le9C9pZp9PsW0NoFy3vLBUdAXEXAMPLEOVG8feXfiEEA+1khgFK/wEtwR+9zF7NaMMMse07wN2gG2tH0eKMEXAMPLEQX+sMbytQo8iepP9PZOzlZsSFb/dP5Q8hk6YEXAMPLEYcKZsTkDAq2uKFQ8mYUVA9EtQnNRiFLEY83aKvG/tqLWNnGlSNVx7SMcfovkFDqQamm+88y1OwwAEYK7qcoceX6Z7GGcaYuIfGpaX2MCCELeQvZ+8WxEgOnIfz7GYvsYNjLZSaRnV4G+ILY1F0QNW64S9Nvj+BwDg3ht2CrNvpwjVYlj9U3nmxE0UG5ne83LL5hhqMpm25kmL7enVgw2kQzmU2id4IKu0C/WaoDRuO2F5zE63vJbxN8AYs7338+4B4HBb6BZ6OUgg96Q15RA41/gIqxaVPxyTpDfTU5GfSLxocdYeniqqpFMtZG2n9d0u7GsQNcFkNcG3qDZm4tDo8tZbuym0a2VcF2E5hFEgXBa+XLJCfXi/77OqAEjP0x7Qdk3B43p8KG/BaioP5RsV8zBGvH1zAgyPha2rN70/tT13yrmPd5QYEfwzexjKrV4mWIuRg8NTHYSZJUaeyCwTom80VFUJXG+GYTUyv5W22aBcnoRGiCiKEYTLOkgXecdKFTHmcIAejQ9Welr0a196Kq87w5KNMCkcCGFnwBNFLmfnbpNqT6rUBxxs3X5ntX9d8HVtSYINTsGXXMZCJ7fnbWajhg/aox0FtHX21eF6qIGT8j1z+l2opU+ggwUgkhUUgCH2TfqBj+MLMVVvpgqJsPKt582caFKArIFIvO+9QupxLnEH2hz04TMTfnU6bQC6z1buVe7h+tOLnh1YPFsLQ88anib/7TTC8k9DsBTq0ASe8R2GbSEsmO9qbbMwgEaYUhOKtGeyQsSJdhSk6XxXThrWL9EnwBCXDkICMqdntAxyyM9nWsZ4bL9JHqExgWUmfWChzPFAqn3F4y896UqHTZxlq3WGypn5HHcem2Hqf3IVxKH1inhqdVtkryEiTWrI7ZdjbqnqRbl+WgtPtKOOweDlCaRs3R2qXcbNgVhleMk4IWnF8D1695AenU1LwHjOJLkCjxgNFiWAFEPH9aEXAMPLExA==",
  "Authorization": "AWS4-HMAC-SHA256 Credential=XXXXXXXXXXXXXXXXXXX/20200401/us-east-1/appsync/aws4_request, SignedHeaders=accept;content-encoding;content-type;host;x-amz-date;x-amz-security-token, Signature=83EXAMPLEbcc1fe3ee69f75cd5ebbf4cb4f150e4f99cec869f149c5EXAMPLEdc"
}
```

**Intestazioni tramite stringa di query**

Innanzitutto, un oggetto JSON contenente `host` (endpoint AWS AppSync GraphQL) e le altre intestazioni di autorizzazione viene convertito in una stringa. Successivamente, questa stringa viene codificata utilizzando la codifica base64. La stringa con codifica base64 risultante viene aggiunta all'URL come parametro di query denominato. WebSocket `header` L'URL della richiesta risultante assume il formato seguente:

```
wss://example1234567890000.appsync-realtime-api.us-east-1.amazonaws.com/graphql?header=eyJBdXRob3JpemF0aW9uIjoiZXlKcmFXUWlPaUpqYkc1eGIzQTVlVzVNSzA5UVlYSXJNVEpIV0VGTFNYQmllVTVXTkhoc1FqaFBWVzlZTW5NMldsZHZQU0lzSW1Gc1p5STZJbEpUTWpVMkluMC5leUp6ZFdJaU9pSmhObU5tTWpjd055MHhOamd4TFRRMU5ESXRPV1l4T0MxbE5qWTBNVGcyTmpsa016WWlMQ0psZG1WdWRGOXBaQ0k2SW1Wa016TTVNbU5rTFdOallUTXROR00yT0MxaE5EWXlMVEpsWkdJM1pUTm1ZMkZqWmlJc0luUnZhMlZ1WDNWelpTSTZJbUZqWTJWemN5SXNJbk5qYjNCbElqb2lZWGR6TG1OdloyNXBkRzh1YzJsbmJtbHVMblZ6WlhJdVlXUnRhVzRpTENKaGRYUm9YM1JwYldVaU9qRTFOamswTlRjM01UZ3NJbWx6Y3lJNkltaDBkSEJ6T2x3dlhDOWpiMmR1YVhSdkxXbGtjQzVoY0MxemIzVjBhR1ZoYzNRdE1pNWhiV0Y2YjI1aGQzTXVZMjl0WEM5aGNDMXpiM1YwYUdWaGMzUXRNbDgzT0hZMFNWWmliVkFpTENKbGVIQWlPakUxTmprME5qRXpNakFzSW1saGRDSTZNVFUyT1RRMU56Y3lNQ3dpYW5ScElqb2lOVGd6WmpobVltTXRNemsyTVMwMFl6QTRMV0poWlRBdFl6UXlZMkl4TVRNNU5EWTVJaXdpWTJ4cFpXNTBYMmxrSWpvaU0zRmxhalZsTVhabU16ZDFOM1JvWld3MGRHOTFkREprTVd3aUxDSjFjMlZ5Ym1GdFpTSTZJbVZzYjNKNllXWmxJbjAuQjRjZEp0aDNLRk5wSjZpa1ZwN2U2RFJlZTk1VjZRaS16RUUyREpIN3NIT2wyenhZaTdmLVNtRUdvaDJBRDhlbXhRUllhakJ5ei1yRTRKaDBRT3ltTjJZcy1aSWtNcFZCVFBndS1UTVdEeU9IaERVbVVqMk9QODJ5ZVozd2xaQXRyX2dNNEx6alhVWG1JX0syeUdqdVhmWFRhYTFtdlFFQkcwbVFmVmQ3U2Z3WEItamN2NFJZVmk2ajI1cWdvdzlFdzUydWZ1clBxYUstM1dBS0czMktwVjhKNC1XZWpxOHQwYy15QTdzYjhFbkI1NTFiN1RVOTN1S1JpVlZLM0U1NU5rNUFEUG9hbV9XWUU0NWkzczVxVkFQXy1Jblc3NU5Vb09DR1RzUzhZV01mYjZlY0hZSi0xai1iekEyN3phVDlWamN0WG45YnlORlptS0xwQTJMY3h3IiwiaG9zdCI6ImV4YW1wbGUxMjM0NTY3ODkwMDAwLmFwcHN5bmMtYXBpLnVzLWVhc3QtMS5hbWF6b25hd3MuY29tIn0=&payload=e30=
```

È importante notare che oltre all'oggetto header con codifica base64, anche un oggetto JSON vuoto \$1\$1 è codificato in base64 e incluso come parametro di query separato denominato nell'URL. `payload` WebSocket

**Intestazioni tramite `Sec-WebSocket-Protocol`**

Un oggetto JSON contenente le `host` e le altre intestazioni di autorizzazione viene convertito in una stringa e quindi codificato utilizzando la codifica Base64URL. La stringa con codifica Base64URL risultante ha il prefisso. `header-` Questa stringa con prefisso viene quindi utilizzata come nuovo sottoprotocollo oltre che nell'`Sec-WebSocket-Protocol`intestazione quando si stabilisce la connessione con l'`graphql-ws`endpoint in tempo reale. WebSocket AWS AppSync 

L'URL della richiesta risultante assume il seguente formato:

```
wss://example1234567890000.appsync-realtime-api.us-east-1.amazonaws.com/graphql
```

L'`Sec-WebSocket-Protocol`intestazione contiene il seguente valore:

```
"sec-websocket-protocol" : ["graphql-ws", "header-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"]
```

**Intestazioni tramite intestazioni HTTP standard**

In questo metodo, l'host e le altre informazioni di autorizzazione vengono trasmesse utilizzando intestazioni HTTP standard quando si stabilisce la WebSocket connessione con l' AWS AppSync endpoint in tempo reale. L'URL della richiesta risultante assume il seguente formato:

```
wss://example1234567890000.appsync-realtime-api.us-east-1.amazonaws.com/graphql
```

Le intestazioni della richiesta includerebbero quanto segue:

```
"sec-websocket-protocol" : ["graphql-ws"]
"accept": "application/json, text/javascript",
"content-encoding": "amz-1.0",
"content-type": "application/json; charset=UTF-8",
"host": "example1234567890000.appsync-api.us-east-1.amazonaws.com",
"x-amz-date": "20200401T001010Z",
"X-Amz-Security-Token": "AgEXAMPLEZ2luX2VjEAoaDmFwLXNvdXRoZWFEXAMPLEcwRQIgAh97Cljq7wOPL8KsxP3YtDuyc/9hAj8PhJ7Fvf38SgoCIQDhJEXAMPLEPspioOztj++pEagWCveZUjKEn0zyUhBEXAMPLEjj//////////8BEXAMPLExODk2NDgyNzg1NSIMo1mWnpESWUoYw4BkKqEFSrm3DXuL8w+ZbVc4JKjDP4vUCKNR6Le9C9pZp9PsW0NoFy3vLBUdAXEXAMPLEOVG8feXfiEEA+1khgFK/wEtwR+9zF7NaMMMse07wN2gG2tH0eKMEXAMPLEQX+sMbytQo8iepP9PZOzlZsSFb/dP5Q8hk6YEXAMPLEYcKZsTkDAq2uKFQ8mYUVA9EtQnNRiFLEY83aKvG/tqLWNnGlSNVx7SMcfovkFDqQamm+88y1OwwAEYK7qcoceX6Z7GGcaYuIfGpaX2MCCELeQvZ+8WxEgOnIfz7GYvsYNjLZSaRnV4G+ILY1F0QNW64S9Nvj+BwDg3ht2CrNvpwjVYlj9U3nmxE0UG5ne83LL5hhqMpm25kmL7enVgw2kQzmU2id4IKu0C/WaoDRuO2F5zE63vJbxN8AYs7338+4B4HBb6BZ6OUgg96Q15RA41/gIqxaVPxyTpDfTU5GfSLxocdYeniqqpFMtZG2n9d0u7GsQNcFkNcG3qDZm4tDo8tZbuym0a2VcF2E5hFEgXBa+XLJCfXi/77OqAEjP0x7Qdk3B43p8KG/BaioP5RsV8zBGvH1zAgyPha2rN70/tT13yrmPd5QYEfwzexjKrV4mWIuRg8NTHYSZJUaeyCwTom80VFUJXG+GYTUyv5W22aBcnoRGiCiKEYTLOkgXecdKFTHmcIAejQ9Welr0a196Kq87w5KNMCkcCGFnwBNFLmfnbpNqT6rUBxxs3X5ntX9d8HVtSYINTsGXXMZCJ7fnbWajhg/aox0FtHX21eF6qIGT8j1z+l2opU+ggwUgkhUUgCH2TfqBj+MLMVVvpgqJsPKt582caFKArIFIvO+9QupxLnEH2hz04TMTfnU6bQC6z1buVe7h+tOLnh1YPFsLQ88anib/7TTC8k9DsBTq0ASe8R2GbSEsmO9qbbMwgEaYUhOKtGeyQsSJdhSk6XxXThrWL9EnwBCXDkICMqdntAxyyM9nWsZ4bL9JHqExgWUmfWChzPFAqn3F4y896UqHTZxlq3WGypn5HHcem2Hqf3IVxKH1inhqdVtkryEiTWrI7ZdjbqnqRbl+WgtPtKOOweDlCaRs3R2qXcbNgVhleMk4IWnF8D1695AenU1LwHjOJLkCjxgNFiWAFEPH9aEXAMPLExA==",
"Authorization": "AWS4-HMAC-SHA256 Credential=XXXXXXXXXXXXXXXXXXX/20200401/us-east-1/appsync/aws4_request, SignedHeaders=accept;content-encoding;content-type;host;x-amz-date;x-amz-security-token, Signature=83EXAMPLEbcc1fe3ee69f75cd5ebbf4cb4f150e4f99cec869f149c5EXAMPLEdc"
```

Per firmare la richiesta utilizzando un dominio personalizzato:

```
{
  url: "https://api.example.com/graphql/connect",
  data: "{}",
  method: "POST",
  headers: {
    "accept": "application/json, text/javascript",
    "content-encoding": "amz-1.0",
    "content-type": "application/json; charset=UTF-8",
  }
}
```

**Esempio**

```
{
  "accept": "application/json, text/javascript",
  "content-encoding": "amz-1.0",
  "content-type": "application/json; charset=UTF-8",
  "host": "api.example.com",
  "x-amz-date": "20200401T001010Z",
  "X-Amz-Security-Token": "AgEXAMPLEZ2luX2VjEAoaDmFwLXNvdXRoZWFEXAMPLEcwRQIgAh97Cljq7wOPL8KsxP3YtDuyc/9hAj8PhJ7Fvf38SgoCIQDhJEXAMPLEPspioOztj++pEagWCveZUjKEn0zyUhBEXAMPLEjj//////////8BEXAMPLExODk2NDgyNzg1NSIMo1mWnpESWUoYw4BkKqEFSrm3DXuL8w+ZbVc4JKjDP4vUCKNR6Le9C9pZp9PsW0NoFy3vLBUdAXEXAMPLEOVG8feXfiEEA+1khgFK/wEtwR+9zF7NaMMMse07wN2gG2tH0eKMEXAMPLEQX+sMbytQo8iepP9PZOzlZsSFb/dP5Q8hk6YEXAMPLEYcKZsTkDAq2uKFQ8mYUVA9EtQnNRiFLEY83aKvG/tqLWNnGlSNVx7SMcfovkFDqQamm+88y1OwwAEYK7qcoceX6Z7GGcaYuIfGpaX2MCCELeQvZ+8WxEgOnIfz7GYvsYNjLZSaRnV4G+ILY1F0QNW64S9Nvj+BwDg3ht2CrNvpwjVYlj9U3nmxE0UG5ne83LL5hhqMpm25kmL7enVgw2kQzmU2id4IKu0C/WaoDRuO2F5zE63vJbxN8AYs7338+4B4HBb6BZ6OUgg96Q15RA41/gIqxaVPxyTpDfTU5GfSLxocdYeniqqpFMtZG2n9d0u7GsQNcFkNcG3qDZm4tDo8tZbuym0a2VcF2E5hFEgXBa+XLJCfXi/77OqAEjP0x7Qdk3B43p8KG/BaioP5RsV8zBGvH1zAgyPha2rN70/tT13yrmPd5QYEfwzexjKrV4mWIuRg8NTHYSZJUaeyCwTom80VFUJXG+GYTUyv5W22aBcnoRGiCiKEYTLOkgXecdKFTHmcIAejQ9Welr0a196Kq87w5KNMCkcCGFnwBNFLmfnbpNqT6rUBxxs3X5ntX9d8HVtSYINTsGXXMZCJ7fnbWajhg/aox0FtHX21eF6qIGT8j1z+l2opU+ggwUgkhUUgCH2TfqBj+MLMVVvpgqJsPKt582caFKArIFIvO+9QupxLnEH2hz04TMTfnU6bQC6z1buVe7h+tOLnh1YPFsLQ88anib/7TTC8k9DsBTq0ASe8R2GbSEsmO9qbbMwgEaYUhOKtGeyQsSJdhSk6XxXThrWL9EnwBCXDkICMqdntAxyyM9nWsZ4bL9JHqExgWUmfWChzPFAqn3F4y896UqHTZxlq3WGypn5HHcem2Hqf3IVxKH1inhqdVtkryEiTWrI7ZdjbqnqRbl+WgtPtKOOweDlCaRs3R2qXcbNgVhleMk4IWnF8D1695AenU1LwHjOJLkCjxgNFiWAFEPH9aEXAMPLExA==",
  "Authorization": "AWS4-HMAC-SHA256 Credential=XXXXXXXXXXXXXXXXXXX/20200401/us-east-1/appsync/aws4_request, SignedHeaders=accept;content-encoding;content-type;host;x-amz-date;x-amz-security-token, Signature=83EXAMPLEbcc1fe3ee69f75cd5ebbf4cb4f150e4f99cec869f149c5EXAMPLEdc"
}
```

**URL della richiesta con stringa di query**

```
wss://api.example.com/graphql?header=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&payload=e30=
```

**Nota**  
Una WebSocket connessione può avere più abbonamenti (anche con diverse modalità di autenticazione). Un modo per implementarlo consiste nel creare una WebSocket connessione per il primo abbonamento e poi chiuderlo quando l'ultimo abbonamento non è registrato. Puoi ottimizzarlo attendendo qualche secondo prima di chiudere la WebSocket connessione, nel caso in cui l'app venga sottoscritta immediatamente dopo la cancellazione dell'ultimo abbonamento. Ad esempio, quando si passa da una schermata all'altra, quando si *smonta* un abbonamento si interrompe e, in caso di *montaggio*, si avvia un abbonamento diverso.

### Autorizzazione Lambda
<a name="lambda-auth"></a>

#### Intestazione di autorizzazione Lambda
<a name="lambda-auth-list"></a>

**Contenuto dell'intestazione**
+  `"Authorization": <string>`: Il valore che viene passato come`authorizationToken`.
+  `"host": <string>`: l'host per l'endpoint AWS AppSync GraphQL o il nome di dominio personalizzato.

**Esempio**

```
{
    "Authorization":"M0UzQzM1MkQtMkI0Ni00OTZCLUI1NkQtMUM0MTQ0QjVBRTczCkI1REEzRTIxLTk5NzItNDJENi1BQjMwLTFCNjRFNzQ2NzlCNQo=",
    "host":"example1234567890000.appsync-api.us-east-1.amazonaws.com"
}
```

**Intestazioni tramite stringa di query**

Innanzitutto, un oggetto JSON contenente `host` and the `Authorization` viene convertito in una stringa. Successivamente, questa stringa viene codificata utilizzando la codifica base64. La stringa risultante con codifica base64 viene aggiunta come parametro di query denominato all' WebSocket URL per stabilire la connessione con l'endpoint `header` in tempo reale. AWS AppSync L'URL della richiesta risultante assume il formato seguente:

```
wss://example1234567890000.appsync-realtime-api.us-east-1.amazonaws.com/graphql?header=eyJBdXRob3JpemF0aW9uIjoiZXlKcmFXUWlPaUpqYkc1eGIzQTVlVzVNSzA5UVlYSXJNVEpIV0VGTFNYQmllVTVXTkhoc1FqaFBWVzlZTW5NMldsZHZQU0lzSW1Gc1p5STZJbEpUTWpVMkluMC5leUp6ZFdJaU9pSmhObU5tTWpjd055MHhOamd4TFRRMU5ESXRPV1l4T0MxbE5qWTBNVGcyTmpsa016WWlMQ0psZG1WdWRGOXBaQ0k2SW1Wa016TTVNbU5rTFdOallUTXROR00yT0MxaE5EWXlMVEpsWkdJM1pUTm1ZMkZqWmlJc0luUnZhMlZ1WDNWelpTSTZJbUZqWTJWemN5SXNJbk5qYjNCbElqb2lZWGR6TG1OdloyNXBkRzh1YzJsbmJtbHVMblZ6WlhJdVlXUnRhVzRpTENKaGRYUm9YM1JwYldVaU9qRTFOamswTlRjM01UZ3NJbWx6Y3lJNkltaDBkSEJ6T2x3dlhDOWpiMmR1YVhSdkxXbGtjQzVoY0MxemIzVjBhR1ZoYzNRdE1pNWhiV0Y2YjI1aGQzTXVZMjl0WEM5aGNDMXpiM1YwYUdWaGMzUXRNbDgzT0hZMFNWWmliVkFpTENKbGVIQWlPakUxTmprME5qRXpNakFzSW1saGRDSTZNVFUyT1RRMU56Y3lNQ3dpYW5ScElqb2lOVGd6WmpobVltTXRNemsyTVMwMFl6QTRMV0poWlRBdFl6UXlZMkl4TVRNNU5EWTVJaXdpWTJ4cFpXNTBYMmxrSWpvaU0zRmxhalZsTVhabU16ZDFOM1JvWld3MGRHOTFkREprTVd3aUxDSjFjMlZ5Ym1GdFpTSTZJbVZzYjNKNllXWmxJbjAuQjRjZEp0aDNLRk5wSjZpa1ZwN2U2RFJlZTk1VjZRaS16RUUyREpIN3NIT2wyenhZaTdmLVNtRUdvaDJBRDhlbXhRUllhakJ5ei1yRTRKaDBRT3ltTjJZcy1aSWtNcFZCVFBndS1UTVdEeU9IaERVbVVqMk9QODJ5ZVozd2xaQXRyX2dNNEx6alhVWG1JX0syeUdqdVhmWFRhYTFtdlFFQkcwbVFmVmQ3U2Z3WEItamN2NFJZVmk2ajI1cWdvdzlFdzUydWZ1clBxYUstM1dBS0czMktwVjhKNC1XZWpxOHQwYy15QTdzYjhFbkI1NTFiN1RVOTN1S1JpVlZLM0U1NU5rNUFEUG9hbV9XWUU0NWkzczVxVkFQXy1Jblc3NU5Vb09DR1RzUzhZV01mYjZlY0hZSi0xai1iekEyN3phVDlWamN0WG45YnlORlptS0xwQTJMY3h3IiwiaG9zdCI6ImV4YW1wbGUxMjM0NTY3ODkwMDAwLmFwcHN5bmMtYXBpLnVzLWVhc3QtMS5hbWF6b25hd3MuY29tIn0=&payload=e30=
```

È importante notare che oltre all'oggetto header con codifica base64, anche un oggetto JSON vuoto \$1\$1 è codificato in base64 e incluso come parametro di query separato denominato nell'URL. `payload` WebSocket

**Intestazioni tramite `Sec-WebSocket-Protocol`**

Un oggetto JSON contenente `host` and the `Authorization` viene convertito in una stringa e quindi codificato utilizzando la codifica Base64url. La stringa con codifica Base64URL risultante ha il prefisso. `header-` Questa stringa con prefisso viene quindi utilizzata come nuovo sottoprotocollo oltre che nell'`Sec-WebSocket-Protocol`intestazione quando si stabilisce la connessione con l'`graphql-ws`endpoint in tempo reale. WebSocket AWS AppSync 

L'URL della richiesta risultante assume il seguente formato:

```
wss://example1234567890000.appsync-realtime-api.us-east-1.amazonaws.com/graphql
```

L'`Sec-WebSocket-Protocol`intestazione contiene il seguente valore:

```
"sec-websocket-protocol" : ["graphql-ws", "header-ewogICAgImhvc3QiOiJleGFtcGxlMTIzNDU2Nzg5MDAwMC5hcHBzeW5jLWFwaS51cy1lYXN0LTEuYW1hem9uYXdzLmNvbSIsCiAgICAieC1hcGkta2V5IjoiZGEyLTEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Igp9"]
```

**Intestazioni tramite intestazioni HTTP standard**

In questo metodo, le informazioni sull'host e sull'autorizzazione vengono trasmesse utilizzando intestazioni HTTP standard quando si stabilisce la WebSocket connessione con l' AWS AppSync endpoint in tempo reale. L'URL della richiesta risultante assume il seguente formato:

```
wss://example1234567890000.appsync-realtime-api.us-east-1.amazonaws.com/graphql
```

Le intestazioni della richiesta includerebbero quanto segue:

```
"sec-websocket-protocol" : ["graphql-ws"]
"Authorization":"eyEXAMPLEiJjbG5xb3A5eW5MK09QYXIrMTJHWEFLSXBieU5WNHhsQjEXAMPLEnM2WldvPSIsImFsZyI6IlEXAMPLEn0.eyEXAMPLEiJhNmNmMjcwNy0xNjgxLTQ1NDItOWYxOC1lNjY0MTg2NjlkMzYiLCJldmVudF9pZCI6ImVkMzM5MmNkLWNjYTMtNGM2OC1hNDYyLTJlZGI3ZTNmY2FjZiIsInRva2VuX3VzZSI6ImFjY2VzcyIsInNjb3BlIjoiYXdzLmNvZ25pdG8uc2lnbmluLnVzZXIuYWRtaW4iLCJhdXRoX3RpbWUiOjE1Njk0NTc3MTgsImlzcyI6Imh0dHBzOlwvXC9jb2duaXRvLWlkcC5hcC1zb3V0aGVhc3QtMi5hbWF6b25hd3MuY29tXC9hcC1zb3V0aGVhc3QtMl83OHY0SVZibVAiLCJleHAiOjE1Njk0NjEzMjAsImlhdCI6MTU2OTQ1NzcyMCwianRpIjoiNTgzZjhmYmMtMzk2MS00YzA4LWJhZTAtYzQyY2IxMTM5NDY5IiwiY2xpZW50X2lkIjoiM3FlajVlMXZmMzd1N3RoZWw0dG91dDJkMWwiLCJ1c2VybmFtZSI6ImVsb3EXAMPLEn0.B4EXAMPLEFNpJ6ikVp7e6DRee95V6Qi-zEE2DJH7sHOl2zxYi7f-SmEGoh2AD8emxQRYajByz-rE4Jh0QOymN2Ys-ZIkMpVBTPgu-TMWDyOHhDUmUj2OP82yeZ3wlZAtr_gM4LzjXUXmI_K2yGjuXfXTaa1mvQEBG0mQfVd7SfwXB-jcv4RYVi6j25qgow9Ew52ufurPqaK-3WAKG32KpV8J4-Wejq8t0c-yA7sb8EnB551b7TU93uKRiVVK3E55Nk5ADPoam_WYE45i3s5qVAP_-InW75NUoOCGTsS8YWMfb6ecHYJ-1j-bzA27zaT9VjctXn9byNFZmEXAMPLExw",
"host":"example1234567890000.appsync-api.us-east-1.amazonaws.com"
```

## Funzionamento in tempo reale WebSocket
<a name="real-time-websocket-operation"></a>

Dopo aver avviato con successo una WebSocket stretta di mano con AWS AppSync, il client deve inviare un messaggio successivo a cui connettersi AWS AppSync per diverse operazioni. Questi messaggi richiedono i seguenti dati:
+  `type`: il tipo di operazione.
+  `id`: un identificatore univoco per l'abbonamento. Si consiglia di utilizzare un UUID per questo scopo.
+  `payload`: Il payload associato, a seconda del tipo di operazione.

Il `type` campo è l'unico campo obbligatorio; i `payload` campi `id` e sono facoltativi.

### Sequenza di eventi
<a name="sequence-of-events"></a>

Per avviare, stabilire, registrare ed elaborare correttamente la richiesta di iscrizione, il cliente deve seguire la seguente sequenza:

1. Inizializza connessione (`connection_init`)

1. Riconoscimento connessione (`connection_ack`)

1. Registrazione sottoscrizione (`start`)

1. Riconoscimento sottoscrizione (`start_ack`)

1. Elaborazione della sottoscrizione (`data`)

1. Annullamento sottoscrizione (`stop`)

## Messaggio init di connessione
<a name="connection-init-message"></a>

(Facoltativo) Dopo una stretta di mano riuscita, il client può inviare il `connection_init` messaggio per iniziare a comunicare con l' AWS AppSyncendpoint in tempo reale. Il messaggio è una stringa ottenuta stringendo l'oggetto JSON come segue:

```
{ "type": "connection_init" }
```

## Messaggio di conferma connessione
<a name="connection-acknowledge-message"></a>

Dopo aver inviato il messaggio `connection_init`, il client deve attendere il messaggio `connection_ack`. Tutti i messaggi inviati prima della ricezione vengono ignorati. `connection_ack` Il messaggio dovrebbe essere letto come segue:

```
{
  "type": "connection_ack",
  "payload": {
    // Time in milliseconds waiting for ka message before the client should terminate the WebSocket connection
    "connectionTimeoutMs": 300000
  }
}
```

## Messaggio keep-alive
<a name="keep-alive-message"></a>

Oltre al messaggio di conferma della connessione, il client riceve periodicamente messaggi keep-alive. Se il client non riceve un messaggio keep-alive entro il periodo di timeout della connessione, deve chiudere la connessione. AWS AppSync continua a inviare questi messaggi e a gestire gli abbonamenti registrati fino a quando non interrompe automaticamente la connessione (dopo 24 ore). I messaggi Keep-alive sono battiti cardiaci e non è necessario che il client li riconosca.

```
{ "type": "ka" }
```

## Messaggio di registrazione dell'abbonamento
<a name="subscription-registration-message"></a>

Dopo aver ricevuto un `connection_ack` messaggio, il client può inviare messaggi di registrazione dell'abbonamento a. AWS AppSync Questo tipo di messaggio è un oggetto JSON con stringhe che contiene i seguenti campi:
+  `"id": <string>`: L'ID dell'abbonamento. Questo ID deve essere univoco per ogni abbonamento, altrimenti il server restituisce un errore che indica che l'ID dell'abbonamento è duplicato.
+  `"type": "start"`: un parametro `<string>` costante.
+  `"payload": <Object>`: Un oggetto che contiene le informazioni relative all'abbonamento.
  +  `"data": <string>`: un oggetto JSON con stringhe che contiene una query GraphQL e variabili.
    +  `"query": <string>`: Un'operazione GraphQL.
    +  `"variables": <Object>`: Un oggetto che contiene le variabili per la query.
  +  `"extensions": <Object>`: Un oggetto che contiene un oggetto di autorizzazione.
+  `"authorization": <Object>`: Un oggetto che contiene i campi richiesti per l'autorizzazione.

### Oggetto autorizzazione per la registrazione della sottoscrizione
<a name="authorization-object-for-subscription-registration"></a>

Le stesse regole della [Formato dei parametri di intestazione basato sulla modalità di autorizzazione AWS AppSync API](#header-parameter-format-based-on-appsync-api-authorization-mode) sezione si applicano all'oggetto di autorizzazione. L'unica eccezione è per IAM, in cui le informazioni sulla firma SigV4 sono leggermente diverse. Per ulteriori dettagli, vedere l'esempio di IAM.

Esempio di utilizzo di pool di utenti Amazon Cognito:

```
{
  "id": "ee849ef0-cf23-4cb8-9fcb-152ae4fd1e69",
  "payload": {
    "data": "{\"query\":\"subscription onCreateMessage {\\n onCreateMessage {\\n __typename\\n message\\n }\\n }\",\"variables\":{}}",
      "extensions": {
        "authorization": {
          "Authorization": "eyEXAMPLEiJjbG5xb3A5eW5MK09QYXIrMTJEXAMPLEBieU5WNHhsQjhPVW9YMnM2WldvPSIsImFsZyI6IlEXAMPLEn0.eyJzdWIiOiJhNmNmMjcwNy0xNjgxLTQ1NDItEXAMPLENjY0MTg2NjlkMzYiLCJldmVudF9pZCI6ImU3YWVmMzEyLWUEXAMPLEY0Zi04YjlhLTRjMWY5M2Q5ZTQ2OCIsInRva2VuX3VzZSI6ImFjY2VzcyIsIEXAMPLEIjoiYXdzLmNvZ25pdG8uc2lnbmluLnVzZXIuYWRtaW4iLCJhdXRoX3RpbWUiOjE1Njk2MTgzMzgsImlzcyI6Imh0dEXAMPLEXC9jb2duaXRvLWlkcC5hcC1zb3V0aGVhc3QtMi5hbWF6b25hd3MuY29tXC9hcC1zbEXAMPLEc3QtMl83OHY0SVZibVAiLCJleHAiOjE1NzAyNTQ3NTUsImlhdCI6MTU3MDI1MTE1NSwianRpIjoiMmIEXAMPLEktZTVkMi00ZDhkLWJiYjItNjA0YWI4MDEwOTg3IiwiY2xpZW50X2lkIjoiM3FlajVlMXZmMzd1EXAMPLE0dG91dDJkMWwiLCJ1c2VybmFtZSI6ImVsb3J6YWZlIn0.CT-qTCtrYeboUJ4luRSTPXaNewNeEXAMPLE14C6sfg05tO0fOMpiUwj9k19gtNCCMqoSsjtQoUweFnH4JYa5EXAMPLEVxOyQEQ4G7jQrt5Ks6STn53vuseR3zRW9snWgwz7t3ZmQU-RWvW7yQU3sNQRLEXAMPLEcd0yufBiCYs3dfQxTTdvR1B6Wz6CD78lfNeKqfzzUn2beMoup2h6EXAMPLE4ow8cUPUPvG0DzRtHNMbWskjPanu7OuoZ8iFO_Eot9kTtAlVKYoNbWkZhkD8dxutyoU4RSH5JoLAnrGF5c8iKgv0B2dfEXAMPLEIihxaZVJ9w9w48S4EXAMPLEcA",
          "host": "example1234567890000.appsync-api.us-east-1.amazonaws.com"
         }
      }
  },
  "type": "start"
}
```

Esempio di utilizzo di IAM:

```
{
  "id": "eEXAMPLE-cf23-1234-5678-152EXAMPLE69",
  "payload": {
    "data": "{\"query\":\"subscription onCreateMessage {\\n onCreateMessage {\\n __typename\\n message\\n }\\n }\",\"variables\":{}}",
    "extensions": {
      "authorization": {
        "accept": "application/json, text/javascript",
        "content-type": "application/json; charset=UTF-8",
        "X-Amz-Security-Token": "AgEXAMPLEZ2luX2VjEAoaDmFwLXNvdXRoZWFEXAMPLEcwRQIgAh97Cljq7wOPL8KsxP3YtDuyc/9hAj8PhJ7Fvf38SgoCIQDhJEXAMPLEPspioOztj++pEagWCveZUjKEn0zyUhBEXAMPLEjj//////////8BEXAMPLExODk2NDgyNzg1NSIMo1mWnpESWUoYw4BkKqEFSrm3DXuL8w+ZbVc4JKjDP4vUCKNR6Le9C9pZp9PsW0NoFy3vLBUdAXEXAMPLEOVG8feXfiEEA+1khgFK/wEtwR+9zF7NaMMMse07wN2gG2tH0eKMEXAMPLEQX+sMbytQo8iepP9PZOzlZsSFb/dP5Q8hk6YEXAMPLEYcKZsTkDAq2uKFQ8mYUVA9EtQnNRiFLEY83aKvG/tqLWNnGlSNVx7SMcfovkFDqQamm+88y1OwwAEYK7qcoceX6Z7GGcaYuIfGpaX2MCCELeQvZ+8WxEgOnIfz7GYvsYNjLZSaRnV4G+ILY1F0QNW64S9Nvj+BwDg3ht2CrNvpwjVYlj9U3nmxE0UG5ne83LL5hhqMpm25kmL7enVgw2kQzmU2id4IKu0C/WaoDRuO2F5zE63vJbxN8AYs7338+4B4HBb6BZ6OUgg96Q15RA41/gIqxaVPxyTpDfTU5GfSLxocdYeniqqpFMtZG2n9d0u7GsQNcFkNcG3qDZm4tDo8tZbuym0a2VcF2E5hFEgXBa+XLJCfXi/77OqAEjP0x7Qdk3B43p8KG/BaioP5RsV8zBGvH1zAgyPha2rN70/tT13yrmPd5QYEfwzexjKrV4mWIuRg8NTHYSZJUaeyCwTom80VFUJXG+GYTUyv5W22aBcnoRGiCiKEYTLOkgXecdKFTHmcIAejQ9Welr0a196Kq87w5KNMCkcCGFnwBNFLmfnbpNqT6rUBxxs3X5ntX9d8HVtSYINTsGXXMZCJ7fnbWajhg/aox0FtHX21eF6qIGT8j1z+l2opU+ggwUgkhUUgCH2TfqBj+MLMVVvpgqJsPKt582caFKArIFIvO+9QupxLnEH2hz04TMTfnU6bQC6z1buVe7h+tOLnh1YPFsLQ88anib/7TTC8k9DsBTq0ASe8R2GbSEsmO9qbbMwgEaYUhOKtGeyQsSJdhSk6XxXThrWL9EnwBCXDkICMqdntAxyyM9nWsZ4bL9JHqExgWUmfWChzPFAqn3F4y896UqHTZxlq3WGypn5HHcem2Hqf3IVxKH1inhqdVtkryEiTWrI7ZdjbqnqRbl+WgtPtKOOweDlCaRs3R2qXcbNgVhleMk4IWnF8D1695AenU1LwHjOJLkCjxgNFiWAFEPH9aEXAMPLExA==",
        "Authorization": "AWS4-HMAC-SHA256 Credential=XXXXXXXXXXXXXXXXXXXX/20200401/us-east-1/appsync/aws4_request, SignedHeaders=accept;content-encoding;content-type;host;x-amz-date;x-amz-security-token, Signature=b90131a61a7c4318e1c35ead5dbfdeb46339a7585bbdbeceeaff51f4022eb1fd",
        "content-encoding": "amz-1.0",
        "host": "example1234567890000.appsync-api.us-east-1.amazonaws.com",
        "x-amz-date": "20200401T001010Z"
      }
    }
  },
  "type": "start"
}
```

Esempio di utilizzo di un nome di dominio personalizzato:

```
{
  "id": "key-cf23-4cb8-9fcb-152ae4fd1e69",
  "payload": {
    "data": "{\"query\":\"subscription onCreateMessage {\\n onCreateMessage {\\n __typename\\n message\\n }\\n }\",\"variables\":{}}",
      "extensions": {
        "authorization": {
          "x-api-key": "da2-12345678901234567890123456",
          "host": "api.example.com"
         }
      }
  },
  "type": "start"
}
```

Non è necessario aggiungere la firma SigV4 `/connect` all'URL e l'operazione GraphQL con stringa JSON la sostituisce. `data` Di seguito è riportato un esempio di richiesta di firma SigV4:

```
{
  url: "https://example1234567890000.appsync-api.us-east-1.amazonaws.com/graphql",
  data: "{\"query\":\"subscription onCreateMessage {\\n onCreateMessage {\\n __typename\\n message\\n }\\n }\",\"variables\":{}}",
  method: "POST",
  headers: {
    "accept": "application/json, text/javascript",
    "content-encoding": "amz-1.0",
    "content-type": "application/json; charset=UTF-8",
  }
}
```

## Messaggio di conferma dell'iscrizione
<a name="subscription-acknowledge-message"></a>

Dopo aver inviato il messaggio di avvio dell'abbonamento, il cliente deve AWS AppSync attendere l'invio del `start_ack` messaggio. Il `start_ack` messaggio indica che l'abbonamento è andato a buon fine.

Esempio di riconoscimento dell'abbonamento:

```
{
  "type": "start_ack",
  "id": "eEXAMPLE-cf23-1234-5678-152EXAMPLE69"
}
```

## Messaggio di errore
<a name="error-message"></a>

Se l'avvio della connessione o la registrazione dell'abbonamento falliscono o se una sottoscrizione viene interrotta dal server, il server invia un messaggio di errore al client. Se l'errore si verifica durante l'avvio della connessione, la connessione verrà chiusa dal server.
+  `"type": "error"`: un parametro `<string>` costante.
+  `"id": <string>`: L'ID dell'abbonamento registrato corrispondente, se pertinente.
+  `"payload" <Object>`: Un oggetto che contiene le informazioni di errore corrispondenti.

Esempio:

```
{
  "type": "error",
  "payload": {
    "errors": [
      {
        "errorType": "LimitExceededError",
        "message": "Rate limit exceeded"
      }
    ]
  }
}
```

## Elaborazione dei messaggi dati
<a name="processing-data-messages"></a>

Quando un client invia una mutazione, AWS AppSync identifica tutti gli abbonati interessati e invia un `"type":"data"` messaggio a ciascuno di essi utilizzando l'abbonamento corrispondente `id` dall'operazione di sottoscrizione. `"start"` Il client dovrebbe tenere traccia dell'abbonamento inviato in modo `id` che, quando riceve un messaggio di dati, possa abbinarlo all'abbonamento corrispondente.
+  `"type": "data"`: un parametro `<string>` costante.
+  `"id": <string>`: L'ID dell'abbonamento registrato corrispondente.
+  `"payload" <Object>`: Un oggetto che contiene le informazioni sulla sottoscrizione.

Esempio:

```
{
  "type": "data",
  "id": "ee849ef0-cf23-4cb8-9fcb-152ae4fd1e69",
  "payload": {
    "data": {
      "onCreateMessage": {
        "__typename": "Message",
        "message": "test"
      }
    }
  }
}
```

## Messaggio di annullamento registrazione sottoscrizione
<a name="subscription-unregistration-message"></a>

Quando l'app desidera interrompere l'ascolto degli eventi di sottoscrizione, il client deve inviare un messaggio con il seguente oggetto JSON con stringhe:
+  `"type": "stop"`: un parametro `<string>` costante.
+  `"id": <string>`: L'ID dell'abbonamento di cui annullare la registrazione.

Esempio:

```
{
  "type":"stop",
  "id":"ee849ef0-cf23-4cb8-9fcb-152ae4fd1e69"
}
```

AWS AppSync restituisce un messaggio di conferma con il seguente oggetto JSON con stringhe:
+  `"type": "complete"`: un parametro `<string>` costante.
+  `"id": <string>`: L'ID dell'abbonamento non registrato.

Dopo aver ricevuto il messaggio di conferma, il cliente non riceve più messaggi per questo particolare abbonamento.

Esempio:

```
{
  "type":"complete",
  "id":"eEXAMPLE-cf23-1234-5678-152EXAMPLE69"
}
```

## Disconnettere il WebSocket
<a name="disconnecting-the-websocket"></a>

Prima della disconnessione, per evitare la perdita di dati, il client deve disporre della logica necessaria per verificare che al momento non sia in corso alcuna operazione tramite la WebSocket connessione. Tutti gli abbonamenti devono essere annullati prima di disconnettersi da. WebSocket