

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à.

# EventBridge Schemi Amazon
<a name="eb-schema"></a>

Uno schema definisce la struttura degli [eventi](eb-events.md) a cui vengono inviati EventBridge. EventBridge fornisce schemi per tutti gli eventi generati dai AWS servizi. Puoi inoltre [creare o caricare schemi personalizzati](eb-schema-create.md) o [dedurre schemi](eb-schemas-infer.md) direttamente dagli eventi in un [router di eventi](eb-event-bus.md). Quando disponi di uno schema per un evento, puoi scaricare le associazioni di codice per i linguaggi di programmazione più diffusi e accelerare la fase di sviluppo. È possibile utilizzare le associazioni di codice per gli schemi e gestire gli schemi dalla EventBridge console, utilizzando l'API o direttamente nell'IDE utilizzando i toolkit. AWS Per creare app serverless che utilizzano eventi, utilizza AWS Serverless Application Model.

**Nota**  
Quando si utilizza la funzionalità [trasformatore di input](eb-transform-target-input.md), l'evento originale viene dedotto dall'individuazione dello schema, non l'evento trasformato inviato alla destinazione.

EventBridge supporta i formati OpenAPI 3 e JSONSchema Draft4.

Per [AWS Toolkit for JetBrains](https://docs.aws.amazon.com/toolkit-for-jetbrains/latest/userguide/eventbridge-schemas.html) e [AWS Toolkit for VS](https://docs.aws.amazon.com/toolkit-for-vscode/latest/userguide/working-with-aws.html) Code, puoi sfogliare o cercare schemi e scaricare le associazioni di codice per gli schemi direttamente nel tuo IDE. 

 Il video seguente offre una panoramica degli schemi e dei registri di schemi:




## Mascheramento del valore delle proprietà dell'API di registro di schemi
<a name="eb-schema-mask"></a>

Alcuni valori di proprietà degli eventi utilizzate per creare un registro di schemi possono contenere informazioni riservate sui clienti. Per proteggere le informazioni del cliente, i valori verranno mascherati con asterischi (\$1). Poiché stiamo mascherando questi valori, consigliamo EventBridge di non creare applicazioni che dipendono esplicitamente dalle seguenti proprietà o dai relativi valori:
+ **[CreateSchema](https://docs.aws.amazon.com/eventbridge/latest/schema-reference/v1-registries-name-registryname-schemas-name-schemaname.html#CreateSchema)**— La `Content` proprietà del corpo `requestParameters`
+ **[GetDiscoveredSchema](https://docs.aws.amazon.com/eventbridge/latest/schema-reference/v1-discover.html#GetDiscoveredSchema)**— La `Events` proprietà del `requestParameters` corpo e la `Content` proprietà del `responseElements` corpo
+ **[SearchSchemas](https://docs.aws.amazon.com/eventbridge/latest/schema-reference/v1-registries-name-registryname-schemas-search.html#SearchSchemas)**— La `keywords` proprietà del `requestParameters`
+ **[UpdateSchema](https://docs.aws.amazon.com/eventbridge/latest/schema-reference/v1-registries-name-registryname-schemas-name-schemaname.html#UpdateSchema)**— La `Content` proprietà di `requestParameters`

# Individuazione di uno schema di eventi di AWS servizio in Amazon EventBridge
<a name="eb-find-schema"></a>

EventBridge include [schemi](eb-schema.md) per tutti i AWS servizi che generano eventi. Puoi trovare questi schemi nella EventBridge console oppure puoi trovarli utilizzando l'azione API. [https://docs.aws.amazon.com/eventbridge/latest/schema-reference/v1-registries-name-registryname-schemas-search.html](https://docs.aws.amazon.com/eventbridge/latest/schema-reference/v1-registries-name-registryname-schemas-search.html)

**Per trovare schemi per i AWS servizi nella console EventBridge**

1. Apri la EventBridge console Amazon all'indirizzo [https://console.aws.amazon.com/events/](https://console.aws.amazon.com/events/).

1. Nel riquadro di navigazione, seleziona **Schemas (Schemi)**.

1. Nella pagina **Schemi**, seleziona **Registro schemi eventi AWS **.

   Viene visualizzata la prima pagina degli schemi disponibili.

1. **Per trovare uno schema, in **Cerca schemi di AWS eventi**, inserisci un termine di ricerca.**

   Una ricerca restituisce corrispondenze sia per il nome che per il contenuto degli schemi disponibili e visualizza le versioni dello schema che contengono corrispondenza.

1. Apri uno schema di eventi selezionando il nome dello schema.

# Registri degli schemi in Amazon EventBridge
<a name="eb-schema-registry"></a>

I registri di schemi sono container di schemi. I registri di schemi raccolgono e organizzano gli schemi in gruppi logici. I registri di schemi predefiniti sono: 
+ **Tutti gli schemi**: tutti gli schemi dei registri degli AWS eventi, rilevati e degli schemi personalizzati.
+ **AWS registro degli schemi degli eventi**: gli schemi incorporati.
+ **Registro schema individuato**: gli schemi individuati con Individuazione schema.

Puoi inoltre creare registri personalizzati per organizzare gli schemi creati o caricati.

**Nota**  
L'esportazione di schemi personalizzati dal registro degli EventBridge schemi non è supportata.

**Per creare un registro di schemi personalizzato**

1. Apri la EventBridge console Amazon all'indirizzo [https://console.aws.amazon.com/events/](https://console.aws.amazon.com/events/).

1. Nel riquadro di navigazione, scegli **Schemi** quindi **Crea registro**.

1. Nella pagina **Dettagli del registro** immetti un **Nome**.

1. (Facoltativo) Immetti una descrizione per il nuovo registro.

1. Scegli **Create** (Crea).

Per [creare uno schema personalizzato](eb-schema-create.md) nel nuovo registro, seleziona **Crea schemi personalizzati**. Per aggiungere uno schema al registro, seleziona il registro quando crei un nuovo schema.

Per creare un registro mediante l'API, utilizza [https://docs.aws.amazon.com/eventbridge/latest/schema-reference/v1-registries-name-registryname.html#v1-registries-name-registryname-http-methods](https://docs.aws.amazon.com/eventbridge/latest/schema-reference/v1-registries-name-registryname.html#v1-registries-name-registryname-http-methods). Per ulteriori informazioni, consulta [Amazon EventBridge Schema Registry API Reference](https://docs.aws.amazon.com/eventbridge/latest/schema-reference/index.html).

Per informazioni sull'utilizzo del registro degli EventBridge schemi tramite AWS CloudFormation, consulta [EventSchemas Resource Type Reference](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/AWS_EventSchemas.html) in CloudFormation.

# Creazione di uno schema di eventi in Amazon EventBridge
<a name="eb-schema-create"></a>

[È possibile creare schemi utilizzando file JSON con la specifica [OpenAPI o la specifica](https://swagger.io/specification/) Draft4. JSONSchema ](https://json-schema.org/specification-links.html#draft-4) [È possibile creare o caricare schemi personalizzati utilizzando un modello o EventBridge generando uno schema basato sul codice JSON di un evento.](eb-events.md) Puoi anche dedurre lo schema da eventi in [router di eventi](eb-event-bus.md). Per creare uno schema utilizzando l'API EventBridge Schema Registry, utilizza l'azione [https://docs.aws.amazon.com/eventbridge/latest/schema-reference/v1-registries-name-registryname-schemas-name-schemaname.html#v1-registries-nam](https://docs.aws.amazon.com/eventbridge/latest/schema-reference/v1-registries-name-registryname-schemas-name-schemaname.html#v1-registries-nam)API.

Quando scegli tra i formati OpenAPI 3 e JSONSchema Draft4, considera le seguenti differenze:
+ JSONSchema il formato supporta parole chiave aggiuntive che non sono supportate in OpenAPI, ad esempio. `$schema, additionalItems`
+ Esistono piccole differenze nel modo in cui vengono gestite le parole chiave, ad esempio `type` e `format`.
+ OpenAPI non supporta i JSONSchema collegamenti ipertestuali Hyper-Schema nei documenti JSON.
+ Gli strumenti per OpenAPI tendono a concentrarsi sulla fase di compilazione, mentre gli strumenti per OpenAPI JSONSchema tendono a concentrarsi sulle operazioni in fase di esecuzione, come gli strumenti client per la convalida dello schema.

Si consiglia di utilizzare il JSONSchema formato per implementare la convalida lato client in modo che gli eventi inviati siano conformi allo schema. EventBridge È possibile utilizzare JSONSchema per definire un contratto per documenti JSON validi e quindi utilizzare un [validatore di schemi JSON](https://json-schema.org/tools) prima di inviare gli eventi associati.

Dopo aver creato un nuovo schema, puoi scaricare le [associazioni di codice](eb-schema-code-bindings.md) utili per creare applicazioni per eventi con quello schema.

# Creazione di uno schema utilizzando un modello in Amazon EventBridge
<a name="eb-schema-template"></a>

È possibile creare uno schema da un file modello scaricato o modificando un modello direttamente nella EventBridge console. 

## Crea uno schema da un file modello
<a name="eb-schema-template-file"></a>

Per scaricare il modello, devi scaricarlo dalla console. Modifica il modello in modo che lo schema corrisponda agli eventi. Quindi carica il nuovo modello tramite la console.

**Per scaricare il modello di schema**

1. Apri la EventBridge console Amazon all'indirizzo [https://console.aws.amazon.com/events/](https://console.aws.amazon.com/events/).

1. Nel riquadro di spostamento, seleziona **Schema registry (Registro degli schemi)**.

1. Nella sezione **Getting started (Nozioni di base)** in **Schema template (Modello schema)**, scegli **Download (Scarica)**.

In alternativa, puoi copiare il modello JSON dall'esempio di codice seguente.

```
{
    "openapi": "3.0.0",
    "info": {
      "version": "1.0.0",
      "title": "Event"
    },
    "paths": {},
    "components": {
      "schemas": {
        "Event": {
          "type": "object",
          "properties": {
            "ordinal": {
              "type": "number",
              "format": "int64"
            },
            "name": {
              "type": "string"
            },
            "price": {
              "type": "number",
              "format": "double"
            },
            "address": {
              "type": "string"
            },
            "comments": {
              "type": "array",
              "items": {
                "type": "string"
              }
            },
            "created_at": {
              "type": "string",
              "format": "date-time"
            }
          }
        }
      }
    }
  }
```

**Per caricare un modello di schema**

1. Apri la EventBridge console Amazon all'indirizzo [https://console.aws.amazon.com/events/](https://console.aws.amazon.com/events/).

1. Nel riquadro di navigazione, scegli **Schemi** quindi scegli **Crea schema**.

1. (Facoltativo) Seleziona o crea un registro di schemi.

1. In **Dettagli dello schema**, immetti un nome per lo schema.

1. (Facoltativo) Immetti una descrizione per lo schema.

1. In **Tipo di schema**, scegli **OpenAPI 3.0** o **JSON Schema Draft 4**.

1. Nella scheda **Crea**, nella casella di testo, trascina il file dello schema nella casella di testo oppure incolla l'origine dello schema.

1. Seleziona **Crea**.

## Modifica di un modello di schema direttamente nella console
<a name="eb-schema-template-console"></a>

È possibile creare uno schema direttamente nella EventBridge console.

**Per modificare uno schema nella console**

1. Apri la EventBridge console Amazon all'indirizzo [https://console.aws.amazon.com/events/](https://console.aws.amazon.com/events/).

1. Nel riquadro di navigazione, scegli **Schemi** quindi scegli **Crea schema**.

1. (Facoltativo) Seleziona o crea un registro di schemi.

1. In **Dettagli dello schema**, immetti un nome per lo schema.

1. In **Tipo di schema**, scegli **OpenAPI 3.0** o **JSON Schema Draft 4**.

1. (Facoltativo) Puoi immettere una descrizione per lo schema da creare.

1. Nella scheda **Crea**, scegli **Carica modello**.

1. Nella casella di testo, modifica il modello in modo che lo schema corrisponda ai tuoi [eventi](eb-events.md). 

1. Seleziona **Crea**.

# Creazione di uno schema dall'evento JSON in Amazon EventBridge
<a name="eb-schemas-infer-from-json"></a>

Se disponi del JSON di un evento, puoi creare automaticamente uno schema per quel tipo di evento.

**Per creare uno schema basato sul JSON di un evento**

1. Apri la EventBridge console Amazon all'indirizzo [https://console.aws.amazon.com/events/](https://console.aws.amazon.com/events/).

1. Nel riquadro di navigazione, scegli **Schemi** quindi scegli **Crea schema**.

1. (Facoltativo) Seleziona o crea un registro di schemi.

1. In **Schema details (Dettagli schema)** inserisci un nome per lo schema.

1. (Facoltativo) Puoi immettere una descrizione per lo schema creato.

1. In **Tipo di schema**, scegli **OpenAPI 3.0**.

   Non puoi utilizzarlo JSONSchema quando crei uno schema dal codice JSON di un evento.

1. Seleziona **Discover from JSON (Individua da JSON)**

1. Nella casella di testo in **JSON**, incolla o trascina l'origine JSON di un evento.

   Ad esempio, è possibile incollare il codice sorgente di questo AWS Step Functions evento per un'esecuzione non riuscita.

   ```
   {
       "version": "0",
       "id": "315c1398-40ff-a850-213b-158f73e60175",
       "detail-type": "Step Functions Execution Status Change",
       "source": "aws.states",
       "account": "012345678912",
       "time": "2019-02-26T19:42:21Z",
       "region": "us-east-1",
       "resources": [
         "arn:aws:states:us-east-1:012345678912:execution:state-machine-name:execution-name"
       ],
       "detail": {
           "executionArn": "arn:aws:states:us-east-1:012345678912:execution:state-machine-name:execution-name",
           "stateMachineArn": "arn:aws:states:us-east-1:012345678912:stateMachine:state-machine",
           "name": "execution-name",
           "status": "FAILED",
           "startDate": 1551225146847,
           "stopDate": 1551225151881,
           "input": "{}",
           "output": null
       }
   }
   ```

1. Scegli **Individua schema**.

1. EventBridge genera uno schema OpenAPI per l'evento. Ad esempio, lo schema seguente viene generato per l'evento Step Functions precedente.

   ```
   {
     "openapi": "3.0.0",
     "info": {
       "version": "1.0.0",
       "title": "StepFunctionsExecutionStatusChange"
     },
     "paths": {},
     "components": {
       "schemas": {
         "AWSEvent": {
           "type": "object",
           "required": ["detail-type", "resources", "detail", "id", "source", "time", "region", "version", "account"],
           "x-amazon-events-detail-type": "Step Functions Execution Status Change",
           "x-amazon-events-source": "aws.states",
           "properties": {
             "detail": {
               "$ref": "#/components/schemas/StepFunctionsExecutionStatusChange"
             },
             "account": {
               "type": "string"
             },
             "detail-type": {
               "type": "string"
             },
             "id": {
               "type": "string"
             },
             "region": {
               "type": "string"
             },
             "resources": {
               "type": "array",
               "items": {
                 "type": "string"
               }
             },
             "source": {
               "type": "string"
             },
             "time": {
               "type": "string",
               "format": "date-time"
             },
             "version": {
               "type": "string"
             }
           }
         },
         "StepFunctionsExecutionStatusChange": {
           "type": "object",
           "required": ["output", "input", "executionArn", "name", "stateMachineArn", "startDate", "stopDate", "status"],
           "properties": {
             "executionArn": {
               "type": "string"
             },
             "input": {
               "type": "string"
             },
             "name": {
               "type": "string"
             },
             "output": {},
             "startDate": {
               "type": "integer",
               "format": "int64"
             },
             "stateMachineArn": {
               "type": "string"
             },
             "status": {
               "type": "string"
             },
             "stopDate": {
               "type": "integer",
               "format": "int64"
             }
           }
         }
       }
     }
   }
   ```

1. Una volta generato lo schema, scegli **Crea**.

# Deduzione di schemi dagli eventi del bus degli eventi in EventBridge
<a name="eb-schemas-infer"></a>

Amazon EventBridge può dedurre schemi scoprendo gli eventi. Per dedurre gli schemi, si attiva l'individuazione degli eventi in un router di eventi e ogni schema univoco viene aggiunto al registro di schemi, compresi quelli per eventi multi-account. **Gli schemi scoperti da EventBridge vengono visualizzati nel **registro Discovered schemas nella pagina Schemas**.**

Se il contenuto degli eventi sul bus degli eventi cambia, EventBridge crea nuove versioni dello schema correlato. EventBridge 

## Considerazioni sull'avvio del rilevamento dello schema su un bus di eventi
<a name="eb-schemas-infer-considerations"></a>

Tenete conto delle seguenti considerazioni prima di abilitare lo schema discover su un bus di eventi:
+ L'abilitazione dell'individuazione degli eventi in un router di eventi può comportare un costo. I primi cinque milioni di eventi elaborati ogni mese sono gratuiti.
+ EventBridge per impostazione predefinita, deduce gli schemi dagli eventi tra account diversi, ma è possibile disabilitarlo aggiornando la proprietà. `cross-account` Per ulteriori informazioni, consulta [Discoverers](https://docs.aws.amazon.com/eventbridge/latest/schema-reference/v1-discoverers.html) nello EventBridge Schema Registry API Reference.

**Nota**  
L'individuazione dello schema non è supportata per i bus di eventi crittografati utilizzando una chiave gestita dal cliente. Per abilitare l'individuazione dello schema su un bus di eventi, scegli di utilizzare un Chiave di proprietà di AWS. Per ulteriori informazioni, consulta [Opzioni chiave KMS](eb-encryption-at-rest-key-options.md).

**Per avviare o interrompere l'individuazione dello schema su un bus di eventi (console)**

1. Apri la EventBridge console Amazon all'indirizzo [https://console.aws.amazon.com/events/](https://console.aws.amazon.com/events/).

1. Nel riquadro di navigazione, scegliere **Event history (Cronologia eventi)**.

1. Seleziona il bus degli eventi su cui desideri avviare o interrompere il rilevamento dello schema.

1. Esegui una delle seguenti operazioni: 
   + Per avviare l'individuazione dello schema, scegli **Avvia scoperta**.
   + Per interrompere l'individuazione dello schema, scegli **Elimina scoperta**.

**Per avviare o interrompere l'individuazione dello schema su un bus di eventi (AWS CLI)**
+ Per avviare l'individuazione dello schema, usa [create-discoverer](https://docs.aws.amazon.com/cli/latest/reference/schemas/create-discoverer.html).

  [Per interrompere l'individuazione dello schema, usa delete-discoverer.](https://docs.aws.amazon.com/cli/latest/reference/schemas/delete-discoverer.html)

**Nota**  
L'individuazione dello schema non supporta eventi di dimensioni superiori a 1000 KB. Questi eventi non verranno rilevati e non verrà generata alcuna notifica di errore. Per tenere traccia degli schemi per eventi più grandi, è necessario creare manualmente gli schemi utilizzando il registro degli schemi.

# Generazione di associazioni di codice per schemi di eventi in Amazon EventBridge
<a name="eb-schema-code-bindings"></a>

Puoi generare associazioni di codice per [schemi](eb-schema.md) di eventi per accelerare lo sviluppo in Golang, Java, Python e. TypeScript Le associazioni di codice sono disponibili per eventi di servizi AWS , schemi che [crei](eb-schema-create.md) e per schemi che [generati](eb-schemas-infer.md) in base a [eventi](eb-events.md) in un [router di eventi](eb-event-bus.md). Puoi generare associazioni di codice per uno schema utilizzando la EventBridge console, l'[API EventBridge Schema Registry](https://docs.aws.amazon.com/eventbridge/latest/schema-reference/index.html) o nel tuo IDE con un toolkit. AWS 

**Per generare associazioni di codice da uno schema EventBridge**

1. Apri la EventBridge console Amazon all'indirizzo [https://console.aws.amazon.com/events/](https://console.aws.amazon.com/events/).

1. Nel riquadro di navigazione, seleziona **Schemas (Schemi)**.

1. Trova uno schema per il quale desideri eseguire le associazioni di codice, cercando nei registri di schemi o cercando uno schema.

1. Seleziona il nome dello schema.

1. Nella pagina dei **dettagli dello schema**, nella sezione **Versione**, seleziona **Scarica le associazioni del codice**.

1. Nella pagina **Download code bindings (Scarica associazioni di codice)** selezionare la lingua delle associazioni di codice che si desidera scaricare.

1. Selezionare **Download (Scarica)**.

   Potrebbero essere necessari alcuni secondi per l’avvio del download. Il file di download è un file zip di associazioni di codice per il linguaggio selezionato.