Introducción a Schema Registry - AWS Glue
Instalación de bibliotecas SerDeUso de AWS CLI para las API de AWS Glue Schema RegistryCreación de un registroTrabajar con un registro específico (JAVA POJO) para JSONCreación de un esquemaActualización de un esquema o registroEliminación de un esquema o registroEjemplos de IAM para serializadoresEjemplos de IAM para deserializadoresConectividad privada mediante AWS PrivateLinkAcceso a métricas de Amazon CloudWatchEjemplo de plantilla de AWS CloudFormation para Schema Registry

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Introducción a Schema Registry

Las siguientes secciones ofrecen información general y una guía para configurar y empezar a utilizar Schema Registry. Para obtener más información sobre los conceptos y componentes de Schema Registry, consulte AWS Glue Schema Registry.

Instalación de bibliotecas SerDe

nota

Requisitos previos: antes de completar los siguientes pasos, deberá tener un clúster de Amazon Managed Streaming for Apache Kafka (Amazon MSK) o Apache Kafka en ejecución. Sus productores y consumidores deben ejecutarse en Java 8 o superior.

Las bibliotecas SerDe proporcionan un marco para serializar y deserializar datos.

Instalará el serializador de código abierto para sus aplicaciones que producen datos (colectivamente los “serializadores”). El serializador controla la serialización, la compresión y la interacción con Schema Registry. El serializador extrae automáticamente el esquema de un registro que se está escribiendo en un destino compatible con Schema Registry, como Amazon MSK. Del mismo modo, instalará el deserializador de código abierto en sus aplicaciones que consumen datos.

Para instalar las bibliotecas en productores y consumidores:

  1. Dentro de los archivos pom.xml de los productores y consumidores, agregue esta dependencia a través del siguiente código:

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

    También puede clonar el repositorio Github de AWS Glue Schema Registry.

  2. Configure sus productores con estas propiedades requeridas:

    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"

    Si no hay esquemas existentes, debe activarse el registro automático (siguiente paso). Si tiene un esquema que desea aplicar, reemplace “my-schema (mi esquema)” con su nombre de esquema. También debe proporcionarse el “registry-name (nombre del registro)” si el registro automático del esquema está desactivado. Si el esquema se crea como “default-registry (registro predeterminado)”, entonces el nombre del registro se puede omitir.

  3. (Opcional) configure cualquiera de estas propiedades de productor opcionales. Para ver descripciones detalladas de propiedades, consulte el archivo ReadMe (Léame).

    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

    El registro automático registra la versión del esquema en el registro predeterminado (“default-registry”). Si no se especifica un SCHEMA_NAME en el paso anterior, entonces el nombre del tema se infiere como el SCHEMA_NAME.

    Consulte Compatibilidad y control de versiones de esquemas para obtener más información sobre los modos de compatibilidad.

  4. Configure sus consumidores con estas propiedades obligatorias:

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

  5. (Opcional) configure estas propiedades de consumidores opcionales. Para ver descripciones detalladas de propiedades, consulte el archivo ReadMe (Léame).

    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

Uso de AWS CLI para las API de AWS Glue Schema Registry

Para utilizar AWS CLI para las API de AWS Glue Schema Registry, asegúrese de actualizar su AWS CLI a la versión más reciente.

Creación de un registro

Puede utilizar el registro predeterminado o crear tantos registros nuevos como sea necesario mediante las API de AWS Glue o la consola de AWS Glue.

Las API de AWS Glue

Puede seguir estos pasos para realizar esta tarea mediante las API de AWS Glue.

Para agregar un registro nuevo, use la API de CreateRegistry acción (Python: create_registry). Especifique RegistryName como el nombre del registro que se va a crear con una longitud máxima de 255, y solo puede contener letras, números, guión, guión bajo, signo de dólar o marca hash.

Especifique una Description como una cadena cuya extensión no sea más de 2048 bytes y que coincida con el patrón de cadena de varias líneas de la dirección URI.

De manera opcional, especifique una o varias Tags para su registro, como matriz de mapas de pares clave-valor.

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

Cuando se crea el registro se le asigna un nombre de recurso de Amazon (ARN). Este ARN lo puede ver en RegistryArn de la respuesta de la API. Ahora que ha creado un registro, cree uno o más esquemas para ese registro.

Consola de AWS Glue

Para agregar un nuevo registro en la consola de AWS Glue:

  1. Inicie sesión en AWS Management Console y abra la consola de AWS Glue en https://console.aws.amazon.com/glue/.

  2. En el panel de navegación, en Data catalog (Catálogo de datos), elija Schema registries (Registros de esquemas).

  3. Elija Add registry (Agregar registro).

  4. Escriba un Registry name (Nombre del Registro) para el registro, que conste de letras, números, guiones o guiones bajos. Este nombre no se puede cambiar.

  5. Escriba una Description (Descripción) (opcional) para el registro.

  6. De manera opcional, aplique una o varias etiquetas a su registro. Elija Add new tag (Agregar nueva etiqueta) y especifique una Tag key (Clave de etiqueta) y, opcionalmente, un Tag value (Valor de etiqueta).

  7. Elija Add registry (Agregar registro).

Ejemplo de creación de un registro.

Cuando se crea el registro, se le asigna un nombre de recurso de Amazon (ARN), que puede ver al seleccionar el registro de la lista en Schema registries (Registros de esquemas). Ahora que ha creado un registro, cree uno o más esquemas para ese registro.

Trabajar con un registro específico (JAVA POJO) para JSON

Puede usar un objeto Java antiguo simple (POJO) y transferir el objeto como un registro. Esto es similar a la noción de un registro específico en AVRO. mbknor-jackson-jsonschema puede generar un esquema JSON para el POJO transferido. Esta biblioteca también puede inyectar información adicional en el esquema JSON.

La biblioteca de AWS Glue Schema Registry utiliza el campo “className (nombre de clase)” inyectado en el esquema para proporcionar un nombre de clase completamente clasificado. El deserializador utiliza el campo “className” para deserializar en un objeto de esa clase.

 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() {}
}

Creación de un esquema

Puede crear un esquema con las API de AWS Glue o la consola de AWS Glue.

Las API de AWS Glue

Puede seguir estos pasos para realizar esta tarea mediante las API de AWS Glue.

Para agregar un esquema nuevo, use la API de CreateSchema acción (Python: create_schema).

Especifique una estructura de RegistryId para indicar un registro para el esquema. O bien, omita el RegistryId para utilizar el registro predeterminado.

Especifique un SchemaName, que conste de letras, números, guiones o guiones bajos, y DataFormat como AVRO o JSON. Una vez configurado el DataFormat en un esquema no puede modificarse.

Especifique un modo de Compatibility:

  • Hacia atrás (recomendado): el consumidor puede leer tanto la versión actual como la anterior.

  • Hacia atrás todo: el consumidor puede leer tanto la versión actual como todas las anteriores.

  • Hacia adelante: el consumidor puede leer tanto la versión actual como la posterior.

  • Hacia adelante todo: el consumidor puede leer tanto la versión actual como todas las versiones posteriores.

  • Completo: combinación de hacia atrás y hacia adelante.

  • Completo todo: combinación de hacia atrás todos y hacia adelante todos.

  • Ninguno: no se realizan comprobaciones de compatibilidad.

  • Desactivado: evita cualquier control de versiones para este esquema.

Opcionalmente, especifique Tags para su esquema.

Especifique una SchemaDefinition para definir el esquema en formato de datos Avro, JSON o Protobuf. Consulte estos ejemplos.

Para el formato de datos 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\"} ]}"

Para el formato de datos 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\"}}}"

Para el formato de datos 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;}"
Consola de AWS Glue

Para agregar un nuevo esquema a través de la consola de AWS Glue:

  1. Inicie sesión en la consola de administración de AWS y abra la consola de AWS Glue en https://console.aws.amazon.com/glue/.

  2. En el panel de navegación, en Data catalog (Catálogo de datos), elija Schema (Esquemas).

  3. Elija Add schema (Agregar esquema).

  4. Escriba un Schema name (Nombre del esquema), que conste de letras, números, guiones, guiones bajos, signos de dólar o marcas hash. Este nombre no se puede cambiar.

  5. Elija el Registry (Registro) en el que se almacenará el esquema del menú desplegable. El registro principal no se puede cambiar después de la creación.

  6. Deje el Data format (Formato de los datos) como Apache Avro o JSON. Este formato se aplica a todas las versiones de este esquema.

  7. Elija un (Compatibility mode) Modo de compatibilidad.

    • Hacia atrás (recomendado): el receptor puede leer tanto la versión actual como la anterior.

    • Hacia atrás todo: el receptor puede leer tanto la versión actual como todas las anteriores.

    • Hacia adelante: el remitente puede escribir tanto la versión actual como la anterior.

    • Hacia adelante todo: el remitente puede escribir tanto la versión actual como todas las versiones anteriores.

    • Completo: combinación de hacia atrás y hacia adelante.

    • Completo todo: combinación de hacia atrás todos y hacia adelante todos.

    • Ninguno: no se realizan comprobaciones de compatibilidad.

    • Desactivado: evita cualquier control de versiones para este esquema.

  8. Escriba una Description (Descripción) para el registro de hasta 250 caracteres.

    Ejemplo de creación de un esquema.

  9. De manera opcional, aplique una o varias etiquetas a su esquema. Elija Add new tag (Agregar nueva etiqueta) y especifique una Tag key (Clave de etiqueta) y, opcionalmente, un Tag value (Valor de etiqueta).

  10. En la casilla, First schema version (Primera versión del esquema), ingrese o pegue el esquema inicial.

    Para el formato Avro, consulte Trabajar con formato de datos Avro

    Para el formato JSON, consulte Trabajar con formato de datos JSON

  11. También puede seleccionar Add metadata (Agregar metadatos) para agregar metadatos de versión para anotar o clasificar la versión del esquema.

  12. Elija Create schema and version (Crear esquema y versión).

Ejemplo de creación de un esquema.

El esquema se crea y aparece en la lista en Schemas (Esquemas).

Trabajar con formato de datos Avro

Avro proporciona servicios de serialización e intercambio de datos. Avro almacena la definición de datos en formato JSON, lo que facilita su lectura e interpretación. Los datos en sí se almacenan en formato binario.

Para obtener información sobre cómo definir un esquema Apache Avro, consulte la especificación de Apache Avro.

Trabajar con formato de datos JSON

Los datos se pueden serializar con formato JSON. Formato de esquemas JSON define el estándar para el formato de esquema JSON.

Actualización de un esquema o registro

Una vez creado, puede editar los esquemas, las versiones de esquema o el registro.

Actualización de un registro

Puede actualizar un registro mediante las API de AWS Glue o la consola de AWS Glue. No se puede editar el nombre de un registro existente. La descripción de un registro puede editarse.

Las API de AWS Glue

Para actualizar un registro existente, use la API UpdateRegistry acción (Python: update_registry).

Especifique una estructura de RegistryId para indicar el registro que desea actualizar. Transferir una Description para cambiar la descripción de un registro.

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

Para actualizar un registro mediante la consola de AWS Glue:

  1. Inicie sesión en AWS Management Console y abra la consola de AWS Glue en https://console.aws.amazon.com/glue/.

  2. En el panel de navegación, en Data catalog (Catálogo de datos), elija Schema registries (Registros de esquemas).

  3. Seleccione un registro de la lista de registros, al marcar la casilla correspondiente.

  4. En el menú Action (Acción), elija Edit registry (Editar registro).

Actualización de un esquema

Puede actualizar la descripción o la configuración de compatibilidad de un esquema.

Para actualizar un esquema existente, use la API UpdateSchema acción (Python: update_schema).

Especifique una estructura de SchemaId para indicar el esquema que desea actualizar. Uno de VersionNumber o Compatibility debe ser proporcionado.

Ejemplos de código 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

Agregar una versión de esquema.

Cuando agregue una versión de esquema, deberá comparar las versiones para asegurarse de que se aceptará el nuevo esquema.

Para agregar una nueva versión a un esquema existente, utilice la API RegisterSchemaVersion acción (Python: register_schema_version).

Especifique una estructura de SchemaId para indicar el esquema para el que desea agregar una versión, y una SchemaDefinition para definir el esquema.

Ejemplos de código 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. Inicie sesión en AWS Management Console y abra la consola de AWS Glue en https://console.aws.amazon.com/glue/.

  2. En el panel de navegación, en Data catalog (Catálogo de datos), elija Schema (Esquemas).

  3. Seleccione el esquema de la lista de esquemas, al marcar la casilla correspondiente.

  4. Seleccione uno o varios esquemas de la lista, al marcar las casillas correspondientes.

  5. En el menú Action (Acción), elija Register new version (Registrar nueva versión).

  6. En la casilla New version (Nueva versión), ingrese o pegue el nuevo esquema.

  7. Elija Compare with previous version (Comparar con la versión anterior) para ver las diferencias con la versión del esquema anterior.

  8. También puede seleccionar Add metadata (Agregar metadatos) para agregar metadatos de versión para anotar o clasificar la versión del esquema. Ingrese Key (Clave) y Value (Valor) opcional.

  9. Elija Register version (Registrar versión).

Agregar una versión de esquema.

La versión de esquema(s) aparece en la lista de versiones. Si la versión cambió el modo de compatibilidad, la versión se marcará como punto de control.

Ejemplo de comparación de versiones de esquema.

Cuando elige Compare with previous version (Comparar con la versión anterior), verá las versiones anterior y nueva mostradas juntas. La información que se modificó se resaltará de la siguiente manera:

  • Amarillo: indica información modificada.

  • Verde: indica el contenido agregado en la última versión.

  • Rojo: indica el contenido eliminado de la última versión.

También se pueden realizar comparaciones con versiones anteriores.

Ejemplo de comparación de versiones de esquema.

Eliminación de un esquema o registro

Eliminar un esquema, una versión de esquema o un registro son acciones permanentes que no se pueden deshacer.

Eliminación de un esquema

Es posible que desee eliminar un esquema cuando ya no se utilizará dentro de un registro, utilizando la consola AWS Management Console, o la API DeleteSchema acción (Python: delete_schema).

Eliminar uno o varios esquemas es una acción permanente que no se puede deshacer. Asegúrese de que el esquema o los esquemas ya no son necesarios.

Para eliminar un esquema del registro, llame a la API DeleteSchema acción (Python: delete_schema), y especifique la estructura de SchemaId para identificar el esquema.

Por ejemplo:

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"
Consola de AWS Glue

Para eliminar un esquema de la consola de AWS Glue:

  1. Inicie sesión en AWS Management Console y abra la consola de AWS Glue en https://console.aws.amazon.com/glue/.

  2. En el panel de navegación, en Data catalog (Catálogo de datos), elija Schema registries (Registros de esquemas).

  3. Elija el registro que contiene el esquema de la lista de registros.

  4. Seleccione uno o varios esquemas de la lista, al marcar las casillas correspondientes.

  5. En el menú Action (Acción), elija Delete schema (Eliminar esquema).

  6. Ingrese el texto Delete en el campo para confirmar la eliminación.

  7. Elija Eliminar.

Los esquemas especificados se eliminan del registro.

Eliminar una versión de esquema

A medida que los esquemas se acumulan en el registro, es posible que desee eliminar las versiones de esquema no deseadas mediante la AWS Management Console o la API DeleteSchemaVersions acción (Python: delete_schema_versions). Eliminar una o varias versiones de esquema es una acción permanente que no se puede deshacer. Asegúrese de que las versiones del esquema ya no sean necesarias.

Al eliminar versiones de esquema, tenga en cuenta las siguientes restricciones:

  • No puede eliminar una versión marcada como punto de control.

  • El rango de versiones contiguas no puede ser superior a 25.

  • La versión del esquema más reciente no debe estar en un estado pendiente.

Especifique la estructura de SchemaId para identificar el esquema y especifique las Versions como un rango de versiones para eliminar. Para obtener más información sobre cómo especificar una versión o un rango de versiones, consulte DeleteRegistry acción (Python: delete_registry). Las versiones de los esquemas especificados se eliminan del registro.

Llamar a la API ListSchemaVersions acción (Python: list_schema_versions) después de esta llamada arrojará una lista del estado de las versiones eliminadas.

Por ejemplo:

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. Inicie sesión en AWS Management Console y abra la consola de AWS Glue en https://console.aws.amazon.com/glue/.

  2. En el panel de navegación, en Data catalog (Catálogo de datos), elija Schema registries (Registros de esquemas).

  3. Elija el registro que contiene el esquema de la lista de registros.

  4. Seleccione uno o varios esquemas de la lista, al marcar las casillas correspondientes.

  5. En el menú Action (Acción), elija Delete schema (Eliminar esquema).

  6. Ingrese el texto Delete en el campo para confirmar la eliminación.

  7. Elija Eliminar.

Las versiones de los esquemas especificados se eliminan del registro.

Eliminación de un registro

Es posible que desee eliminar un registro cuando los esquemas que contiene ya no se organicen en ese registro. Tendrá que reasignar esos esquemas a otro registro.

Eliminar uno o varios registros es una acción permanente que no se puede deshacer. Asegúrese de que el registro o los registros ya no son necesarios.

El registro predeterminado se puede eliminar mediante AWS CLI.

API de AWS Glue

Para eliminar todo el registro, incluido el esquema y todas sus versiones, llame a la API DeleteRegistry acción (Python: delete_registry). Especifique una estructura de RegistryId para identificar el registro.

Por ejemplo:

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"

Para obtener el estado de la operación de eliminación, puede llamar a la API GetRegistry después de la llamada asíncrona.

Consola de AWS Glue

Para eliminar un registro de la consola de AWS Glue:

  1. Inicie sesión en AWS Management Console y abra la consola de AWS Glue en https://console.aws.amazon.com/glue/.

  2. En el panel de navegación, en Data catalog (Catálogo de datos), elija Schema registries (Registros de esquemas).

  3. Seleccione un registro de la lista, al marcar la casilla correspondiente.

  4. En el menú Action (Acción), elija Delete registry (Eliminar registro).

  5. Ingrese el texto Delete en el campo para confirmar la eliminación.

  6. Elija Eliminar.

Los registros seleccionados se eliminan de AWS Glue.

Ejemplos de IAM para serializadores

nota

Las políticas administradas de AWS conceden los permisos necesarios para los casos de uso comunes. Para obtener información sobre el uso de las políticas para administrar el registro de esquemas, consulte AWS políticas gestionadas (predefinidas) para AWS Glue.

Para los serializadores, debe crear una política mínima similar a la siguiente para poder encontrar el schemaVersionId para una definición de esquema determinada. Tenga en cuenta que debe tener permisos de lectura en el registro para poder leer los esquemas del registro. Puede limitar los registros que se pueden leer mediante la cláusula Resource.

Ejemplos de código 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"
                     ]  
}

Además, también puede permitir a los productores crear nuevos esquemas y versiones mediante la inclusión de los siguientes métodos adicionales. Tenga en cuenta que debería poder inspeccionar el registro para agregar/eliminar/evolucionar los esquemas dentro de él. Puede limitar los registros que se pueden inspeccionar mediante la cláusula Resource.

Ejemplos de código 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"
                 ]  
}

Ejemplos de IAM para deserializadores

Para los deserializadores (lado del consumidor), debe crear una política similar a la siguiente para permitir que el deserializador recupere el esquema de Schema Registry para su deserialización. Tenga en cuenta que debería poder inspeccionar el registro para obtener los esquemas dentro de él.

Ejemplos de código 15:

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

Conectividad privada mediante AWS PrivateLink

Puede usar AWS PrivateLink para conectar la VPC del productor de datos a AWS Glue. Para ello, defina un punto de enlace de la VPC de interfaz para AWS Glue. Cuando se utiliza un punto de enlace de la interfaz de la VPC, la comunicación entre la VPC y AWS Glue se realiza en su totalidad dentro de la red de AWS. Para obtener más información, consulte Uso de AWS Glue con puntos de enlace de la VPC.

Acceso a métricas de Amazon CloudWatch

Las métricas de Amazon CloudWatch están disponibles como parte de la capa gratuita de CloudWatch. También puede acceder a estas métricas en la consola de CloudWatch. Las métricas de nivel de API incluyen CreateSchema (éxito y latencia), GetSchemabyDefinition, (éxito y latencia), GetSchemaVersion (éxito y latencia), RegisterSchemaVersion (éxito y latencia), PutSchemaVersionMetadata (éxito y latencia). Las métricas de nivel de recursos incluyen Registry.ThrottledByLimit, SchemaVersion.ThrottledByLimit, SchemaVersion.Size.

Ejemplo de plantilla de AWS CloudFormation para Schema Registry

A continuación se muestra una plantilla de ejemplo para crear recursos de Schema Registry en AWS CloudFormation. Para crear esta pila en su cuenta, copie la plantilla anterior en un archivo SampleTemplate.yaml y ejecute el siguiente comando:

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

En este ejemplo se utiliza AWS::Glue::Registry para crear un registro, AWS::Glue::Schema para crear un esquema, AWS::Glue::SchemaVersion para crear una versión de esquema y AWS::Glue::SchemaVersionMetadata para completar los metadatos de la versión del esquema. 

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"