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à.
# Tipi di contenuto supportati: JSON, Avro, Protobuf e byte raw
`PutRawEvents`accetta qualsiasi byte. Ogni voce `SystemMetadata.ContentType` indica EventBridge cosa sono i byte e quel valore decide se EventBridge deserializzare il payload prima che filtri e fornisca l'evento. Per Avro e Protobuf, EventBridge deserializza il payload rispetto a un registro di schema denominato nella richiesta, in modo che gli abbonati filtrino, trasformino e ricevano l'evento come JSON. Per i byte opachi, fornisce il payload intatto. EventBridge
| `ContentType` | Cosa fa con il payload EventBridge | Registro degli schemi |
| --- | --- | --- |
| application/json | Filtra e trasforma il contenuto JSON | Non utilizzato |
| application/avro | Deserializza il binario Avro in JSON, quindi filtra e trasforma su quel JSON | Richiesto |
| application/protobuf | Deserializza il binario Protobuf in JSON, quindi filtra e trasforma su quel JSON | Richiesto |
| application/octet-stream | Non deserializza né ispeziona il payload. Fornisce i byte così come inviati | Non utilizzato |
## Come EventBridge deserializza un payload
Quando una voce `ContentType` è `application/avro` o`application/protobuf`, EventBridge esegue i seguenti passaggi per quella voce.
1. EventBridge legge l'identificatore dello schema che il serializzatore del registro ha scritto nei byte del payload.
1. EventBridge recupera lo schema corrispondente dal registro in cui inserisci il nome e deserializza il payload in `SchemaRegistryConfiguration.RegistryUri` JSON. Se lo schema non può essere trovato o letto o il payload non può essere deserializzato rispetto ad esso, la voce ha esito negativo con un errore per voce e le altre voci della richiesta non vengono modificate.
1. Se un sottoscrittore definisce dei filtri, EventBridge li valuta rispetto al JSON deserializzato.
1. EventBridge applica la trasformazione dell'abbonato al JSON deserializzato e fornisce JSON alla destinazione.
Assegna un nome al registro su ogni richiesta, in. `PutRawEvents` `SchemaRegistryConfiguration.RegistryUri` L'impostazione appartiene alla richiesta, non al bus, e la EventBridge ignora per le voci JSON nella stessa richiesta. EventBridge legge il registro con le credenziali del chiamante, quindi l'identità che pubblica richiede l'accesso in lettura al registro.
Dopo la deserializzazione, l'evento si comporta come qualsiasi evento JSON pubblicato con. `PutRawEvents` Un filtro con un ambito `DATA` corrisponde ai campi del record deserializzato in base ai nomi dello schema, un trasformatore JSonata li indirizza sotto e un target riceve JSON. `$events.Data` EventBridge imposta anche tre chiavi nel file consegnato. `SystemMetadata`
+ `aws:SchemaId`: l'identificatore dello schema EventBridge deserializzato con; un UUID per Glue, un numero intero per AWS Confluent.
+ `aws:RegistryType`: il registro che ha decodificato l'evento, o. `Glue` `Confluent` Gli eventi pubblicati con `PutEvents` never carry it.
+ `ContentType`: il tipo di contenuto della voce pubblicata, ad esempio`application/avro`.
## Scelta della modalità di EventBridge consegna del payload
`ContentType`seleziona uno dei due percorsi di consegna.
+ **Deserializza in JSON. ** `ContentType`Impostato su `application/avro` o`application/protobuf`. EventBridge deserializza il payload rispetto al registro degli schemi e gli abbonati filtrano`DATA`, trasformano con JSonata e ricevono JSON. Usa questo percorso quando desideri il routing e il rimodellamento basati sui contenuti degli eventi codificati dallo schema.
+ **Consegna byte intatti. ** Impostato `ContentType` su`application/octet-stream`. EventBridge non deserializza né ispeziona il payload, non è coinvolto alcun registro degli schemi e il sottoscrittore riceve i byte esatti che hai inviato. Usa questo percorso quando deserializzi tu stesso il payload sulla destinazione o quando il contenuto è un formato che non viene deserializzato. EventBridge
## Deserializzazione con AWS Registro Glue Schema
`RegistryUri`Impostato sull'ARN del registro, nel formato`arn:aws:glue:{{region}}:{{account-id}}:registry/{{name}}`. Codificate il payload con il serializzatore AWS Glue Schema Registry per la vostra lingua prima della pubblicazione; il serializzatore incorpora il riferimento allo schema utilizzato per risolvere e deserializzare l'evento. EventBridge
EventBridge legge lo schema come chiamante di pubblicazione, quindi concedi all'identità di pubblicazione l'accesso in lettura al registro e ai suoi schemi. La seguente politica concede l'autorizzazione minima, limitata a un registro.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "glue:GetSchemaVersion",
"Resource": [
"arn:aws:glue:us-east-1:111122223333:registry/orders",
"arn:aws:glue:us-east-1:111122223333:schema/orders/*"
]
}
]
}
```
Pubblica i byte codificati dallo schema con l'ARN del registro Glue in. `RegistryUri`
```
aws eventsv2 put-raw-events \
--event-bus-arn arn:aws:events:us-east-1:111122223333:event-busv2/orders/EXAMPLE1234567890abcdef \
--schema-registry-configuration RegistryUri=arn:aws:glue:us-east-1:111122223333:registry/orders \
--entries '[
{
"Data": "{{base64-encoded-avro-bytes}}",
"SystemMetadata": { "ContentType": "application/avro", "EventGroupId": "order-1001" }
}
]'
```
Un sottoscrittore filtra quindi il record deserializzato. Se lo schema Avro ha un campo denominato`orderId`, il filtro seguente corrisponde a un ordine.
```
{ "Scope": "DATA", "Pattern": "{\"orderId\":[\"1001\"]}" }
```
## Deserializzazione con un registro dello schema confluente
Impostato sull'`RegistryUri`URL HTTPS del registro. Un registro HTTPS richiede `SchemaRegistryConfiguration.ConfluentPublicRegistryConfiguration.ConnectionArn` inoltre l'ARN di una EventBridge connessione che contiene la chiave API o le credenziali OAuth del registro. La connessione deve appartenere all'account chiamante; una connessione tra account viene rifiutata. Crea la connessione prima della prima pubblicazione. Codificate il payload con il serializzatore Confluent per la vostra lingua prima della pubblicazione; il serializzatore incorpora il riferimento allo schema utilizzato per risolvere e deserializzare l'evento. EventBridge
EventBridge legge le credenziali del registro tramite la connessione denominata. Concedi all'identità di pubblicazione il permesso di leggere le credenziali di quella connessione.
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "events:RetrieveConnectionCredentials",
"Resource": "arn:aws:events:us-east-1:111122223333:connection/confluent-registry/*"
},
{
"Effect": "Allow",
"Action": ["secretsmanager:GetSecretValue", "secretsmanager:DescribeSecret"],
"Resource": "arn:aws:secretsmanager:us-east-1:111122223333:secret:events!connection/confluent-registry/*",
"Condition": { "Bool": { "aws:ViaAWSService": "true" } }
}
]
}
```
Se il segreto di connessione è crittografato con una AWS KMS chiave gestita dal cliente, `kms:Decrypt` concedi anche tale chiave.
Pubblica i byte codificati dallo schema con l'URL Confluent e l'ARN di connessione.
```
aws eventsv2 put-raw-events \
--event-bus-arn arn:aws:events:us-east-1:111122223333:event-busv2/orders/EXAMPLE1234567890abcdef \
--schema-registry-configuration '{
"RegistryUri": "https://psrc-example.us-east-1.aws.confluent.cloud",
"ConfluentPublicRegistryConfiguration": {
"ConnectionArn": "arn:aws:events:us-east-1:111122223333:connection/confluent-registry/EXAMPLE-1234-5678-abcd"
}
}' \
--entries '[
{
"Data": "{{base64-encoded-protobuf-bytes}}",
"SystemMetadata": { "ContentType": "application/protobuf" }
}
]'
```
### Opzioni di autenticazione della connessione
Configura la connessione con il tipo di autenticazione previsto dal registro Confluent. EventBridge legge solo le intestazioni di autenticazione prodotte dalla connessione; non vede mai il segreto grezzo e aggiorna automaticamente i token OAuth.
**Chiave API. ** Confluent Schema Registry in genere utilizza l'autenticazione HTTP Basic con la chiave API del registro dello schema come nome utente e il segreto API come password.
```
aws events create-connection \
--name confluent-registry \
--authorization-type API_KEY \
--auth-parameters '{
"ApiKeyAuthParameters": {
"ApiKeyName": "Authorization",
"ApiKeyValue": "Basic {{base64(srApiKey:srApiSecret)}}"
}
}'
```
**Credenziali del client OAuth. ** EventBridge recupera e aggiorna il token. Devi `grant_type=client_credentials` includerlo come parametro del corpo; EventBridge non lo aggiunge per te.
```
aws events create-connection \
--name confluent-registry-oauth \
--authorization-type OAUTH_CLIENT_CREDENTIALS \
--auth-parameters '{
"OAuthParameters": {
"AuthorizationEndpoint": "https://{{idp-domain}}/oauth/token",
"HttpMethod": "POST",
"ClientParameters": {
"ClientID": "{{oauth-client-id}}",
"ClientSecret": "{{oauth-client-secret}}"
},
"OAuthHttpParameters": {
"BodyParameters": [
{ "Key": "grant_type", "Value": "client_credentials", "IsValueSecret": false }
]
}
}
}'
```
EventBridge memorizza entrambe le credenziali in un segreto gestito di Secrets Manager (`events!connection/...`), che la connessione legge per tuo conto.
## Consegna di byte senza deserializzazione
Per far sì che un EventBridge payload venga recapitato esattamente come è stato inviato, imposta la voce su. `SystemMetadata.ContentType` `application/octet-stream` Questo è un campo in ogni voce, non un'intestazione HTTP. EventBridge non deserializza né ispeziona i byte e non è coinvolto alcun registro degli schemi, quindi qualsiasi formato funziona, inclusi Avro o Protobuf che deserializzi tu stesso a destinazione. Poiché il contenuto è opaco, un filtro non può eguagliarlo. `DATA` Indirizza tali eventi attivando o attivando i filtri`METADATA`, utilizzando i tasti che hai impostato nella `Metadata` mappa della voce. `SYSTEM_METADATA` Content-based la deduplicazione funziona ancora e esegue l'hashing dei byte esattamente come li hai inviati. In un trasformatore, il payload appare come una stringa Base64; vedi. [Trasformare gli eventi con JSonata](eb-custom-bus-transform.md)
## Filtraggio e trasformazione degli eventi deserializzati
Una volta EventBridge deserializzato un evento in JSON, il payload scorre attraverso la normale pipeline. Un filtro con un ambito di `DATA` corrisponde ai campi deserializzati in base ai relativi nomi di schema e un trasformatore JSonata li indirizza in. `$events.Data` Un evento pubblicato come Avro o Protobuf ottiene lo stesso routing basato sul contenuto e la stessa ridefinizione per abbonato di un evento pubblicato come semplice JSON. Scrivi modelli di filtro in base al JSON deserializzato, tenendo presenti due regole di conversione.
+ **Avro esegue la ** deserializzazione in JSON standard. La conversione è unidirezionale: il JSON non può essere riconvertito in un oggetto Avro.
+ **Protobuf ** deserializza in JSON con i nomi dei campi definiti nello schema, invece di convertirli in camel case come normalmente fanno gli strumenti Protobuf. Corrisponde ai nomi dei campi dello schema.
## Deduplicazione degli eventi tra i formati
EventBridge supporta due modalità di deduplicazione: ID-based, in cui si fornisce un valore all'ingresso e basata `DeduplicationId` sul contenuto, in cui viene EventBridge calcolato un SHA-256 hash del contenuto dell'evento. Per gli eventi deserializzati, la deduplicazione basata sul contenuto esegue l'hashing dei byte di cavo Avro o Protobuf originali, non del JSON deserializzato. Due eventi sono duplicati solo quando i payload originali sono identici ai byte. Lo stesso evento logico pubblicato in formati diversi non viene quindi deduplicato: i byte Avro, i byte Protobuf e il JSON grezzo differiscono istantaneamente anche quando vengono deserializzati sugli stessi dati. Consulta [Ordinamento e deduplicazione degli eventi su un bus di eventi personalizzato](eb-custom-bus-ordering.md).
## Errori
+ Una voce Avro o Protobuf pubblicata senza `SchemaRegistryConfiguration` errori come errore per voce con un of e un messaggio che indica. `ErrorCode` `VALIDATION_ERROR` `SchemaRegistryConfiguration is required` Le altre voci della richiesta non sono interessate.
+ A `ConnectionArn` che non nomina una connessione utilizzabile, o che appartiene a un altro account, non restituisce la voce `VALIDATION_ERROR` e un messaggio che nomina il registro.
+ Uno schema che non può essere trovato o letto, o un payload che non può essere deserializzato rispetto ad esso, non supera tale immissione con. `VALIDATION_ERROR` Questo errore non è ripetibile; correggi la richiesta o l'accesso al registro del chiamante prima della ripubblicazione.
+ Un registro che non può essere raggiunto non risponde alla richiesta con. `SchemaRegistryUnavailableException` Nel percorso OAuth di Confluent, ciò può verificarsi durante l'aggiornamento del token di accesso al registro. Questo errore è temporaneo; riprova la richiesta con il backoff.
Per i risultati per immissione e le linee guida generali sui nuovi tentativi, consulta. [Pubblicazione di eventi su un Event Bus personalizzato](eb-custom-bus-publish.md)