Démarrer avec le registre de schémas - AWS Glue
Installation de SerDe bibliothèquesUtilisation de la AWS CLI pour les API de registre de schémas AWS GlueCréation d'un registreTraiter un enregistrement spécifique (JAVA POJO) pour JSONCréation d'un schémaMise à jour d'un schéma ou d'un registreSuppression d'un schéma ou d'un registreExemples d'IAM pour les sérialiseursExemples d'IAM pour les désérialiseursConnectivité privée utilisant AWS PrivateLinkAccès aux CloudWatch métriques d'AmazonExemple de modèle AWS CloudFormation pour le registre de schémas

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Démarrer avec le registre de schémas

Les sections suivantes fournissent une présentation et vous expliquent comment configurer et utiliser le registre de schémas. Pour plus d'informations sur les concepts et les composants du registre de schémas, veuillez consulter Registre de schémas AWS Glue.

Installation de SerDe bibliothèques

Note

Prérequis : avant d'effectuer les étapes suivantes, vous devez avoir un Amazon Managed Streaming for Apache Kafka(Amazon MSK) ou un cluster Apache Kafka en cours d'exécution. Vos applications producteur et consommateur doivent utiliser Java 8 ou une version supérieure.

Les SerDe bibliothèques fournissent un cadre pour la sérialisation et la désérialisation des données.

Vous allez installer le sérialiseur open source pour vos applications produisant des données (collectivement les « sérialiseurs »). Le sérialiseur gère la sérialisation, la compression et l'interaction avec le registre de schémas. Le sérialiseur extrait automatiquement le schéma d'un enregistrement en cours d'écriture vers une destination compatible avec le registre de schémas, telle qu'Amazon MSK. De même, vous allez installer le désérialiseur open source sur vos applications consommant des données.

Pour installer les bibliothèques sur les applications producteur et consommateur :

  1. Dans les fichiers pom.xml des applications producteur et consommateur, ajoutez cette dépendance via le code ci-dessous :

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

    Vous pouvez également cloner le référentiel Github du registre de schémas AWS Glue.

  2. Configurez vos applications producteur avec les propriétés requises suivantes :

    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"

    S'il n'existe aucun schéma existant, l'enregistrement automatique doit être activé (étape suivante). Si vous avez un schéma que vous souhaitez appliquer, remplacez « my-schema » par le nom de votre schéma. La valeur « registry-name » doit également être fournie si l'enregistrement automatique du schéma est désactivé. Si le schéma est créé sous la valeur « default-registry », le nom du registre peut être omis.

  3. (Facultatif) Définissez l'une de ces propriétés de producteur facultatives. Pour une description détaillée des propriétés, consultez le ReadMe fichier.

    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

    L'enregistrement automatique enregistre la version du schéma sous le registre par défaut (« default-registry »). Si une valeur SCHEMA_NAME n'est pas spécifiée à l'étape précédente, le nom de la rubrique est alors déduit comme étant SCHEMA_NAME.

    Pour de plus amples informations sur les modes de compatibilité, veuillez consulter Gestion des versions et compatibilité des schémas.

  4. Configurez vos applications consommateur avec les propriétés requises suivantes :

    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 Région AWS
props.put(AWSSchemaRegistryConstants.AVRO_RECORD_TYPE, AvroRecordType.GENERIC_RECORD.getName()); // Only required for AVRO data format

  5. (Facultatif) Définissez ces propriétés d'application consommateur facultatives. Pour une description détaillée des propriétés, consultez le ReadMe fichier.

    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

Utilisation de la AWS CLI pour les API de registre de schémas AWS Glue

Pour utiliser la AWS CLI pour les API du registre de schémas AWS Glue, assurez-vous de mettre à jour votre AWS CLI vers la dernière version.

Création d'un registre

Vous pouvez utiliser le registre par défaut ou créer autant de nouveaux registres que nécessaire à l'aide des API AWS Glue ou de la console AWS Glue.

API AWS Glue

Vous pouvez suivre cette procédure pour effectuer cette tâche à l'aide des API AWS Glue.

Pour ajouter un nouveau registre, utilisez l'API CreateRegistry action (Python : create_registry). Spécifiez RegistryName comme nom du registre à créer, avec une longueur maximale de 255, contenant uniquement des lettres, des chiffres, des traits d'union, des traits de soulignement, le symbole dollar ou le dièse.

Spécifiez a Description sous forme de chaîne d'une longueur maximale de 2 048 octets, correspondant au modèle de chaîne multiligne de l'adresse URI.

Vous pouvez également spécifier une ou plusieurs Tags pour votre registre, sous forme de tableau de mappage de paires clé-valeur.

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

Lorsque votre registre est créé, il se voit attribuer un Amazon Resource Name (ARN), que vous pouvez consulter dans le RegistryArn de la réponse de l'API. Maintenant que vous avez créé un registre, créez un ou plusieurs schémas pour ce registre.

Console AWS Glue 

Pour ajouter un nouveau registre dans la console AWS Glue :

  1. Connectez-vous à la AWS Management Console et ouvrez la console AWS Glue à l'adresse https://console.aws.amazon.com/glue/.

  2. Dans le panneau de navigation, sous Data catalog (Catalogue de données), choisissez Schema registries (Registres de schémas).

  3. Choisissez Add registry (Ajouter un registre).

  4. Saisissez un nom du registre à donner au registre, composé de lettres, de chiffres, de traits d'union et de traits de soulignement. Ce nom ne peut pas être modifié.

  5. Saisissez une description (facultatif) pour le registre.

  6. Si vous le souhaitez, appliquez une ou plusieurs balises à votre registre. Choisissez Add new tag (Ajouter une nouvelle balise) et spécifiez une clé de balise, et éventuellement une valeur de balise.

  7. Choisissez Add registry (Ajouter un registre).

Exemple de création d'un registre.

Lorsque votre registre est créé, un Amazon Resource Name (ARN) lui est attribué, que vous pouvez consulter en choisissant le registre dans la liste Schema registries (Registres de schémas). Maintenant que vous avez créé un registre, créez un ou plusieurs schémas pour ce registre.

Traiter un enregistrement spécifique (JAVA POJO) pour JSON

Vous pouvez utiliser un ancien objet Java simple (POJO) et transmettre l'objet en tant qu'enregistrement. Ceci est similaire à la notion d'enregistrement spécifique dans AVRO. Ils mbknor-jackson-jsonschemapeuvent générer un schéma JSON pour le POJO transmis. Cette bibliothèque peut également injecter des informations supplémentaires dans le schéma JSON.

La bibliothèque de registre de schémas AWS Glue utilise le champ « ClassName » injecté dans le schéma pour fournir un nom de classe entièrement classifié. Le champ « ClassName » est utilisé par le désérialiseur pour désérialiser dans un objet de cette 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() {}
}

Création d'un schéma

Vous pouvez créer un schéma à l'aide des API AWS Glue ou de la console AWS Glue.

API AWS Glue

Vous pouvez suivre cette procédure pour effectuer cette tâche à l'aide des API AWS Glue.

Pour ajouter un nouveau schéma, utilisez l'API CreateSchema action (Python : créer_schéma).

Spécifiez une structure RegistryId pour indiquer un registre pour le schéma. Ou, omettez la valeur RegistryId pour utiliser le registre par défaut.

Spécifiez une valeur SchemaName composée de lettres, de chiffres, de traits d'union et de traits de soulignement, ainsi qu'une valeur DataFormat comme AVRO ou JSON. Une fois la valeur DataFormat définie sur un schéma, elle n'est pas modifiable.

Spécifiez un mode Compatibility :

  • Backward (Descendant) (recommandé) — L'application consommateur peut lire à la fois la version actuelle et précédente.

  • Backward all (Descendant tout) — L'application consommateur peut lire les versions actuelles et toutes les versions précédentes.

  • Forward (Ascendant) — L'application consommateur peut lire à la fois la version actuelle et la version ultérieure.

  • Forward all (Ascendant tout) — L'application consommateur peut lire à la fois les versions actuelles et les versions ultérieures.

  • Full (Complet) — Combinaison de Forward (Ascendant) et de Backward (Descendant).

  • Full all (Complet tout) — Combinaison de Backward all (Descendant tout) et de Forward all (Ascendant tout).

  • None (Aucun) — Aucune vérification de compatibilité n'est effectuée.

  • Disabled (Désactivé) — Empêche toute gestion des versions pour ce schéma.

Le cas échéant, spécifiez Tags pour votre schéma.

Spécifiez une valeur SchemaDefinition pour définir le schéma au format de données Avro, JSON ou Protobuf. Veuillez consulter les exemples.

Pour le format de données 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\"} ]}"

Pour le format de données 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\"}}}"

Pour le format de données 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 

Pour ajouter un nouveau schéma à l'aide de la console AWS Glue :

  1. Connectez-vous à AWS Management Console et ouvrez la console AWS Glue à l'adresse https://console.aws.amazon.com/glue/.

  2. Dans le panneau de navigation, sous Data catalog (Catalogue de données), choisissez Schemas (Schémas).

  3. Choisissez Add schema (Ajouter un schéma).

  4. Saisissez un nom de schéma, composé de lettres, de chiffres, de traits d'union, de traits de soulignement, de symboles dollar ou de dièses. Ce nom ne peut pas être modifié.

  5. Cliquez sur l'onglet Registry (Registre) où le schéma sera stocké à partir du menu déroulant. Le registre parent ne peut pas être modifié après la création.

  6. Quitter le format de données en tant qu'Apache Avro ou JSON. Ce format s'applique à toutes les versions de ce schéma.

  7. Choisissez un mode de compatibilité.

    • Backward (Descendant) (recommandé) — Le récepteur peut lire à la fois les versions actuelles et précédentes.

    • Backward All (Descendant tout) — Le récepteur peut lire les versions actuelles et toutes les versions précédentes.

    • Forward (Ascendant) — L'expéditeur peut écrire à la fois les versions actuelles et précédentes.

    • Forward all (Ascendant tout) — L'expéditeur peut écrire la version actuelle et toutes les versions précédentes.

    • Full (Complet) — Combinaison de Forward (Ascendant) et de Backward (Descendant).

    • Full All (Complet tout) — Combinaison de Backward All (Descendant tout) et de Forward All (Ascendant tout).

    • None (Aucun) — Aucune vérification de compatibilité n'est effectuée.

    • Disabled (Désactivé) — Empêche toute gestion des versions pour ce schéma.

  8. Saisissez une description facultative pour le registre de 250 caractères maximum.

    Exemple de création d'un schéma.

  9. Si vous le souhaitez, appliquez une ou plusieurs balises à votre schéma. Choisissez Add new tag (Ajouter une nouvelle balise) et spécifiez une clé de balise, et éventuellement une valeur de balise.

  10. Dans la case First schema version (Première version de schéma), saisissez ou collez votre schéma initial.

    Pour le format Avro, voir Utilisation du format de données Avro

    Pour le format JSON, voir Utilisation du format de données JSON

  11. Choisissez éventuellement Add metadata (Ajouter des métadonnées) pour ajouter des métadonnées de version afin d'annoter ou de classer votre version de schéma.

  12. Choisissez Create schema and version (Créer un schéma et une version).

Exemple de création d'un schéma.

Le schéma est créé et apparaît dans la liste sous Schemas (Schémas).

Utilisation du format de données Avro

Avro fournit des services de sérialisation et d'échange de données. Avro stocke la définition des données au format JSON, ce qui la rend facile à lire et à interpréter. Les données elles-mêmes sont stockées au format binaire.

Pour plus d'informations sur la définition d'un schéma Apache Avro, veuillez consulter la spécification d'Apache Avro.

Utilisation du format de données JSON

Les données peuvent être sérialisées au format JSON. Le format de schéma JSON définit la norme pour le format de schéma JSON.

Mise à jour d'un schéma ou d'un registre

Une fois créés, vous pouvez modifier vos schémas, vos versions de schéma ou votre registre.

Mise à jour d'un registre

Vous pouvez mettre à jour un registre à l'aide des API AWS Glue ou de la console AWS Glue. Le nom d'un registre existant ne peut pas être modifié. Vous pouvez modifier la description d'un registre.

API AWS Glue

Pour mettre à jour un registre existant, utilisez l'API UpdateRegistry action (Python : update_registry).

Spécifiez une structure RegistryId pour indiquer le registre que vous souhaitez mettre à jour. Transmettez une Description pour modifier la description d'un registre.

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

Pour mettre à jour un registre à l'aide de la console AWS Glue :

  1. Connectez-vous à la AWS Management Console et ouvrez la console AWS Glue à l'adresse https://console.aws.amazon.com/glue/.

  2. Dans le panneau de navigation, sous Data catalog (Catalogue de données), choisissez Schema registries (Registres de schémas).

  3. Sélectionnez un registre dans la liste des registres, en cochant sa case.

  4. Dans le menu Action, choisissez Edit registry (Modifier un registre).

Mise à jour d'un schéma

Vous pouvez mettre à jour le paramètre de description ou de compatibilité pour un schéma.

Pour mettre à jour un schéma existant, utilisez l'API UpdateSchema action (Python : update_schema).

Spécifiez une structure SchemaId pour indiquer le schéma que vous souhaitez mettre à jour. VersionNumber ou Compatibility doit être fourni.

Exemple de code 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

Ajout d'une version de schéma

Lorsque vous ajoutez une version de schéma, vous devez comparer les versions pour vous assurer que le nouveau schéma sera accepté.

Pour ajouter une nouvelle version à un schéma existant, utilisez l'API RegisterSchemaVersion action (Python : register_schema_version).

Spécifiez une structure SchemaId pour indiquer le schéma pour lequel vous souhaitez ajouter une version, ainsi qu'une valeur SchemaDefinition pour définir le schéma.

Exemple de code 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. Connectez-vous à la AWS Management Console et ouvrez la console AWS Glue à l'adresse https://console.aws.amazon.com/glue/.

  2. Dans le panneau de navigation, sous Data catalog (Catalogue de données), choisissez Schemas (Schémas).

  3. Sélectionnez le schéma dans la liste des schémas, en cochant sa case.

  4. Sélectionnez un ou plusieurs schémas dans la liste, en cochant les cases.

  5. Dans le menu Action, choisissez Register new version (Enregistrer une nouvelle version).

  6. Dans New version (Nouvelle version), saisissez ou collez votre nouveau schéma.

  7. Choisissez Compare with previous version (Comparer avec la version précédente) pour voir les différences avec la version de schéma précédente.

  8. Choisissez éventuellement Add metadata (Ajouter des métadonnées) pour ajouter des métadonnées de version afin d'annoter ou de classer votre version de schéma. Saisissez une clé et une valeur facultative.

  9. Choisissez Register version (Version de registre).

Ajout d'une version de schéma.

La version du ou des schémas s'affiche dans la liste des versions. Si la version a changé le mode de compatibilité, la version sera marquée comme point de contrôle.

Exemple de comparaison d'une version de schéma

Lorsque vous choisissez Compare with previous version (Comparer avec la version précédente), vous verrez les versions précédentes et les nouvelles versions affichées ensemble. Les informations modifiées seront mises en évidence comme suit :

  • Jaune : indique les informations modifiées.

  • Vert : indique le contenu ajouté à la dernière version.

  • Rouge : indique le contenu supprimé dans la dernière version.

Vous pouvez également comparer les versions antérieures.

Exemple de comparaison d'une version de schéma.

Suppression d'un schéma ou d'un registre

La suppression d'un schéma, d'une version de schéma ou d'un registre est une action permanente qui ne peut pas être annulée.

Suppression d'un schéma

Vous pouvez supprimer un schéma lorsqu'il ne sera plus utilisé dans un registre, à l'aide de l'APl AWS Management Console ou DeleteSchema action (Python : supprimer_schéma).

La suppression d'un ou plusieurs schémas est une action permanente qui ne peut pas être annulée. Assurez-vous que le ou les schémas ne sont plus nécessaires.

Pour supprimer un schéma du registre, appelez l'API DeleteSchema action (Python : supprimer_schéma), en spécifiant la structure SchemaId pour identifier le schéma.

Par exemple :

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 

Pour supprimer un schéma de la console AWS Glue :

  1. Connectez-vous à la AWS Management Console et ouvrez la console AWS Glue à l'adresse https://console.aws.amazon.com/glue/.

  2. Dans le panneau de navigation, sous Data catalog (Catalogue de données), choisissez Schema registries (Registres de schémas).

  3. Choisissez le registre qui contient votre schéma dans la liste des registres.

  4. Sélectionnez un ou plusieurs schémas dans la liste, en cochant les cases.

  5. Dans le menu Action, sélectionnez Delete schema (Supprimer un schéma).

  6. Saisissez le texte Delete dans le champ pour confirmer la suppression.

  7. Choisissez Delete (Supprimer).

Le ou les schémas que vous avez spécifiés sont supprimés du registre.

Suppression d'une version de schéma

Au fur et à mesure que les schémas s'accumulent dans le registre, il se peut que vous souhaitiez supprimer les versions de schéma indésirables à l'aide de la AWS Management Console ou de l'API DeleteSchemaVersions action (Python : delete_schema_versions). La suppression d'une ou de plusieurs versions de schéma est une action permanente qui ne peut pas être annulée. Assurez-vous que les versions de schéma ne sont plus nécessaires.

Lorsque vous supprimez des versions de schéma, veuillez tenir compte des contraintes suivantes :

  • Vous ne pouvez pas supprimer une version comportant un point de contrôle.

  • La gamme de versions contiguës ne peut pas dépasser 25.

  • La version de schéma la plus récente ne doit pas être dans un état en attente.

Spécifiez la structure SchemaId pour identifier le schéma et spécifiez Versions comme une plage de versions à supprimer. Pour plus d'informations sur la spécification d'une version ou d'une plage de versions, veuillez consulter DeleteRegistry action (Python : supprimer_registre). Les versions de schéma que vous avez spécifiées sont supprimées du registre.

En appelant l'API ListSchemaVersions action (Python : list_schema_versions) après cet appel, vous obtiendrez la liste de l'état des versions supprimées.

Par exemple :

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. Connectez-vous à la AWS Management Console et ouvrez la console AWS Glue à l'adresse https://console.aws.amazon.com/glue/.

  2. Dans le panneau de navigation, sous Data catalog (Catalogue de données), choisissez Schema registries (Registres de schémas).

  3. Choisissez le registre qui contient votre schéma dans la liste des registres.

  4. Sélectionnez un ou plusieurs schémas dans la liste, en cochant les cases.

  5. Dans le menu Action, sélectionnez Delete schema (Supprimer un schéma).

  6. Saisissez le texte Delete dans le champ pour confirmer la suppression.

  7. Choisissez Delete (Supprimer).

Les versions de schéma que vous avez spécifiées sont supprimées du registre.

Suppression d'un registre

Vous pouvez supprimer un registre lorsque les schémas qu'il contient ne doivent plus être organisés sous ce registre. Vous devrez réaffecter ces schémas à un autre registre.

La suppression d'un ou de plusieurs registres est une action permanente qui ne peut pas être annulée. Assurez-vous que le ou les registres ne sont plus requis.

Le registre par défaut peut être supprimé à l'aide de la AWS CLI.

API AWS Glue

Pour supprimer l'intégralité du registre, y compris le schéma et toutes ses versions, appelez l'API DeleteRegistry action (Python : supprimer_registre). Spécifiez une structure RegistryId pour identifier le registre.

Par exemple :

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"

Pour obtenir le statut de l'opération de suppression, vous pouvez appeler l'API GetRegistry après l'appel asynchrone.

Console AWS Glue 

Pour supprimer un registre de la console AWS Glue :

  1. Connectez-vous à la AWS Management Console et ouvrez la console AWS Glue à l'adresse https://console.aws.amazon.com/glue/.

  2. Dans le panneau de navigation, sous Data catalog (Catalogue de données), choisissez Schema registries (Registres de schémas).

  3. Sélectionnez un registre dans la liste en cochant une case.

  4. Dans le menu Action, choisissez Delete registry (Supprimer un registre).

  5. Saisissez le texte Delete dans le champ pour confirmer la suppression.

  6. Choisissez Delete (Supprimer).

Les registres que vous avez sélectionnés sont supprimés de AWS Glue.

Exemples d'IAM pour les sérialiseurs

Note

Les politiques gérées AWS octroient les autorisations nécessaires pour les cas d'utilisation courants. Pour plus d'informations sur l'utilisation des politiques gérées pour gérer le registre de schéma, veuillez consulter AWS politiques gérées (prédéfinies) pour AWS Glue.

Pour les sérialiseurs, vous devez créer une politique minimale similaire à celle ci-dessous pour vous donner la possibilité de trouver le schemaVersionId pour une définition de schéma donnée. Notez que vous devez disposer des autorisations de lecture sur le registre afin de lire les schémas dans le registre. Vous pouvez limiter les registres qui peuvent être lus à l'aide de la clause Resource.

Exemple de code 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"
                     ]  
}

En outre, vous pouvez également autoriser les applications producteur à créer des schémas et versions en incluant les méthodes supplémentaires suivantes. Notez que vous devriez être en mesure d'inspecter le registre afin d'ajouter/de supprimer/de faire évoluer les schémas qu'il contient. Vous pouvez limiter les registres qui peuvent être inspectés à l'aide de la clause Resource.

Exemple de code 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"
                 ]  
}

Exemples d'IAM pour les désérialiseurs

Pour les désérialiseurs (côté application consommateur), vous devez créer une politique similaire à celle ci-dessous pour autoriser le désérialiseur à récupérer le schéma à partir du registre de schéma pour la désérialisation. Notez que vous devriez être en mesure d'inspecter le registre afin d'extraire les schémas qu'il contient.

Exemple de code 15 :

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

Connectivité privée utilisant AWS PrivateLink

Vous pouvez utiliser AWS PrivateLink pour connecter le VPC de votre producteur de données à AWS Glue en définissant un point de terminaison d'un VPC d'interface pour AWS Glue. Lorsque vous utilisez un point de terminaison de VPC, la communication entre votre VPC et AWS Glue est gérée au sein du réseau AWS. Pour plus d'informations, veuillez consulter Utilisation d'AWS Glue avec les points de terminaison d'un VPC.

Accès aux CloudWatch métriques d'Amazon

Les CloudWatch statistiques Amazon sont disponibles dans le cadre CloudWatch de l'offre gratuite. Vous pouvez accéder à ces métriques dans la CloudWatch console. Les indicateurs au niveau de l'API incluent CreateSchema (succès et latence) GetSchemaByDefinition, (succès et latence), GetSchemaVersion (succès et latence), RegisterSchemaVersion (succès et latence), PutSchemaVersionMetadata (succès et latence). Les métriques au niveau des ressources incluent le registre. ThrottledByLimit, SchemaVersion. ThrottledByLimit, SchemaVersion Taille.

Exemple de modèle AWS CloudFormation pour le registre de schémas

Voici un exemple de modèle pour créer des ressources du registre de schémas dans AWS CloudFormation. Pour créer cette pile dans votre compte, copiez le modèle ci-dessus dans un fichier SampleTemplate.yaml et exécutez la commande suivante :

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

Cet exemple utilise AWS::Glue::Registry pour créer un registre, AWS::Glue::Schema pour créer un schéma, AWS::Glue::SchemaVersion pour créer une version de schéma et AWS::Glue::SchemaVersionMetadata pour renseigner les métadonnées de version de schéma. 

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"