Guida introduttiva al registro degli schemi

Le sezioni seguenti offrono una panoramica e illustrano la configurazione e l'uso del registro degli schemi. Per informazioni su concetti e componenti del registro degli schemi, consulta Registro dello schema di AWS Glue.

Installazione delle SerDe librerie

Nota

Prerequisiti: prima di completare i passaggi riportati di seguito, dovrai disporre di un cluster in esecuzione Amazon Managed Streaming for Apache Kafka (Amazon MSK) o Apache Kafka. I produttori e i consumer devono essere in esecuzione su Java 8 o versione successiva.

Le SerDe librerie forniscono un framework per la serializzazione e la deserializzazione dei dati.

Installerai il serializzatore open source per le applicazioni che producono dati (collettivamente i "serializzatori"). Il serializzatore gestisce la serializzazione, la compressione e l'interazione con il registro degli schemi. Il serializzatore estrae automaticamente lo schema da un record in fase di scrittura in una destinazione compatibile con il registro degli schemi, ad esempio Amazon MSK. Allo stesso modo, installerai il deserializzatore open source sulle applicazioni che consumano dati.

Per installare le librerie su produttori e consumer:

1. All'interno dei file pom.xml dei produttori e dei consumer, aggiungi questa dipendenza tramite il codice qui sotto:

   <dependency>
       <groupId>software.amazon.glue</groupId>
       <artifactId>schema-registry-serde</artifactId>
       <version>1.1.5</version>
   </dependency>

   In alternativa, è possibile clonare il repository Github del registro degli schemi di AWS Glue.

2. Imposta i tuoi produttori con le seguenti proprietà obbligatorie:

   props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName()); // Can replace StringSerializer.class.getName()) with any other key serializer that you may use
   props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, GlueSchemaRegistryKafkaSerializer.class.getName()); 
   props.put(AWSSchemaRegistryConstants.AWS_REGION, "us-east-2");
   properties.put(AWSSchemaRegistryConstants.DATA_FORMAT, "JSON"); // OR "AVRO"

   Se non esistono schemi, è necessario attivare la registrazione automatica (passaggio successivo). Se si dispone di uno schema da applicare, sostituire "my-schema" con il nome dello schema. Se la registrazione automatica dello schema è disattivata deve essere fornito anche "registry-name". Se lo schema viene creato sotto "default-registry", il nome del registro può essere omesso.

3. (Facoltativo) Impostare una di queste proprietà facoltative del produttore. Per descrizioni dettagliate delle proprietà, consultate il file. ReadMe

   props.put(AWSSchemaRegistryConstants.SCHEMA_AUTO_REGISTRATION_SETTING, "true"); // If not passed, uses "false"
   props.put(AWSSchemaRegistryConstants.SCHEMA_NAME, "my-schema"); // If not passed, uses transport name (topic name in case of Kafka, or stream name in case of Kinesis Data Streams)
   props.put(AWSSchemaRegistryConstants.REGISTRY_NAME, "my-registry"); // If not passed, uses "default-registry"
   props.put(AWSSchemaRegistryConstants.CACHE_TIME_TO_LIVE_MILLIS, "86400000"); // If not passed, uses 86400000 (24 Hours)
   props.put(AWSSchemaRegistryConstants.CACHE_SIZE, "10"); // default value is 200
   props.put(AWSSchemaRegistryConstants.COMPATIBILITY_SETTING, Compatibility.FULL); // Pass a compatibility mode. If not passed, uses Compatibility.BACKWARD
   props.put(AWSSchemaRegistryConstants.DESCRIPTION, "This registry is used for several purposes."); // If not passed, constructs a description
   props.put(AWSSchemaRegistryConstants.COMPRESSION_TYPE, AWSSchemaRegistryConstants.COMPRESSION.ZLIB); // If not passed, records are sent uncompressed

   La registrazione automatica registra la versione dello schema nel registro di default ("default-registry"). Se nel passaggio precedente non è stato specificato un SCHEMA_NAME, il nome dell'argomento viene dedotto come SCHEMA_NAME.

   Per ulteriori informazioni sulle modalità di compatibilità, consulta Controllo delle versioni e compatibilità degli schemi.

4. Imposta i tuoi consumer con le seguenti proprietà obbligatorie:

   props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
   props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, GlueSchemaRegistryKafkaDeserializer.class.getName());
   props.put(AWSSchemaRegistryConstants.AWS_REGION, "us-east-2"); // Pass an Regione AWS
   props.put(AWSSchemaRegistryConstants.AVRO_RECORD_TYPE, AvroRecordType.GENERIC_RECORD.getName()); // Only required for AVRO data format

5. (Facoltativo) Imposta queste proprietà facoltative del consumer. Per descrizioni dettagliate delle proprietà, consultate il ReadMe file.

   properties.put(AWSSchemaRegistryConstants.CACHE_TIME_TO_LIVE_MILLIS, "86400000"); // If not passed, uses 86400000
   props.put(AWSSchemaRegistryConstants.CACHE_SIZE, "10"); // default value is 200
   props.put(AWSSchemaRegistryConstants.SECONDARY_DESERIALIZER, "com.amazonaws.services.schemaregistry.deserializers.external.ThirdPartyDeserializer"); // For migration fall back scenario

Utilizzo di AWS CLI per le api del registro degli schemi di AWS Glue

Per utilizzare AWS CLI per le API del registro degli schemi di AWS Glue, assicurati di aggiornare AWS CLI alla versione più recente.

Creazione di un registro

È possibile utilizzare il registro di default o creare tutti i nuovi registri necessari utilizzando le API AWS Glue o la console AWS Glue.

API AWS Glue

È possibile utilizzare questi passaggi per eseguire questa attività utilizzando le API AWS Glue.

Per aggiungere un nuovo registro, utilizza l'API CreateRegistry azione (Python: create_registry). Specifica RegistryName come nome del registro da creare, con una lunghezza massima di 255 caratteri e può contenere solo lettere, numeri, trattini, trattini bassi, simboli del dollaro o cancelletti.

Specificate a Description come stringa di lunghezza non superiore a 2048 byte, corrispondente allo schema di stringa multilinea dell'indirizzo URI.

Facoltativamente, puoi specificare uno o più Tags per il registro, come una matrice di mappe di coppie chiave-valore.

aws glue create-registry --registry-name registryName1 --description description

Al momento della creazione del registro, gli viene assegnato un Amazon Resource Name (ARN) che puoi visualizzare nel RegistryArn della risposta API. Dopo aver creato un registro, crea uno o più schemi per questo registro.

Console AWS Glue

Per aggiungere un nuovo registro nella console AWS Glue:

1. Accedi alla AWS Management Console, quindi apri la console AWS Glue all'indirizzo https://console.aws.amazon.com/glue/.

2. Nel pannello di navigazione, in Data catalog (Catalogo dati), seleziona Schema registries (Registri degli schemi).

3. Scegli Add registry (Aggiungi registro).

4. Inserisci un Registry name (Nome registro) per il registro, composto da lettere, numeri, trattini o trattini bassi. Questo nome non può essere modificato.

5. Inserisci una Description (Descrizione) (facoltativo) per il registro.

6. Facoltativamente, applica uno o più tag al registro. Seleziona Add new tag (Aggiungi nuovo tag) e immetti una Tag key (Chiave di tag) e facoltativamente un Tag value (Valore di tag).

7. Scegli Add registry (Aggiungi registro).

Al momento della creazione del registro, gli viene assegnato un Amazon Resource Name (ARN) che puoi visualizzare selezionando il registro dall'elenco in Schema registries (Registri degli schemi). Dopo aver creato un registro, crea uno o più schemi per questo registro.

Utilizzo di un record specifico (JAVA POJO) per JSON

È possibile utilizzare un POJO (Plain Old Java Object) e passare l'oggetto come record. È simile alla nozione di un record specifico in AVRO. mbknor-jackson-jsonschemaPuò generare uno schema JSON per il POJO passato. Questa libreria può anche inserire informazioni aggiuntive nello schema JSON.

La libreria del registro degli schemi di AWS Glue utilizza il campo "className" inserito nello schema per fornire un nome di classe completamente classificato. Il campo "className" viene utilizzato dal deserializzatore per eseguire la deserializzazione in un oggetto di quella classe.

 Example class :

@JsonSchemaDescription("This is a car")
@JsonSchemaTitle("Simple Car Schema")
@Builder
@AllArgsConstructor
@EqualsAndHashCode
// Fully qualified class name to be added to an additionally injected property
// called className for deserializer to determine which class to deserialize
// the bytes into
@JsonSchemaInject(
        strings = {@JsonSchemaString(path = "className",
                value = "com.amazonaws.services.schemaregistry.integrationtests.generators.Car")}
)
// List of annotations to help infer JSON Schema are defined by https://github.com/mbknor/mbknor-jackson-jsonSchema
public class Car {
    @JsonProperty(required = true)
    private String make;

    @JsonProperty(required = true)
    private String model;

    @JsonSchemaDefault("true")
    @JsonProperty
    public boolean used;

    @JsonSchemaInject(ints = {@JsonSchemaInt(path = "multipleOf", value = 1000)})
    @Max(200000)
    @JsonProperty
    private int miles;

    @Min(2000)
    @JsonProperty
    private int year;

    @JsonProperty
    private Date purchaseDate;

    @JsonProperty
    @JsonFormat(shape = JsonFormat.Shape.NUMBER)
    private Date listedDate;

    @JsonProperty
    private String[] owners;

    @JsonProperty
    private Collection<Float> serviceChecks;

    // Empty constructor is required by Jackson to deserialize bytes
    // into an Object of this class
    public Car() {}
}

Creazione di uno schema

Puoi creare uno schema utilizzando le API AWS Glue o la console AWS Glue.

API AWS Glue

È possibile utilizzare questi passaggi per eseguire questa attività utilizzando le API AWS Glue.

Per aggiungere un nuovo schema, utilizza l'API CreateSchema azione (Python: create_schema).

Specifica una struttura RegistryId per indicare un registro per lo schema. Oppure, ometti il RegistryId per utilizzare il registro di default.

Specifica un SchemaName composto da lettere, numeri, trattini o trattini bassi e DataFormat come AVRO o JSON. Una volta impostato su uno schema, DataFormat non è modificabile.

Specifica una modalità di Compatibility:

• Backward (consigliato): il consumer può leggere sia la versione attuale che quella precedente.

• Backward all: il consumer può leggere la versione attuale e tutte quelle precedenti.

• Forward: il consumer può leggere sia la versione attuale che quella successiva.

• Forward all: il consumer può leggere sia la versione attuale che tutte quelle successive.

• Full: combinazione di Backward e Forward.

• Full all: combinazione di Backward all e Forward all.

• None: non vengono eseguiti controlli di compatibilità.

• Disabled: impedisce il controllo delle versioni per questo schema.

Facoltativamente, specifica i Tags per lo schema.

Specifica un valore di SchemaDefinition per definire lo schema in formato dati Avro, JSON o Protobuf. Consulta questi esempi.

Per il formato dati Avro:

aws glue create-schema --registry-id RegistryName="registryName1" --schema-name testschema --compatibility NONE --data-format AVRO --schema-definition "{\"type\": \"record\", \"name\": \"r1\", \"fields\": [ {\"name\": \"f1\", \"type\": \"int\"}, {\"name\": \"f2\", \"type\": \"string\"} ]}"

aws glue create-schema --registry-id RegistryArn="arn:aws:glue:us-east-2:901234567890:registry/registryName1" --schema-name testschema --compatibility NONE --data-format AVRO  --schema-definition "{\"type\": \"record\", \"name\": \"r1\", \"fields\": [ {\"name\": \"f1\", \"type\": \"int\"}, {\"name\": \"f2\", \"type\": \"string\"} ]}"

Per il formato dati JSON:

aws glue create-schema --registry-id RegistryName="registryName" --schema-name testSchemaJson --compatibility NONE --data-format JSON --schema-definition "{\"$schema\": \"http://json-schema.org/draft-07/schema#\",\"type\":\"object\",\"properties\":{\"f1\":{\"type\":\"string\"}}}"

aws glue create-schema --registry-id RegistryArn="arn:aws:glue:us-east-2:901234567890:registry/registryName" --schema-name testSchemaJson --compatibility NONE --data-format JSON --schema-definition "{\"$schema\": \"http://json-schema.org/draft-07/schema#\",\"type\":\"object\",\"properties\":{\"f1\":{\"type\":\"string\"}}}"

Per il formato dati Protobuf:

aws glue create-schema --registry-id RegistryName="registryName" --schema-name testSchemaProtobuf --compatibility NONE --data-format PROTOBUF --schema-definition "syntax = \"proto2\";package org.test;message Basic { optional int32 basic = 1;}"

aws glue create-schema --registry-id RegistryArn="arn:aws:glue:us-east-2:901234567890:registry/registryName" --schema-name testSchemaProtobuf --compatibility NONE --data-format PROTOBUF --schema-definition "syntax = \"proto2\";package org.test;message Basic { optional int32 basic = 1;}"

Console AWS Glue

Per aggiungere un nuovo schema utilizzando la console AWS Glue:

1. Accedi alla Console di gestione AWS e apri la console AWS Glue all'indirizzo https://console.aws.amazon.com/glue/.

2. Nel pannello di navigazione, in Data catalog (Catalogo dati), seleziona Schema (Schemi).

3. Seleziona Aggiungi schema (Aggiungi schema).

4. Inserisci uno Schema name (Nome schema) composto da lettere, numeri, trattini, trattini bassi, simboli di dollaro o cancelletti. Questo nome non può essere modificato.

5. Seleziona il registro in cui lo schema verrà archiviato dal menu a discesa. Il registro padre non può essere modificato dopo la creazione.

6. Lascia Data format (Formato dei dati) come Apache Avro o JSON. Questo formato si applica a tutte le versioni di questo schema.

7. Scegli una Compatibility mode (Modalità Compatibilità).

   • Backward (consigliato): il ricevitore può leggere sia la versione attuale che quella precedente.

   • Backward all: il ricevitore può leggere la versione attuale e tutte quelle precedenti.

   • Forward: il mittente può scrivere sia la versione attuale che quelle precedenti.

   • Forward All: il mittente può scrivere sia la versione attuale che tutte quelle precedenti.

   • Full: combinazione di Backward e Forward.

   • Full All: combinazione di Backward All e Forward All.

   • None: non vengono eseguiti controlli di compatibilità.

   • Disabled: impedisce il controllo delle versioni per questo schema.

8. Immetti un a Description (Descrizione) facoltativa per il registro con un massimo di 250 caratteri.

   

9. Facoltativamente, applica uno o più tag allo schema. Seleziona Add new tag (Aggiungi nuovo tag) e immetti una Tag key (Chiave di tag) e facoltativamente un Tag value (Valore di tag).

10. Immetti o incolla lo schema iniziale nella casella First schema version (Prima versione dello schema).

    Per il formato Avro, consulta Utilizzare il formato di dati Avro

    Per il formato JSON, consulta Utilizzare il formato di dati JSON

11. Facoltativamente, scegli Add metadata (Aggiungi metadata) per aggiungere metadati di versione per annotare o classificare la versione dello schema.

12. Scegli Create schema and version (Crea schema e versione).

Lo schema viene creato e viene visualizzato nell'elenco sotto Schemas (Schemi).

Utilizzare il formato di dati Avro

Avro fornisce servizi di serializzazione dei dati e scambio di dati. Avro memorizza la definizione dei dati in formato JSON semplificando la lettura e l'interpretazione. I dati stessi sono memorizzati in formato binario.

Per informazioni sulla definizione di uno schema Apache Avro, consulta la specifica di Apache Avro.

Utilizzare il formato di dati JSON

I dati possono essere serializzati con il formato JSON. Il formato di schemi JSON definisce lo standard per il formato di schemi JSON.

Aggiornamento di uno schema o di un registro

Una volta creati, è possibile modificare gli schemi, le versioni degli schemi o il registro.

Aggiornamento di un registro

È possibile aggiornare un registro utilizzando l'API AWS Glue o la console AWS Glue. Il nome di un registro esistente non può essere modificato. È possibile modificare la descrizione di un registro.

API AWS Glue

Per aggiornare un registro esistente, utilizza l'API UpdateRegistry azione (Python: update_registry).

Specifica una struttura RegistryId per indicare il registro da aggiornare. Passa una Description per modificare la descrizione di un registro.

aws glue update-registry --description updatedDescription --registry-id RegistryArn="arn:aws:glue:us-east-2:901234567890:registry/registryName1"

Console AWS Glue

Per aggiornare un registro utilizzando la console AWS Glue:

1. Accedi alla AWS Management Console, quindi apri la console AWS Glue all'indirizzo https://console.aws.amazon.com/glue/.

2. Nel pannello di navigazione, in Data catalog (Catalogo dati), seleziona Schema registries (Registri degli schemi).

3. Scegli un registro dall'elenco dei registri selezionando la relativa casella.

4. Dal menu Action (Operazioni), seleziona Edit registry (Modifica registro).

Aggiornamento di uno schema

È possibile aggiornare la descrizione o l'impostazione di compatibilità per uno schema.

Per aggiornare uno schema esistente, utilizza l'API UpdateSchema azione (Python: update_schema).

Specifica una struttura SchemaId per indicare lo schema da aggiornare. Deve essere fornito VersionNumber o Compatibility.

Esempio di codice 11:

aws glue update-schema --description testDescription --schema-id SchemaName="testSchema1",RegistryName="registryName1" --schema-version-number LatestVersion=true --compatibility NONE

aws glue update-schema --description testDescription --schema-id SchemaArn="arn:aws:glue:us-east-2:901234567890:schema/registryName1/testSchema1" --schema-version-number LatestVersion=true --compatibility NONE

Aggiunta di una versione dello schema

Quando si aggiunge una versione dello schema, è necessario confrontare le versioni per assicurarsi che il nuovo schema venga accettato.

Per aggiungere una nuova versione a uno schema esistente, utilizza l'API RegisterSchemaVersion azione (Python: register_schema_version).

Specifica una struttura SchemaId per indicare lo schema per il quale si desidera aggiungere una versione e un valore di SchemaDefinition per definire lo schema.

Esempio di codice 12:

aws glue register-schema-version --schema-definition "{\"type\": \"record\", \"name\": \"r1\", \"fields\": [ {\"name\": \"f1\", \"type\": \"int\"}, {\"name\": \"f2\", \"type\": \"string\"} ]}" --schema-id SchemaArn="arn:aws:glue:us-east-1:901234567890:schema/registryName/testschema"

aws glue register-schema-version --schema-definition "{\"type\": \"record\", \"name\": \"r1\", \"fields\": [ {\"name\": \"f1\", \"type\": \"int\"}, {\"name\": \"f2\", \"type\": \"string\"} ]}" --schema-id SchemaName="testschema",RegistryName="testregistry"

1. Accedi alla AWS Management Console, quindi apri la console AWS Glue all'indirizzo https://console.aws.amazon.com/glue/.

2. Nel pannello di navigazione, in Data catalog (Catalogo dati), seleziona Schema (Schemi).

3. Scegli lo schema dall'elenco degli schemi selezionando la relativa casella.

4. Seleziona uno o più schemi dall'elenco selezionando le caselle.

5. Nel menu Action (Operazioni), seleziona Register new version (Registra nuova versione).

6. Nella casella New version (Nuova versione), immetti o incolla il nuovo schema.

7. Seleziona Compare with previous version (Confronta con la versione precedente) per visualizzare le differenze con la versione precedente dello schema.

8. Facoltativamente, scegli Add metadata (Aggiungi metadata) per aggiungere metadati di versione per annotare o classificare la versione dello schema. Inserisci Key (Chiave) e facoltativamente Value (Valore).

9. Scegli Register version (Registra versione).

La versione degli schemi viene visualizzata nell'elenco delle versioni. Se la versione ha modificato la modalità di compatibilità, la versione verrà contrassegnata come checkpoint.

Esempio di confronto tra le versioni di uno schema

Selezionando Compare with previous version (Confronta con la versione precedente), le versioni precedenti e quelle nuove verranno mostrate insieme. Le informazioni modificate saranno evidenziate come segue:

• Giallo: indica le informazioni modificate.

• Verde: indica il contenuto aggiunto nella versione più recente.

• Rosso: indica il contenuto rimosso nella versione più recente.

È possibile eseguire il confronto anche con le versioni precedenti.

Eliminazione di uno schema o di un registro

L'eliminazione di uno schema, di una versione dello schema o di un registro è un'azione permanente che non può essere annullata.

Eliminazione di uno schema

Puoi eliminare uno schema quando non questo verrà più utilizzato all'interno di un registro, utilizzando la AWS Management Console o l'API DeleteSchema azione (Python: delete_schema).

L'eliminazione di uno o più schemi è un'azione permanente che non può essere annullata. Accertati che lo schema o gli schemi non siano più necessari.

Per eliminare uno schema dal registro, chiama l'API DeleteSchema azione (Python: delete_schema), specificando la struttura SchemaId per identificare lo schema.

Ad esempio:

aws glue delete-schema --schema-id SchemaArn="arn:aws:glue:us-east-2:901234567890:schema/registryName1/schemaname"

aws glue delete-schema --schema-id SchemaName="TestSchema6-deleteschemabyname",RegistryName="default-registry"

Console AWS Glue

Per eliminare uno schema dalla console AWS Glue:

1. Accedi alla AWS Management Console, quindi apri la console AWS Glue all'indirizzo https://console.aws.amazon.com/glue/.

2. Nel pannello di navigazione, in Data catalog (Catalogo dati), seleziona Schema registries (Registri degli schemi).

3. Scegli il registro che contiene lo schema dall'elenco dei registri.

4. Seleziona uno o più schemi dall'elenco selezionando le caselle.

5. Dal menu Action (Operazioni), scegli Delete schema (Elimina schema).

6. Inserisci il testo Delete nel campo per confermare l'eliminazione.

7. Seleziona Delete (Elimina).

Gli schemi specificati vengono eliminati dal registro.

Eliminazione di una versione dello schema

Man mano che gli schemi si accumulano nel registro, puoi eliminare le versioni indesiderate utilizzando la AWS Management Console o l'API DeleteSchemaVersions azione (Python: delete_schema_versions). L'eliminazione di una o più versioni degli schemi è un'azione permanente che non può essere annullata. Accertati che le versioni degli schemi non siano più necessarie.

Durante l'eliminazione delle versioni degli schemi, tieni presente i seguenti vincoli:

• Non è possibile eliminare una versione con segno di spunta.

• L'intervallo di versioni contigue non può essere superiore a 25.

• La versione più recente non deve trovarsi nello stato in sospeso.

Specifica la struttura SchemaId per identificare lo schema e specifica Versions come intervallo di versioni da eliminare. Per ulteriori informazioni sulla specifica di una versione o un intervallo di versioni, consulta DeleteRegistry azione (Python: delete_registry). Le versioni degli schemi specificate vengono eliminate dal registro.

Chiamare l'API ListSchemaVersions azione (Python: list_schema_versions) dopo questa chiamata elencherà lo stato delle versioni eliminate.

Ad esempio:

aws glue delete-schema-versions --schema-id SchemaName="TestSchema6",RegistryName="default-registry" --versions "1-1"

aws glue delete-schema-versions --schema-id SchemaArn="arn:aws:glue:us-east-2:901234567890:schema/default-registry/TestSchema6-NON-Existent" --versions "1-1"

1. Accedi alla AWS Management Console, quindi apri la console AWS Glue all'indirizzo https://console.aws.amazon.com/glue/.

2. Nel pannello di navigazione, in Data catalog (Catalogo dati), seleziona Schema registries (Registri degli schemi).

3. Scegli il registro che contiene lo schema dall'elenco dei registri.

4. Seleziona uno o più schemi dall'elenco selezionando le caselle.

5. Dal menu Action (Operazioni), scegli Delete schema (Elimina schema).

6. Inserisci il testo Delete nel campo per confermare l'eliminazione.

7. Seleziona Delete (Elimina).

Le versioni degli schemi specificate vengono eliminate dal registro.

Eliminazione di un registro

È possibile eliminare un registro quando gli schemi in esso contenuti non devono più essere organizzati in tale registro. Sarà necessario riassegnare tali schemi a un altro registro.

L'eliminazione di uno o più registri è un'azione permanente che non può essere annullata. Accertati che il registro o i registri non siano più necessari.

Il registro predefinito può essere eliminato utilizzando AWS CLI.

API AWS Glue

Per eliminare l'intero registro, inclusi gli schemi e tutte le relative versioni, chiama l'API DeleteRegistry azione (Python: delete_registry). Specifica una struttura RegistryId per identificare lo schema.

Ad esempio:

aws glue delete-registry --registry-id RegistryArn="arn:aws:glue:us-east-2:901234567890:registry/registryName1"

aws glue delete-registry --registry-id RegistryName="TestRegistry-deletebyname"

Per ottenere lo stato dell'operazione di eliminazione, è possibile chiamare l'API GetRegistry dopo la chiamata asincrona.

Console AWS Glue

Per eliminare un registro dalla console AWS Glue:

1. Accedi alla AWS Management Console, quindi apri la console AWS Glue all'indirizzo https://console.aws.amazon.com/glue/.

2. Nel pannello di navigazione, in Data catalog (Catalogo dati), seleziona Schema registries (Registri degli schemi).

3. Scegli un registro dall'elenco selezionando una casella.

4. Dal menu Action (Operazioni), seleziona Delete registry (Elimina registro).

5. Inserisci il testo Delete nel campo per confermare l'eliminazione.

6. Seleziona Delete (Elimina).

I registri selezionati vengono eliminati da AWS Glue.

Esempi di IAM per i serializzatori

Nota

Le policy gestite da AWS concedono le autorizzazioni necessarie per casi di utilizzo comuni. Per informazioni sull'utilizzo delle policy gestite per gestire il registro degli schemi, consulta AWS politiche gestite (predefinite) per AWS Glue.

Per i serializzatori, è necessario creare una policy minima simile a quella riportata di seguito per avere la possibilità di trovare lo schemaVersionId per una determinata definizione dello schema. Nota, per leggere gli schemi nel registro è necessario disporre delle autorizzazioni di lettura. È possibile limitare i registri che possono essere letti utilizzando la clausola Resource.

Esempio di codice 13:

{
    "Sid" : "GetSchemaByDefinition",
    "Effect" : "Allow",
    "Action" : 
	[
        "glue:GetSchemaByDefinition"
    ],
        "Resource" : ["arn:aws:glue:us-east-2:012345678:registry/registryname-1",
                      "arn:aws:glue:us-east-2:012345678:schema/registryname-1/schemaname-1",
                      "arn:aws:glue:us-east-2:012345678:schema/registryname-1/schemaname-2"
                     ]  
}

Inoltre, è possibile consentire ai produttori di creare nuovi schemi e versioni includendo i seguenti metodi aggiuntivi. Nota, devi essere in grado di ispezionare il registro per aggiungere/rimuovere/modificare gli schemi al suo interno. È possibile limitare i registri che possono essere ispezionati utilizzando la clausola Resource.

Esempio di codice 14:

{
    "Sid" : "RegisterSchemaWithMetadata",
    "Effect" : "Allow",
    "Action" : 
	[
        "glue:GetSchemaByDefinition",
        "glue:CreateSchema",
        "glue:RegisterSchemaVersion",
        "glue:PutSchemaVersionMetadata",
    ],
    "Resource" : ["arn:aws:glue:aws-region:123456789012:registry/registryname-1",
                  "arn:aws:glue:aws-region:123456789012:schema/registryname-1/schemaname-1",
                  "arn:aws:glue:aws-region:123456789012:schema/registryname-1/schemaname-2"
                 ]  
}

Esempi di IAM per i deserializzatori

Per i deserializzatori (lato consumer), è necessario creare una policy simile a quella riportata di seguito per consentire al deserializzatore di recuperare lo schema dal registro degli schemi per la deserializzazione. Nota, devi essere in grado di ispezionare il registro per recuperare gli schemi al suo interno.

Esempio di codice 15:

{
    "Sid" : "GetSchemaVersion",
    "Effect" : "Allow",
    "Action" : 
	[
        "glue:GetSchemaVersion"
    ],
    "Resource" : ["*"]  
}

Connettività privata utilizzando AWS PrivateLink

È possibile utilizzare AWS PrivateLink per collegare il VPC del produttore di dati ad AWS Gluedefinendo di un endpoint VPC dell'interfaccia per AWS Glue. Quando utilizzi un endpoint VPC di interfaccia, la comunicazione tra il VPC e AWS Glue avviene completamente all'interno della rete AWS. Per ulteriori informazioni, consulta la pagina relativa all'utilizzo di AWS Glue con endpoint VPC.

Accesso ai CloudWatch parametri di Amazon

CloudWatch I parametri di Amazon sono disponibili come parte CloudWatch del piano gratuito. Puoi accedere a queste metriche nella Console. CloudWatch Le metriche a livello di API includono CreateSchema (Successo e latenza), (Successo e latenza) GetSchemaByDefinition, (Successo e latenza), GetSchemaVersion (Successo e latenza), RegisterSchemaVersion (Successo e latenza). PutSchemaVersionMetadata Le metriche a livello di risorsa includono Registry. ThrottledByLimit, SchemaVersion. ThrottledByLimit, SchemaVersion .Taglia.

Esempio di modello AWS CloudFormation per il registro degli schemi

Di seguito è riportato un modello di esempio per la creazione di risorse del registro degli schemi in AWS CloudFormation. Per creare questo stack nell'account, copia il modello sopra in un file SampleTemplate.yaml ed esegui il comando seguente:

aws cloudformation create-stack --stack-name ABCSchemaRegistryStack --template-body "'cat SampleTemplate.yaml'"

Questo esempio usa AWS::Glue::Registry per creare un registro, AWS::Glue::Schema per creare uno schema, AWS::Glue::SchemaVersionper creare una versione dello schema e AWS::Glue::SchemaVersionMetadata per popolare i metadati della versione dello schema.

Description: "A sample CloudFormation template for creating Schema Registry resources."
Resources:
  ABCRegistry:
    Type: "AWS::Glue::Registry"
    Properties:
      Name: "ABCSchemaRegistry"
      Description: "ABC Corp. Schema Registry"
      Tags:
        - Key: "Project"
          Value: "Foo"
  ABCSchema:
    Type: "AWS::Glue::Schema"
    Properties:
      Registry:
        Arn: !Ref ABCRegistry
      Name: "TestSchema"
      Compatibility: "NONE"
      DataFormat: "AVRO"
      SchemaDefinition: >
        {"namespace":"foo.avro","type":"record","name":"user","fields":[{"name":"name","type":"string"},{"name":"favorite_number","type":"int"}]}
      Tags:
        - Key: "Project"
          Value: "Foo"
  SecondSchemaVersion:
    Type: "AWS::Glue::SchemaVersion"
    Properties:
      Schema:
        SchemaArn: !Ref ABCSchema
      SchemaDefinition: >
        {"namespace":"foo.avro","type":"record","name":"user","fields":[{"name":"status","type":"string", "default":"ON"}, {"name":"name","type":"string"},{"name":"favorite_number","type":"int"}]}
  FirstSchemaVersionMetadata:
    Type: "AWS::Glue::SchemaVersionMetadata"
    Properties:
      SchemaVersionId: !GetAtt ABCSchema.InitialSchemaVersionId
      Key: "Application"
      Value: "Kinesis"
  SecondSchemaVersionMetadata:
    Type: "AWS::Glue::SchemaVersionMetadata"
    Properties:
      SchemaVersionId: !Ref SecondSchemaVersion
      Key: "Application"
      Value: "Kinesis"