Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Instalasi SerDe Perpustakaan
SerDe Pustaka menyediakan kerangka kerja untuk serialisasi dan deserialisasi data.
Anda akan menginstal serializer sumber terbuka untuk aplikasi Anda yang menghasilkan data (secara kolektif “"-serializer"). Serializer menangani serialisasi, kompresi, dan interaksi dengan Registri Skema. Serializer secara otomatis mengekstrak skema dari catatan yang ditulis ke tujuan yang kompatibel dengan Registri Skema, seperti Amazon MSK. Demikian juga, Anda akan menginstal deserializer sumber terbuka pada aplikasi Anda yang mengkonsumsi data.
# Implementasi Java
**catatan**
Prasyarat: Sebelum menyelesaikan langkah-langkah berikut, Anda harus memiliki sebuah klaster Amazon Managed Streaming for Apache Kafka (Amazon MSK) atau Apache Kafka yang berjalan. Produsen dan konsumen Anda harus berjalan pada Java 8 atau yang lebih tinggi.
Untuk menginstal perpustakaan pada produsen dan konsumen:
1. Di dalam file pom.xml baik dari produsen dan konsumen, tambahkan dependensi ini melalui kode di bawah ini:
```
software.amazon.glue
schema-registry-serde
1.1.5
```
Atau, Anda dapat mengkloning [Repositori Github Registri Skema AWS Glue](https://github.com/awslabs/aws-glue-schema-registry).
1. Siapkan produsen Anda dengan properti yang diperlukan ini:
```
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"
```
Jika tidak ada skema yang ada, maka pendaftaran otomatis harus Anda aktifkan (langkah berikutnya). Jika Anda memiliki skema yang ingin Anda terapkan, maka ganti "my-schema" dengan nama skema Anda. Selain itu, "registry-name" harus disediakan jika skema pendaftaran otomatis dimatikan. Jika skema dibuat menggunakan "default-registry", maka nama registri dapat dihilangkan.
1. (Opsional) Mengatur salah satu properti produsen opsional ini. Untuk deskripsi properti terperinci, lihat [ ReadMe file](https://github.com/awslabs/aws-glue-schema-registry/blob/master/README.md).
```
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
```
Pendaftaran otomatis mendaftarkan versi skema dengan menggunakan registri default ("default-registry"). Jika `SCHEMA_NAME` tidak ditentukan dalam langkah sebelumnya, maka nama topik disimpulkan sebagai `SCHEMA_NAME`.
Lihat [Pembuatan versi dan kompatibilitas skema](schema-registry.md#schema-registry-compatibility) untuk informasi lebih lanjut tentang mode kompatibilitas.
1. Siapkan konsumen Anda dengan properti yang diperlukan berikut ini:
```
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 Wilayah AWS
props.put(AWSSchemaRegistryConstants.AVRO_RECORD_TYPE, AvroRecordType.GENERIC_RECORD.getName()); // Only required for AVRO data format
```
1. (Opsional) Mengatur properti konsumen opsional ini. Untuk deskripsi properti terperinci, lihat [ ReadMe file](https://github.com/awslabs/aws-glue-schema-registry/blob/master/README.md).
```
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
```
# C\$1 Implementasi
**catatan**
Prasyarat: Sebelum menyelesaikan langkah-langkah berikut, Anda harus memiliki sebuah klaster Amazon Managed Streaming for Apache Kafka (Amazon MSK) atau Apache Kafka yang berjalan. Produsen dan konsumen Anda harus berjalan di .NET 8.0 atau lebih tinggi.
## Penginstalan
Untuk aplikasi C \$1, instal SerDe NuGet paket AWS Glue Schema Registry menggunakan salah satu metode berikut:
**.NET CLI:**
Gunakan perintah berikut untuk menginstal paket:
```
dotnet add package Aws.Glue.SchemaRegistry --version 1.0.0-
```
di mana `` bisa`1.0.0-linux-x64`, `1.0.0-linux-musl-x64` atau `1.0.0-linux-arm64`
**PackageReference (dalam file.csproj Anda):**
Tambahkan yang berikut ini ke file proyek Anda:
```
```
di mana `` bisa`1.0.0-linux-x64`, `1.0.0-linux-musl-x64` atau `1.0.0-linux-arm64`
## Pengaturan File Konfigurasi
Buat file properti konfigurasi (misalnya,`gsr-config.properties`) dengan pengaturan yang diperlukan:
**Konfigurasi Minimal:**
Berikut ini menunjukkan contoh konfigurasi minimal:
```
region=us-east-1
registry.name=default-registry
dataFormat=AVRO
schemaAutoRegistrationEnabled=true
```
## Menggunakan pustaka klien C\$1 Glue Schema untuk Kafka SerDes
**Contoh penggunaan serializer:**
Contoh berikut menunjukkan cara menggunakan serializer:
```
private static readonly string PROTOBUF_CONFIG_PATH = "";
var protobufSerializer = new GlueSchemaRegistryKafkaSerializer(PROTOBUF_CONFIG_PATH);
var serialized = protobufSerializer.Serialize(message, message.Descriptor.FullName);
// send serialized bytes to Kafka using producer.Produce(serialized)
```
**Contoh penggunaan deserializer:**
Contoh berikut menunjukkan cara menggunakan deserializer:
```
private static readonly string PROTOBUF_CONFIG_PATH = "";
var dataConfig = new GlueSchemaRegistryDataFormatConfiguration(
new Dictionary
{
{
GlueSchemaRegistryConstants.ProtobufMessageDescriptor, message.Descriptor
}
}
);
var protobufDeserializer = new GlueSchemaRegistryKafkaDeserializer(PROTOBUF_CONFIG_PATH, dataConfig);
// read message from Kafka using serialized = consumer.Consume()
var deserializedObject = protobufDeserializer.Deserialize(message.Descriptor.FullName, serialized);
```
## Menggunakan pustaka klien C\$1 Glue Schema dengan for KafkaFlow SerDes
**Contoh penggunaan serializer:**
Contoh berikut menunjukkan cara mengkonfigurasi KafkaFlow dengan serializer:
```
services.AddKafka(kafka => kafka
.UseConsoleLog()
.AddCluster(cluster => cluster
.WithBrokers(new[] { "localhost:9092" })
.AddProducer(producer => producer
.DefaultTopic("customer-events")
.AddMiddlewares(m => m
.AddSerializer>(
() => new GlueSchemaRegistryKafkaFlowProtobufSerializer("config/gsr-config.properties")
)
)
)
)
);
```
**Contoh penggunaan deserializer:**
Contoh berikut menunjukkan cara mengkonfigurasi KafkaFlow dengan deserializer:
```
.AddConsumer(consumer => consumer
.Topic("customer-events")
.WithGroupId("customer-group")
.WithBufferSize(100)
.WithWorkersCount(10)
.AddMiddlewares(middlewares => middlewares
.AddDeserializer>(
() => new GlueSchemaRegistryKafkaFlowProtobufDeserializer("config/gsr-config.properties")
)
.AddTypedHandlers(h => h.AddHandler())
)
)
```
## Properti Produsen Opsional
Anda dapat memperluas file konfigurasi Anda dengan properti opsional tambahan:
```
# Auto-registration (if not passed, uses "false")
schemaAutoRegistrationEnabled=true
# Schema name (if not passed, uses topic name)
schema.name=my-schema
# Registry name (if not passed, uses "default-registry")
registry.name=my-registry
# Cache settings
cacheTimeToLiveMillis=86400000
cacheSize=200
# Compatibility mode (if not passed, uses BACKWARD)
compatibility=FULL
# Registry description
description=This registry is used for several purposes.
# Compression (if not passed, records are sent uncompressed)
compressionType=ZLIB
```
## Format Data yang Didukung
Implementasi Java dan C\$1 mendukung format data yang sama:
+ *AVRO: Format* biner Apache Avro
+ *JSON: Format Skema* JSON
+ *PROTOBUF: Format Buffer* Protokol
## Catatan
+ Untuk memulai dengan perpustakaan, silakan kunjungi [https://www.nuget. org/packages/AWS.Lem. SchemaRegistry](https://www.nuget.org/packages/AWS.Glue.SchemaRegistry)
+ Kode sumber tersedia di: [https://github.com/awslabs/aws-glue-schema-registry](https://github.com/awslabs/aws-glue-schema-registry)
# Membuat registri
Anda dapat menggunakan registri default atau membuat registri baru sebanyak yang diperlukan menggunakan AWS Glue APIs atau AWS Glue konsol.
**AWS Glue APIs**
Anda dapat menggunakan langkah-langkah ini untuk melakukan tugas ini menggunakan AWS Glue APIs.
Untuk menggunakan AWS CLI untuk AWS Glue Schema Registry APIs, pastikan untuk memperbarui versi Anda AWS CLI ke versi terbaru.
Untuk menambahkan sebuah registri baru, gunakan API [CreateRegistry tindakan (Python: create\$1registry)](aws-glue-api-schema-registry-api.md#aws-glue-api-schema-registry-api-CreateRegistry). Menentukan `RegistryName` sebagai nama registri yang akan dibuat, dengan panjang maksimal 255 karakter, hanya berisi huruf, angka, tanda hubung, garis bawah, tanda dolar, atau tanda hash.
Tentukan `Description` sebagai string yang panjangnya tidak lebih dari 2048 byte, cocok dengan pola string [multi-baris alamat URI](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-common.html#aws-glue-api-common-_string-patterns).
Opsional, menentukan satu atau beberapa `Tags` untuk registri Anda, sebagai sebuah susunan peta pasangan nilai kunci.
```
aws glue create-registry --registry-name registryName1 --description description
```
Ketika registri Anda sudah dibuat, Amazon Resource Name (ARN) ditetapkan untuknya, yang dapat Anda lihat di `RegistryArn` dari respons API. Setelah Anda membuat sebuah registri, buatlah satu atau beberapa skema untuk registri tersebut.
**Konsol AWS Glue**
Untuk menambahkan sebuah registri baru di konsol AWS Glue:
1. Masuk ke Konsol Manajemen AWS dan buka AWS Glue konsol di [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue\).
1. Di panel navigasi, pada **Katalog data**, pilih **Registri Skema**.
1. Pilih **Tambah registri**.
1. Masukkan sebuah **Nama Registri** untuk registri tersebut, yang terdiri dari huruf, angka, tanda hubung, atau garis bawah. Nama ini tidak dapat diubah.
1. Masukkan **Deskripsi** (opsional) untuk registri.
1. Opsional, terapkan satu atau beberapa tag ke registri Anda. Pilih **Tambahkan tag** dan tentukan **Kunci tag** dan **Nilai tag** opsional.
1. Pilih **Tambah registri**.
![\[Contoh membuat sebuah registri.\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/images/schema_reg_create_registry.png)
Ketika registri Anda dibuat, Amazon Resource Name (ARN) ditetappkan padanya, yang dapat Anda lihat dengan memilih registri dari daftar di **Registri Skema**. Setelah Anda membuat sebuah registri, buatlah satu atau beberapa skema untuk registri tersebut.
# Berurusan dengan catatan tertentu (JAVA POJO) untuk JSON
Anda dapat menggunakan sebuah plain old Java object (POJO) dan memberikan objek tersebut sebagai catatan. Ini mirip dengan maksud dari catatan spesifik di AVRO. [mbknor-jackson-jsonschema](https://github.com/mbknor/mbknor-jackson-jsonSchema)Dapat menghasilkan skema JSON untuk POJO yang dilewati. Perpustakaan ini juga dapat memasukkan informasi tambahan dalam skema JSON.
Perpustakaan Registri Skema AWS Glue menggunakan bidang "ClassName" yang dimasukkan dalam skema untuk memberikan nama kelas terklasifikasi sepenuhnya. Bidang "ClassName" digunakan oleh deserializer untuk melakukan deserialisasi ke objek dari kelas itu.
```
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 serviceChecks;
// Empty constructor is required by Jackson to deserialize bytes
// into an Object of this class
public Car() {}
}
```
# Membuat skema
Anda dapat membuat skema menggunakan AWS Glue APIs atau AWS Glue konsol.
**AWS Glue APIs**
Anda dapat menggunakan langkah-langkah ini untuk melakukan tugas ini menggunakan AWS Glue APIs.
Untuk menambahkan sebuah skema baru, gunakan API [CreateSchema tindakan (Python: create\$1schema)](aws-glue-api-schema-registry-api.md#aws-glue-api-schema-registry-api-CreateSchema).
Menentukan sebuah struktur `RegistryId` untuk menunjukkan registri untuk skema tersebut. Atau, menghilangkan `RegistryId` untuk menggunakan registri default.
Menentukan `SchemaName` yang terdiri dari huruf, angka, tanda hubung, atau garis bawah, dan `DataFormat` sebagai **AVRO** atau **JSON**. `DataFormat` setelah ditetapkan pada skema tidak dapat diubah.
Menentukan mode `Compatibility`:
+ *Backward (disarankan)* — Konsumen dapat membaca versi saat ini dan sebelumnya.
+ *Backward all* — Konsumen dapat membaca versi terkini dan semua versi sebelumnya.
+ *Forward* — Konsumen dapat membaca baik versi saat ini dan versi berikutnya.
+ *Forward all* — Konsumen dapat membaca baik versi saat ini dan semua versi berikutnya.
+ *Full* — Kombinasi dari Backward dan Forward.
+ *Full all* — Kombinasi dari Backward all dan Forward all.
+ *None* — Tidak ada pemeriksaan kompatibilitas yang dilakukan.
+ *Disabled* — Mencegah versioning apapun untuk skema ini.
Opsional, tentukan `Tags` untuk skema Anda.
Tentukan a `SchemaDefinition` untuk menentukan skema dalam format data Avro, JSON, atau Protobuf. Lihat contoh-contohnya.
Untuk format data 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\"} ]}"
```
Untuk format data 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\"}}}"
```
Untuk format data 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;}"
```
**Konsol AWS Glue**
Untuk menambahkan sebuah skema baru menggunakan konsol AWS Glue:
1. Masuk ke Konsol AWS Manajemen dan buka AWS Glue konsol di [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue\).
1. Di panel navigasi, pada **Katalog data**, pilih **Skema**.
1. Pilih **Tambahkan skema**.
1. Masukkan **Nama skema**, terdiri dari huruf, angka, tanda hubung, garis bawah, tanda dolar, atau tanda hash. Nama ini tidak dapat diubah.
1. Pilih **Registri** di mana skema akan disimpan dari menu drop-down. Registri induk tidak dapat diubah setelah dibuat.
1. Biarkan **Format data** sebagai *Apache Avro* atau *JSON*. Format ini berlaku untuk semua versi skema ini.
1. Pilih **Mode kompatibilitas**.
+ *Backward (disarankan)* — Penerima dapat membaca versi saat ini dan sebelumnya.
+ *Backward all* — Penerima dapat membaca versi terkini dan semua versi sebelumnya.
+ *Forward* — Pengirim dapat menulis baik versi terkini dan versi sebelumnya.
+ *Forward all* — Pengirim dapat menulis versi terkini dan semua versi sebelumnya.
+ *Full* — Kombinasi dari Backward dan Forward.
+ *Full all* — Kombinasi dari Backward All dan Forward All.
+ *None* — Tidak ada pemeriksaan kompatibilitas yang dilakukan.
+ *Disabled* — Mencegah versioning apapun untuk skema ini.
1. Masukkan **Deskripsi** opsional untuk registri yang terdiri hingga 250 karakter.
![\[Contoh membuat sebuah skema.\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/images/schema_reg_create_schema.png)
1. Opsional, terapkan satu atau beberapa tag untuk skema Anda. Pilih **Tambahkan tag** dan tentukan **Kunci tag** dan **Nilai tag** opsional.
1. Pada kotak **Versi skema pertama**, masukkan atau tempel skema awal Anda.
Untuk format Avro, lihat [Bekerja dengan format data Avro](#schema-registry-avro)
Untuk format JSON, lihat [Bekerja dengan format data JSON](#schema-registry-json)
1. Opsional, pilih **Tambahkan metadata** untuk menambahkan metadata versi untuk membuat anotasi atau mengklasifikasikan versi skema Anda.
1. Pilih **Buat skema dan versi**.
![\[Contoh membuat sebuah skema.\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/images/schema_reg_create_schema2.png)
Skema dibuat dan muncul dalam daftar pada **Skema**.
## Bekerja dengan format data Avro
Avro menyediakan layanan serialisasi data dan pertukaran data. Avro menyimpan definisi data dalam format JSON sehingga mudah untuk dibaca dan ditafsirkan. Data itu sendiri disimpan dalam format biner.
Untuk informasi tentang cara mendefinisikan skema Apache Avro, lihat [Spesifikasi Apache Avro](http://avro.apache.org/docs/current/spec.html).
## Bekerja dengan format data JSON
Data dapat diserialisasi dengan format JSON. [Format Skema JSON](https://json-schema.org/) mendefinisikan standar untuk format Skema JSON.
# Memperbarui skema atau registri
Setelah dibuat Anda dapat mengedit skema Anda, versi skema, atau registri Anda.
## Memperbarui registri
Anda dapat memperbarui registri menggunakan AWS Glue APIs atau AWS Glue konsol. Nama registri yang sudah ada tidak dapat Anda edit. Anda dapat mengedit deskripsi untuk sebuah registri.
**AWS Glue APIs**
Untuk memperbarui registri yang sudah ada, gunakan API [UpdateRegistry tindakan (Python: update\$1registry)](aws-glue-api-schema-registry-api.md#aws-glue-api-schema-registry-api-UpdateRegistry).
Menentukan sebuah struktur `RegistryId` untuk menunjukkan registri yang ingin Anda perbarui. Berikan sebuah `Description` untuk mengubah deskripsi untuk sebuah registri.
```
aws glue update-registry --description updatedDescription --registry-id RegistryArn="arn:aws:glue:us-east-2:901234567890:registry/registryName1"
```
**Konsol AWS Glue**
Untuk memperbarui sebuah registri menggunakan konsol AWS Glue:
1. Masuk ke Konsol Manajemen AWS dan buka AWS Glue konsol di [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue\).
1. Di panel navigasi, pada **Katalog data**, pilih **Registri Skema**.
1. Pilih sebuah registri dari daftar registri, dengan mencentang kotaknya.
1. Di menu **Tindakan**, pilih **Edit registri**.
# Memperbarui skema
Anda dapat memperbarui pengaturan deskripsi atau kompatibilitas untuk sebuah skema.
Untuk memperbarui skema yang sudah ada, gunakan API [UpdateSchema tindakan (Python: update\$1schema)](aws-glue-api-schema-registry-api.md#aws-glue-api-schema-registry-api-UpdateSchema).
Menentukan sebuah struktur `SchemaId` untuk menunjukkan skema yang ingin Anda perbarui. Salah satu dari `VersionNumber` atau `Compatibility` harus disediakan.
Contoh kode 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
```
# Menambahkan versi skema
Ketika Anda menambahkan sebuah versi skema, Anda akan perlu untuk membandingkan versi untuk memastikan skema baru akan diterima.
Untuk menambahkan versi baru ke sebuah skema yang ada, gunakan API [RegisterSchemaVersion tindakan (Python: register\$1schema\$1version)](aws-glue-api-schema-registry-api.md#aws-glue-api-schema-registry-api-RegisterSchemaVersion).
Menentukan sebuah struktur `SchemaId` untuk menunjukkan skema yang Anda ingin tambah versinya, dan sebuah `SchemaDefinition` untuk menentukan skemanya.
Contoh kode 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. Masuk ke Konsol Manajemen AWS dan buka AWS Glue konsol di [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue\).
1. Di panel navigasi, pada **Katalog data**, pilih **Skema**.
1. Pilih skema dari daftar skema, dengan mencentang kotaknya.
1. Pilih satu atau beberapa skema dari daftar, dengan mencentang kotak.
1. Pada menu **Tindakan**, pilih **Daftarkan versi baru**.
1. Pada kotak **Versi baru**, masukkan atau tempel skema baru Anda.
1. Pilih **Bandingkan dengan versi sebelumnya** untuk melihat perbedaan dengan versi skema sebelumnya.
1. Opsional, pilih **Tambahkan metadata** untuk menambahkan metadata versi untuk membuat anotasi atau mengklasifikasikan versi skema Anda. Masukkan **Kunci** dan **Nilai** opsional.
1. Pilih **Versi Registri**.
![\[Menambahkan sebuah versi skema.\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/images/schema_reg_add_schema_version.png)
Versi skema muncul pada daftar versi. Jika versi mengubah mode kompatibilitas, maka versi akan ditandai sebagai sebuah pos pemeriksaan.
## Contoh perbandingan versi skema
Ketika Anda memilih untuk **Bandingkan dengan versi sebelumnya**, maka Anda akan melihat versi sebelumnya dan versi baru ditampilkan bersama-sama. Informasi yang diubah akan disorot sebagai berikut:
+ *Kuning*: menunjukkan ada perubahan informasi.
+ *Hijau*: menunjukkan ada penambahan konten dalam versi terbaru.
+ *Merah*: menunjukkan ada penghapusan konten dalam versi terbaru.
Anda juga dapat membandingkan dengan versi yang sebelumnya.
![\[Contoh perbandingan sebuah versi skema.\]](http://docs.aws.amazon.com/id_id/glue/latest/dg/images/schema_reg_version_comparison.png)
# Menghapus skema atau registri
Menghapus sebuah skema, versi skema, atau registri adalah tindakan permanen yang tidak dapat dibatalkan.
## Menghapus skema
Anda mungkin ingin menghapus skema ketika tidak lagi digunakan dalam registri, menggunakan Konsol Manajemen AWS, atau [DeleteSchema tindakan (Python: delete\$1schema)](aws-glue-api-schema-registry-api.md#aws-glue-api-schema-registry-api-DeleteSchema) API.
Menghapus satu atau beberapa skema adalah tindakan permanen yang tidak dapat dibatalkan. Pastikan bahwa skema atau skema-skema itu tidak lagi diperlukan.
Untuk menghapus sebuah skema dari registri, panggil API [DeleteSchema tindakan (Python: delete\$1schema)](aws-glue-api-schema-registry-api.md#aws-glue-api-schema-registry-api-DeleteSchema), dengan menentukan struktur `SchemaId` untuk mengidentifikasi skema.
Contoh:
```
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"
```
**Konsol AWS Glue**
Untuk menghapus sebuah skema dari konsol AWS Glue:
1. Masuk ke Konsol Manajemen AWS dan buka AWS Glue konsol di [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue\).
1. Di panel navigasi, pada **Katalog data**, pilih **Registri Skema**.
1. Pilih registri yang berisi skema Anda dari daftar registri.
1. Pilih satu atau beberapa skema dari daftar, dengan mencentang kotak.
1. Di menu **Tindakan**, pilih **Hapus skema**.
1. Masukkan teks **Delete** di bidang untuk mengonfirmasi penghapusan.
1. Pilih **Hapus**.
Skema yang Anda tentukan akan dihapus dari registri.
## Menghapus versi skema
Saat skema terakumulasi dalam registri, Anda mungkin ingin menghapus versi skema yang tidak diinginkan menggunakan Konsol Manajemen AWS, atau API. [DeleteSchemaVersions tindakan (Python: delete\$1schema\$1versions)](aws-glue-api-schema-registry-api.md#aws-glue-api-schema-registry-api-DeleteSchemaVersions) Menghapus satu atau beberapa versi skema adalah tindakan permanen yang tidak dapat dibatalkan. Pastikan bahwa versi skema tersebut tidak diperlukan lagi.
Ketika menghapus versi skema, perhatikan batasan-batasan berikut:
+ Anda tidak dapat menghapus versi yang dikenai pemeriksaan.
+ Rentang versi berdekatan tidak boleh lebih dari 25.
+ Versi skema terbaru tidak boleh dalam status tertunda.
Menentukan struktur `SchemaId` untuk mengidentifikasi skema, dan menentukan `Versions` sebagai rentang versi yang akan dihapus. Untuk informasi lebih lanjut tentang menentukan versi atau rentang versi, lihat [DeleteRegistry tindakan (Python: delete\$1registry)](aws-glue-api-schema-registry-api.md#aws-glue-api-schema-registry-api-DeleteRegistry). Versi skema yang Anda tentukan akan dihapus dari registri.
Memanggil API [ListSchemaVersions tindakan (Python: list\$1schema\$1versions)](aws-glue-api-schema-registry-api.md#aws-glue-api-schema-registry-api-ListSchemaVersions) setelah panggilan ini akan mencantumkan status versi yang dihapus.
Contoh:
```
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. Masuk ke Konsol Manajemen AWS dan buka AWS Glue konsol di [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue\).
1. Di panel navigasi, pada **Katalog data**, pilih **Registri Skema**.
1. Pilih registri yang berisi skema Anda dari daftar registri.
1. Pilih satu atau beberapa skema dari daftar, dengan mencentang kotak.
1. Di menu **Tindakan**, pilih **Hapus skema**.
1. Masukkan teks **Delete** di bidang untuk mengonfirmasi penghapusan.
1. Pilih **Hapus**.
Versi skema yang Anda tentukan akan dihapus dari registri.
# Menghapus registri
Anda mungkin ingin menghapus sebuah registri ketika skema yang ada di dalamnya tidak lagi diatur berdasarkan registri itu. Anda harus menetapkan kembali skema tersebut ke registri yang lain.
Menghapus satu atau beberapa registri adalah tindakan permanen yang tidak dapat dibatalkan. Pastikan bahwa registri atau registri-registri tersebut tidak lagi diperlukan.
Registri default dapat dihapus menggunakan AWS CLI.
**API AWS Glue**
Untuk menghapus registri secara keseluruhan termasuk skema dan semua versinya, panggil API [DeleteRegistry tindakan (Python: delete\$1registry)](aws-glue-api-schema-registry-api.md#aws-glue-api-schema-registry-api-DeleteRegistry). Menentukan sebuah struktur `RegistryId` untuk mengidentifikasi registri.
Contoh:
```
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"
```
Untuk mendapatkan status operasi hapus, Anda dapat memanggil API `GetRegistry` setelah panggilan asinkron.
**Konsol AWS Glue**
Untuk menghapus sebuah registri dari konsol AWS Glue:
1. Masuk ke Konsol Manajemen AWS dan buka AWS Glue konsol di [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue\).
1. Di panel navigasi, pada **Katalog data**, pilih **Registri Skema**.
1. Pilih sebuah registri dari daftar, dengan mencentang kotaknya.
1. Di menu **Tindakan**, pilih **Hapus registri**.
1. Masukkan teks **Delete** di bidang untuk mengonfirmasi penghapusan.
1. Pilih **Hapus**.
Registri yang Anda pilih akan dihapus dari AWS Glue.
## Contoh IAM untuk serializer
**catatan**
AWS kebijakan terkelola memberikan izin yang diperlukan untuk kasus penggunaan umum. Untuk informasi tentang menggunakan kebijakan terkelola untuk mengelola Registri Skema, lihat [AWS kebijakan terkelola (standar) untuk AWS Glue](security-iam-awsmanpol.md#access-policy-examples-aws-managed).
Untuk serializer, Anda harus membuat sebuah kebijakan yang paling tidak serupa dengan yang di bawah ini untuk memberikan Anda kemampuan untuk menemukan `schemaVersionId` untuk definisi skema yang diberikan. Catatan, Anda harus memiliki izin baca pada registri agar dapat membaca skema dalam registri tersebut. Anda dapat membatasi registri yang dapat dibaca dengan menggunakan klausul `Resource`.
Contoh kode 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"
]
}
```
Selanjutnya, Anda juga dapat memungkinkan produsen untuk membuat skema dan versi baru dengan memasukkan metode tambahan berikut. Catatan, Anda harus dapat memeriksa registri untuk skema add/remove/evolve di dalamnya. Anda dapat membatasi registri yang dapat diperiksa dengan menggunakan klausul `Resource`.
Contoh kode 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"
]
}
```
## Contoh IAM untuk deserializer
Untuk deserializer (sisi konsumen), Anda harus membuat kebijakan yang serupa dengan yang di bawah ini untuk memungkinkan deserializer mengambil skema dari Registri Skema untuk melakukan deserialisasi. Catatan, Anda harus dapat memeriksa registri agar dapat mengambil skema di dalamnya.
Contoh kode 15:
```
{
"Sid" : "GetSchemaVersion",
"Effect" : "Allow",
"Action" :
[
"glue:GetSchemaVersion"
],
"Resource" : ["*"]
}
```
## Konektivitas pribadi menggunakan AWS PrivateLink
Anda dapat menggunakan AWS PrivateLink untuk menghubungkan VPC produsen data Anda AWS Glue dengan mendefinisikan titik akhir VPC antarmuka untuk. AWS Glue Ketika Anda menggunakan titik akhir antarmuka VPC, komunikasi antara VPC dan AWS Glue dilakukan sepenuhnya di jaringan AWS . Untuk informasi selengkapnya, lihat [Menggunakan AWS Glue dengan Titik Akhir VPC](https://docs.aws.amazon.com/glue/latest/dg/vpc-endpoint.html).
# Mengakses metrik Amazon CloudWatch
CloudWatch Metrik Amazon tersedia sebagai bagian dari CloudWatch tingkat gratis. Anda dapat mengakses metrik ini di CloudWatch konsol. Metrik tingkat API meliputi CreateSchema (Sukses dan Latensi),, (Sukses dan Latensi) GetSchemaByDefinition, (Sukses dan Latensi), GetSchemaVersion (Sukses dan Latensi), RegisterSchemaVersion (Sukses dan Latensi). PutSchemaVersionMetadata Metrik tingkat sumber daya termasuk Registry. ThrottledByLimit, SchemaVersion. ThrottledByLimit, SchemaVersion .Ukuran.
# Contoh CloudFormation template untuk registri skema
Berikut ini adalah contoh template untuk membuat sumber Schema Registry di CloudFormation. Untuk membuat tumpukan ini di akun Anda, salin templat di atas ke dalam file `SampleTemplate.yaml`, dan jalankan perintah berikut:
```
aws cloudformation create-stack --stack-name ABCSchemaRegistryStack --template-body "'cat SampleTemplate.yaml'"
```
Contoh ini menggunakan `AWS::Glue::Registry` untuk membuat registri, `AWS::Glue::Schema` untuk membuat skema, `AWS::Glue::SchemaVersion` untuk membuat versi skema, dan `AWS::Glue::SchemaVersionMetadata` untuk mengisi metadata versi skema.
```
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:
Project: "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:
Project: "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"
```