Conceitos básicos do registro de esquemas

As seções a seguir fornecem uma visão geral e orientações sobre como configurar e usar o registro de esquemas. Para obter informações sobre conceitos e componentes do registro de esquemas, consulte Registro de esquemas do AWS Glue.

Instalar as bibliotecas SerDe

nota

Pré-requisitos: antes de concluir as etapas a seguir, é necessário ter um cluster do Amazon Managed Streaming for Apache Kafka (Amazon MSK) ou do Apache Kafka em execução. Seus produtores e consumidores precisam estar em execução em Java 8 ou superior.

As bibliotecas SerDe fornecem um framework para serialização e desserialização de dados.

Você instalará o serializador de código aberto para suas aplicações que produzem dados (coletivamente os “serializadores”). O serializador manipula serialização, compactação e interação com o registro de esquemas. O serializador extrai automaticamente o esquema de um registro sendo gravado em um destino compatível com o registro de esquemas, como o Amazon MSK. Da mesma forma, você instalará o desserializador de código aberto em suas aplicações que consomem dados.

Para instalar as bibliotecas em produtores e consumidores:

1. Dentro dos arquivos pom.xml, tanto dos produtores quanto dos consumidores, adicione essa dependência com o código abaixo:

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

   Como alternativa, você pode clonar o repositório do registro de esquemas do AWS Glue do GitHub.

2. Configure seus produtores com estas propriedades obrigatórias:

   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 não houver esquemas existentes, o registro automático precisará ser ativado (próxima etapa). Se você tiver um esquema que gostaria de aplicar, substitua “my-schema” (meu esquema) pelo nome do seu esquema. Além disso, o “registry-name” (nome do registro) deve ser fornecido se o registro automático do esquema estiver desativado. Se o esquema é criado sob o “default-registry” (registro padrão), o nome do registro pode ser omitido.

3. (Opcional) defina qualquer uma destas propriedades opcionais do produtor. Para obter descrições detalhadas das propriedades, consulte o arquivo 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

   O registro automático registra a versão do esquema no registro padrão (“default-registry”). Se um SCHEMA_NAME não for especificado na etapa anterior, então o nome do tópico será inferido como SCHEMA_NAME.

   Consulte Versionamento e compatibilidade de esquema, para obter mais informações sobre os modos de compatibilidade.

4. Configure seus consumidores com estas propriedades obrigatórias:

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

5. (Opcional) defina essas propriedades opcionais do consumidor. Para obter descrições detalhadas das propriedades, consulte o arquivo ReadMe.

   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

Usar a AWS CLI para APIs do registro de esquemas do AWS Glue

Para usar a AWS CLI para APIs do registro de esquemas do AWS Glue, certifique-se de atualizar a AWS CLI para a versão mais recente.

Criar um registro

Você pode usar o registro padrão ou criar quantos novos registros forem necessários usando as APIS do AWS Glue ou o console do AWS Glue.

APIs do AWS Glue

Você pode usar estas etapas para executar essa tarefa usando as APIs do AWS Glue.

Para adicionar um novo registro, use a API do Ação CreateRegistry (Python: create_registry). Especifique RegistryName como o nome do registro a ser criado, com um comprimento máximo de 255, contendo apenas letras, números, hífens, sublinhados, cifrões ou marcas de hash.

Especifique Description como uma string com não mais do que 2.048 bytes de comprimento, correspondente ao padrão de string com várias linhas de endereço URI.

Como alternativa, especifique um ou mais Tags para seu registro, como uma matriz de mapa de pares de chave-valor.

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

Quando seu registro é criado, ele recebe um nome do recurso da Amazon (ARN), que você pode visualizar no RegistryArn da resposta da API. Agora que você criou um registro, crie um ou mais esquemas para esse registro.

Console do AWS Glue

Para adicionar um novo registro no console do AWS Glue:

1. Faça logon no AWS Management Console e abra o console do AWS Glue em https://console.aws.amazon.com/glue/.

2. No painel de navegação, em Data catalog (Catálogo de dados), escolha Schema registries (Registros de esquemas).

3. Escolha Add registry (Adicionar registro).

4. Digite um Registry name (Nome de registro) para o registro composto por letras, números, hifens ou sublinhados. Esse nome não pode ser alterado.

5. Digite uma Description (Descrição) (opcional) para o registro.

6. Opcionalmente, aplique uma ou mais tags ao registro. Escolha Add new tag (Adicionar nova tag), especifique um Tag key (Chave de tag) e, opcionalmente, um Tag value (Valor da tag).

7. Escolha Add registry (Adicionar registro).

Quando seu registro é criado, ele recebe um nome do recurso da Amazon (ARN), que você pode visualizar escolhendo o registro na lista em Schema registries (Registros de esquemas). Agora que você criou um registro, crie um ou mais esquemas para esse registro.

Lidar com um registro específico (JAVA POJO) para JSON

Você pode usar um plain old Java object (POJO) e transmitir o objeto como um registro. Isso é semelhante à noção de um registro específico no AVRO. O mbknor-jackson-jsonschema pode gerar um esquema JSON para o POJO transmitido. Essa biblioteca também pode injetar informações adicionais no esquema JSON.

A biblioteca do registro de esquemas do AWS Glue usa o campo “className” injetado no esquema para fornecer um nome de classe totalmente classificado. O campo “className” é usado pelo desserializador para desserializar em um objeto dessa 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() {}
}

Criar um esquema

Você pode criar um esquema usando as APIs do AWS Glue ou o console do AWS Glue.

APIs do AWS Glue

Você pode usar estas etapas para executar essa tarefa usando as APIs do AWS Glue.

Para adicionar um novo esquema, use a API Ação CreateSchema (Python: create_esquema).

Especifique uma estrutura RegistryId para indicar um registro para o esquema. Ou omita o RegistryId para usar o registro padrão.

Especifique um SchemaName consistindo em letras, números, hifens ou sublinhados e DataFormat como AVRO ou JSON. O DataFormat, uma vez definido em um esquema, não pode ser alterado.

Especifique um modo de Compatibility:

• Backward (Anterior) (recomendado): o consumidor pode ler a versão atual e a anterior.

• Backward all (Todas as anteriores): o consumidor pode ler a versão atual e todas as anteriores.

• Forward (Próxima): o consumidor pode ler a versão atual e a subsequente.

• Forward all (Todas as próximas): o consumidor pode ler a versão atual e todas as subsequentes.

• Full (Completo): combinação de Backward e Forward.

• Full all (Completo total): combinação de Backward all e Forward all.

• None (Nenhum): nenhuma verificação de compatibilidade é realizada.

• Disabled (Desabilitado): impede qualquer versionamento para esse esquema.

Opcionalmente, especifique Tags para seu esquema.

Especifique uma SchemaDefinition para definir o esquema no formato de dados Avro, JSON ou Protobuf. Consulte os exemplos.

Para o formato de dados 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 o formato de dados 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 o formato de dados 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 do AWS Glue

Para adicionar um novo esquema usando o console do AWS Glue:

1. Faça login no Console de Gerenciamento da AWS e abra o console do AWS Glue em https://console.aws.amazon.com/glue/.

2. No painel de navegação, em Data catalog (Catálogo de dados), escolha Schema (Esquema).

3. Escolha Add schema (Adicionar esquema).

4. Digite um Schema name (Nome do esquema), consistindo em letras, números, hifens, sublinhados, cifrões ou marcas de hash. Esse nome não pode ser alterado.

5. Escolha o Registry (Registro) em que o esquema será armazenado no menu suspenso. O registro pai não pode ser alterado após a criação.

6. Deixe Data format (Formato de dados) como Apache Avro ou JSON. Esse formato se aplica a todas as versões desse esquema.

7. Escolha um Compatibility mode (Modo de compatibilidade).

   • Backward (Anterior) (recomendado): o receptor pode ler a versão atual e a anterior.

   • Backward all (Todas as anteriores): o receptor pode ler a versão atual e todas as anteriores.

   • Forward (Próxima): o remetente pode gravar a versão atual e a anterior.

   • Forward all (Todas as próximas): o remetente pode gravar a versão atual e todas as anteriores.

   • Full (Completo): combinação de Backward e Forward.

   • Full all (Completo total): combinação de Backward All e Forward All.

   • None (Nenhum): nenhuma verificação de compatibilidade é realizada.

   • Disabled (Desabilitado): impede qualquer versionamento para esse esquema.

8. Insira uma Description (Descrição) opcional de até 250 caracteres para o registro.

   

9. Opcionalmente, aplique uma ou mais tags ao esquema. Escolha Add new tag (Adicionar nova tag), especifique um Tag key (Chave de tag) e, opcionalmente, um Tag value (Valor da tag).

10. Na caixa First schema version (Primeira versão do esquema), insira ou cole o esquema inicial.

    Para o formato Avro, consulte Trabalhar com o formato de dados Avro

    Para o formato JSON, consulte Trabalhar com o formato de dados JSON

11. Opcionalmente, escolha Add metadata (Adicionar metadados) para adicionar metadados de versão para anotar ou classificar a versão do esquema.

12. Selecione Create schema and version (Criar esquema e versão).

O esquema é criado e aparece na lista em Schemas (Esquemas).

Trabalhar com o formato de dados Avro

O Avro fornece serviços de serialização e troca de dados. O Avro armazena a definição de dados no formato JSON facilitando a leitura e interpretação. Os dados em si são armazenados em formato binário.

Para obter informações sobre como definir um esquema do Apache Avro, consulte a especificação do Apache Avro.

Trabalhar com o formato de dados JSON

Os dados podem ser serializados com o formato JSON. O formato do esquema JSON define o padrão para o formato de esquema JSON.

Atualizar um esquema ou registro

Uma vez criados, você pode editar seus esquemas, versões de esquema ou registro.

Atualizar um registro

Você pode atualizar um registro usando as APIs do AWS Glue ou o console do AWS Glue. O nome de um registro existente não pode ser editado. Você pode editar a descrição de um registro.

APIs do AWS Glue

Para atualizar um registro existente, use a API Ação UpdateRegistry (Python: update_registry).

Especifique uma estrutura RegistryId para indicar o registro que você deseja atualizar. Informe uma Description para alterar a descrição de um registro.

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

Console do AWS Glue

Para atualizar um registro usando o console do AWS Glue:

1. Faça logon no AWS Management Console e abra o console do AWS Glue em https://console.aws.amazon.com/glue/.

2. No painel de navegação, em Data catalog (Catálogo de dados), escolha Schema registries (Registros de esquemas).

3. Escolha um registro na lista de registros, marcando a caixa correspondente.

4. No menu Action (Ação), escolha Edit registry (Editar registro).

Atualizar um esquema

Você pode atualizar a descrição ou a configuração de compatibilidade de um esquema.

Para atualizar um esquema existente, use a API Ação UpdateSchema (Python: update_schema).

Especifique uma estrutura SchemaId para indicar o esquema que você deseja atualizar. Um de VersionNumber ou Compatibility tem de ser fornecido.

Exemplo 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

Adicionar uma versão de esquema

Quando você adiciona uma versão de esquema, precisa comparar as versões para se certificar de que o novo esquema será aceito.

Para adicionar uma nova versão a um esquema existente, use a API Ação RegisterSchemaVersion (Python: register_schema_version).

Especifique um estrutura SchemaId para indicar o esquema no qual você deseja adicionar uma versão e uma SchemaDefinition para definir o esquema.

Exemplo 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. Faça logon no AWS Management Console e abra o console do AWS Glue em https://console.aws.amazon.com/glue/.

2. No painel de navegação, em Data catalog (Catálogo de dados), escolha Schema (Esquema).

3. Escolha o esquema na lista de esquemas, marcando a caixa correspondente.

4. Escolha um ou mais esquemas na lista, marcando as caixas.

5. No menu Action (Ação), escolha Register new version (Registrar nova versão).

6. Na caixa New version (Nova versão), insira ou cole seu novo esquema.

7. Escolha Compare with previous version (Comparar com a versão anterior) para ver as diferenças em relação à versão anterior do esquema.

8. Opcionalmente, escolha Add metadata (Adicionar metadados) para adicionar metadados de versão para anotar ou classificar a versão do esquema. Digite a Key (Chave) e o Value (Valor) opcional.

9. Escolha Register version (Registrar versão).

As versões dos esquemas aparecem na lista de versões. Se a versão alterou o modo de compatibilidade, ela será marcada como um ponto de verificação.

Exemplo de comparação de versões de esquema

Quando você escolher Compare with previous version (Comparar com a versão anterior), você verá a versão nova e a anterior exibidas juntas. As informações alteradas serão destacadas da seguinte forma:

• Amarelo: indica informações alteradas.

• Verde: indica o conteúdo adicionado na versão mais recente.

• Vermelho: indica o conteúdo removido da versão mais recente.

Você também pode comparar com versões anteriores.

Excluir um esquema ou registro

Excluir um esquema, uma versão de esquema ou um registro são ações permanentes que não podem ser desfeitas.

Excluir um esquema

Você pode querer excluir um esquema quando ele não for mais usado dentro de um registro usando o AWS Management Console ou a API Ação DeleteSchema (Python: delete_schema).

Excluir um ou mais esquemas é uma ação permanente que não pode ser desfeita. Certifique-se de que o esquema ou esquemas não são mais necessários.

Para excluir um esquema do registro, chame a API Ação DeleteSchema (Python: delete_schema), especificando a estrutura SchemaId para identificar o esquema.

Por exemplo:

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 do AWS Glue

Para excluir um esquema com o console do AWS Glue:

1. Faça logon no AWS Management Console e abra o console do AWS Glue em https://console.aws.amazon.com/glue/.

2. No painel de navegação, em Data catalog (Catálogo de dados), escolha Schema registries (Registros de esquemas).

3. Escolha o registro que contém o esquema na lista de registros.

4. Escolha um ou mais esquemas na lista, marcando as caixas.

5. No menu Actions (Ações), escolha Delete schema (Excluir esquema).

6. Insira o texto Delete no campo para confirmar a exclusão.

7. Escolha Excluir.

Os esquemas especificados são excluídos do registro.

Excluir uma versão de esquema

À medida que os esquemas se acumulam no registro, você pode querer excluir versões de esquema indesejadas usando o AWS Management Console ou a API Ação DeleteSchemaVersions (Python: delete_schema_versions). Excluir uma ou mais versões de esquema é uma ação permanente que não pode ser desfeita. Certifique-se de que as versões de esquema não são mais necessárias.

Ao excluir versões de esquema, observe as seguintes restrições:

• Você não pode excluir uma versão marcada como ponto de verificação.

• O intervalo de versões contíguas não pode ser superior a 25.

• A versão mais recente do esquema não deve estar em estado pendente.

Especifique a estrutura SchemaId para identificar o esquema e especifique Versions como um intervalo de versões a serem excluídas. Para obter mais informações sobre como especificar uma versão ou intervalo de versões, consulte Ação DeleteRegistry (Python: delete_registry). As versões de esquema especificadas são excluídas do registro.

Chamar a API Ação ListSchemaVersions (Python: list_schema_versions) após essa chamada listará o status das versões excluídas.

Por exemplo:

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. Faça logon no AWS Management Console e abra o console do AWS Glue em https://console.aws.amazon.com/glue/.

2. No painel de navegação, em Data catalog (Catálogo de dados), escolha Schema registries (Registros de esquemas).

3. Escolha o registro que contém o esquema na lista de registros.

4. Escolha um ou mais esquemas na lista, marcando as caixas.

5. No menu Actions (Ações), escolha Delete schema (Excluir esquema).

6. Insira o texto Delete no campo para confirmar a exclusão.

7. Escolha Excluir.

As versões de esquema especificadas são excluídas do registro.

Excluir um registro

Você pode querer excluir um registro quando os esquemas que ele contém não devem mais ser organizados nele. Você precisará reatribuir esses esquemas a outro registro.

Excluir um ou mais registros é uma ação permanente que não pode ser desfeita. Certifique-se de que o registro ou registros não são mais necessários.

O registro padrão pode ser excluído usando a AWS CLI.

API do AWS Glue

Para excluir todo o registro, incluindo o esquema e todas as suas versões, chame a API Ação DeleteRegistry (Python: delete_registry). Especifique uma estrutura RegistryId para identificar o registro.

Por exemplo:

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 obter o status da operação de exclusão, é possível chamar a API GetRegistry após a chamada assíncrona.

Console do AWS Glue

Para excluir um registro do console do AWS Glue:

1. Faça logon no AWS Management Console e abra o console do AWS Glue em https://console.aws.amazon.com/glue/.

2. No painel de navegação, em Data catalog (Catálogo de dados), escolha Schema registries (Registros de esquemas).

3. Escolha um registro na lista, marcando uma caixa.

4. No menu Action (Ação), escolha Delete registry (Excluir registro).

5. Insira o texto Delete no campo para confirmar a exclusão.

6. Escolha Excluir.

Os registros que você selecionou são excluídos do AWS Glue.

Exemplos do IAM para serializadores

nota

As políticas gerenciadas pela AWS concedem as permissões necessárias para casos de uso comuns. Para obter informações sobre como usar políticas gerenciadas para gerenciar o registro do esquema, consulte AWS políticas gerenciadas (predefinidas) para AWS Glue.

Para serializadores, você deve criar uma política mínima semelhante à abaixo, para lhe dar a capacidade de encontrar o schemaVersionId para uma determinada definição de esquema. Observe que você deve ter permissões de leitura no registro para ler os esquemas no registro. Você pode limitar os registros que podem ser lidos usando a cláusula Resource.

Exemplo 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"
                     ]  
}

Além disso, você também pode permitir que os produtores criem novos esquemas e versões ao incluir os seguintes métodos extras. Observe que você deve ser capaz de inspecionar o registro para adicionar/remover/evoluir os esquemas dentro dele. Você pode limitar os registros que podem ser inspecionados usando a cláusula Resource.

Exemplo 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"
                 ]  
}

Exemplos do IAM para desserializadores

Para desserializadores (lado do consumidor), você deve criar uma política semelhante à abaixo para permitir que o desserializador busque o esquema do registro de esquemas para desserialização. Observe que você deve ser capaz de inspecionar o registro a fim de buscar os esquemas dentro dele.

Exemplo de código 15:

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

Conectividade privada usando AWS PrivateLink

Você pode usar o AWS PrivateLink para conectar a VPC do produtor de dados ao AWS Glue definindo um endpoint da VPC de interface para o AWS Glue. Quando você usa um endpoint da VPC de interface, a comunicação entre sua VPC e o AWS Glue é realizada inteiramente dentro da rede da AWS. Para obter mais informações, consulte Usar o AWS Glue com endpoints da VPC.

Acessar métricas do Amazon CloudWatch

As métricas do Amazon CloudWatch estão disponíveis como parte do nível gratuito do CloudWatch. Você também pode visualizar essas métricas no console do CloudWatch. As métricas de nível de API incluem CreateSchema (sucesso e latência), GetSchemaByDefinition (sucesso e latência), GetSchemaVersion (sucesso e latência), RegisterSchemaVersion (sucesso e latência) e PutSchemaVersionMetadata (sucesso e latência). As métricas de nível de recurso incluem Registry.ThrottledByLimit, SchemaVersion.ThrottledByLimit e SchemaVersion.Size.

Exemplo do modelo do AWS CloudFormation para o registro de esquemas

Veja a seguir um modelo de exemplo para criar recursos do registro de esquemas no AWS CloudFormation. Para criar essa pilha em sua conta, copie o modelo acima em um arquivo SampleTemplate.yaml e execute o seguinte comando:

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

Este exemplo usa AWS::Glue::Registry para criar um registro, AWS::Glue::Schema para criar um esquema, AWS::Glue::SchemaVersion para criar uma versão de esquema e AWS::Glue::SchemaVersionMetadata para preencher os metadados da versão do 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"