Service Registry 用户指南


Red Hat Integration 2022.Q3

使用 Service Registry 2.3

摘要

本指南介绍 Service Registry 并介绍如何使用 Service Registry web 控制台、REST API、Maven 插件或 Java 客户端来管理事件 schema 和 API 设计。本指南还解释了如何在 Java 消费者和制作者中使用 Kafka 客户端序列化器和反序列化器。它还描述了支持的 Service Registry 内容类型,以及可选的规则配置。

前言

使开源包含更多

红帽致力于替换我们的代码、文档和 Web 属性中存在问题的语言。我们从这四个术语开始:master、slave、黑名单和白名单。由于此项工作十分艰巨,这些更改将在即将推出的几个发行版本中逐步实施。有关更多详情,请参阅我们的首席技术官 Chris Wright 提供的消息

第 1 章 Service Registry 简介

本章介绍了 Service Registry 概念和功能,并提供了有关 registry 中支持的工件类型的详情:

1.1. 什么是服务 registry?

Service Registry 是一个数据存储,用于跨事件驱动的和 API 架构共享标准事件模式和 API 设计。您可以使用 Service Registry 将数据结构与客户端应用程序分离,并使用 REST 接口在运行时共享和管理您的数据类型和 API 描述。

例如,客户端应用程序可以在运行时动态推送或拉取最新的模式更新,而无需重新部署。开发者团队可以查询 registry 以获取已部署到生产环境中的服务所需的现有模式,并可在开发中注册新服务所需的新架构。

您可以通过在客户端应用程序代码中指定 registry URL,启用客户端应用程序以使用存储在 Service Registry 中的模式和 API 设计。例如,registry 可以存储用于序列化和反序列化消息的 schema,然后从客户端应用程序引用这些消息,以确保它们发送和接收的消息与这些架构兼容。

使用 Service Registry 将数据结构与应用程序分离,通过降低总体消息大小来降低成本,并通过增加整个机构中的 schema 和 API 设计来提升效率。Service Registry 提供了一个 Web 控制台,供开发人员和管理员用于管理注册表内容。

另外,您可以配置可选规则来监管 registry 内容的演进。例如,这包括用于确保上传的内容是语法上有效或之后有效的规则,或者可向后兼容其他版本。任何配置的规则都必须在将新版本上传到 registry 前进行传递,这样可确保时间不显示在无效或不兼容的 schema 或 API 设计中。

Service Registry 基于 Apicurio Registry 开源社区项目。详情请查看 https://github.com/apicurio/apicurio-registry

Service Registry 功能
  • 标准事件模式和 API 规格的多个有效负载格式,如 Apache Avro、JSON Schema、A Protobuf、AsyncAPI、OpenAPI 等
  • AMQ Streams 或 PostgreSQL 数据库中的可插拔 registry 存储选项
  • 用于内容验证和版本兼容性的规则,以监管 registry 内容随时间发展的方式
  • 使用 Web 控制台、REST API、命令行、Maven 插件或 Java 客户端进行注册表内容管理
  • 完整的 Apache Kafka 模式 registry 支持,包括与外部系统集成的 Kafka Connect
  • Kafka 客户端 serializers/deserializers (SerDes)在运行时验证消息类型
  • 与现有 Confluent 或 IBM schema registry 客户端应用程序兼容
  • 云原生 Quarkus Java 运行时,内存低消耗和快速部署时间
  • 基于 Operator 的 Service Registry 在 OpenShift 上安装
  • 使用 Red Hat Single Sign-On 进行 OpenID Connect(OIDC)身份验证

1.2. Service Registry 中的 schema 和 API 工件

存储在 Service Registry 中的项目(如事件模式和 API 设计)称为 registry 工件。以下示例显示了 JSON 格式的 Apache Avro schema 工件示例,用于简单共享价格应用程序:

Avro 模式示例

{
   "type": "record",
   "name": "price",
   "namespace": "com.example",
   "fields": [
       {
           "name": "symbol",
           "type": "string"
       },
       {
           "name": "price",
           "type": "string"
       }
   ]
}
Copy to Clipboard Toggle word wrap

当架构或 API 设计添加为 registry 中的工件时,客户端应用程序可以使用该模式或 API 设计来验证客户端消息是否符合运行时正确的数据结构。

Service Registry 支持各种消息有效负载格式,用于标准事件模式和 API 规格。例如,支持的格式包括 Apache Avro、Google Protobuf、GraphQL、AsyncAPI、OpenAPI 等。

架构和 API 组

工件组 是一个可选的、名为 schema 或 API 工件的集合。每个组包含一组逻辑上相关的模式或 API 设计,通常由单一实体管理,属于特定的应用程序或组织。

您可以在添加模式和 API 设计时创建可选的工件组,以便将其整理在 Service Registry 中。例如,您可以创建组以匹配 开发和生产 应用程序环境,或您的 销售 和工程 组织。

模式和 API 组可以包含多个工件类型。例如,您可以有 Protobuf、Avro、JSON Schema、OpenAPI 或 AsyncAPI 工件在同一组中。

您可以使用 Service Registry Web 控制台、核心 REST API、命令行、Maven 插件或 Java 客户端应用程序创建架构和 API 工件和组。以下简单示例显示了使用 registry 核心 REST API:

$ curl -X POST -H "Content-type: application/json; artifactType=AVRO" \
  -H "X-Registry-ArtifactId: share-price" \
  --data '{"type":"record","name":"price","namespace":"com.example", \
   "fields":[{"name":"symbol","type":"string"},{"name":"price","type":"string"}]}' \
  https://my-registry.example.com/apis/registry/v2/groups/my-group/artifacts
Copy to Clipboard Toggle word wrap

本例创建一个名为 my-group 的构件组,并添加 Avro 模式,工件 ID 为 share-price

注意

在使用 Service Registry web 控制台时,指定组是可选的,其中会自动创建默认组。使用 REST API 或 Maven 插件时,如果您不想创建唯一的组,请在 API 路径中指定 default 组。

引用其他 schema 和 API

某些 Service Registry 工件类型可以包含从一个 工件文件到另一个工件文件中的工件引用。您可以通过定义可重复使用的模式或 API 组件来创建效率,然后从多个位置引用它们。例如,您可以使用 $ref 语句在 JSON Schema 或 OpenAPI 中指定引用,也可以使用 导入 语句在 Google protobuf 中,或使用嵌套命名空间在 Apache Avro 中指定。

以下示例显示了名为 TradeKey 的简单 Avro 模式,其中包含使用嵌套命名空间对名为 Exchange 的另一个模式引用:

带有嵌套 Exchange 模式的 Tradekey 模式

{
 "namespace": "com.kubetrade.schema.trade",
 "type": "record",
 "name": "TradeKey",
 "fields": [
   {
     "name": "exchange",
     "type": "com.kubetrade.schema.common.Exchange"
   },
   {
     "name": "key",
     "type": "string"
   }
 ]
}
Copy to Clipboard Toggle word wrap

Exchange schema

{
 "namespace": "com.kubetrade.schema.common",
 "type": "enum",
 "name": "Exchange",
 "symbols" : ["GEMINI"]
}
Copy to Clipboard Toggle word wrap

工件引用作为工件元数据的集合存储在 Service Registry 中,它从特定于工件类型的引用中映射到内部 Service Registry 引用。Service Registry 中的每个工件引用由以下组成:

  • 组 ID
  • 工件 ID
  • 工件版本
  • 工件引用名称

您可以使用 Service Registry 核心 REST API、Maven 插件和 Java serializers/deserializers (SerDes)来管理工件引用。Service Registry 存储工件引用以及工件内容。Service Registry 还维护一组所有工件引用,以便您可以搜索或列出特定工件的所有引用。

支持的工件类型

Service Registry 目前仅支持以下工件类型的构件引用:

  • Avro
  • protobuf
  • JSON 架构

1.3. 使用 Service Registry Web 控制台管理内容

您可以使用 Service Registry Web 控制台浏览和搜索存储在 registry 中的 schema 和 API 工件以及可选组,并添加新的 schema 和 API 工件、组和版本。您可以通过标签、名称、组和描述来搜索工件。您可以查看工件的内容或其可用版本,或者在本地下载工件文件。

您还可以为 registry 内容(包括全局)和 API 工件配置可选规则。当新的模式和 API 工件或版本上传到 registry 时,会应用这些用于内容验证和兼容性的可选规则。

如需了解更多详细信息,请参阅 第 9 章 Service Registry 工件参考

图 1.1. Service Registry Web 控制台

Service Registry Web 控制台通过 http://MY_REGISTRY_URL/ui 获取。

1.4. Service Registry 核心 REST API

客户端应用程序可以使用 Service Registry 核心 v2 REST API 管理 Service Registry 中的 schema 和 API 工件。此 API 为以下目的提供了创建、读取、更新和删除操作:

工件
管理存储在 registry 中的模式和 API 工件。您还可以管理工件的生命周期状态: enabled、disabled 或 deprecated。
工件版本
更新 schema 或 API 工件时所创建的管理版本。您还可以管理工件版本的生命周期状态: enabled、disabled 或 deprecated。
工件元数据
管理架构或 API 工件的详情,如创建或修改的时间,及其当前状态。您可以编辑工件名称、描述或标签。工件组以及工件创建或修改的时间为只读。
工件规则
配置规则以监管特定架构或 API 工件的内容演进,以防止将无效或不兼容的内容添加到 registry 中。工件规则覆盖配置的任何全局规则。
全局规则
配置规则,以管理所有模式和 API 工件的内容演进,以防止将无效或不兼容的内容添加到 registry 中。只有在工件没有配置自己的特定工件规则时,才会应用全局规则。
搜索
浏览或搜索 schema 和 API 工件和版本,如按名称、组、描述或标签。
Admin
.zip 文件中导出或导入 registry 内容,并在运行时管理 registry 服务器实例的日志级别。
与其他架构 registry REST API 的兼容性

Service Registry 通过包括其相应的 REST API 实现与以下 schema registry 的兼容性:

  • Service Registry core v1
  • Confluent Schema Registry v6
  • IBM Event Streams schema registry v1
  • CNCF CloudEvents Schema Registry v0

使用 Confluent 客户端库的应用程序可以使用 Service Registry 作为替换功能。如需了解更多详细信息,请参阅 Replacing Confluent Schema Registry

1.5. Service Registry 存储选项

Service Registry 为 registry 数据的底层存储提供以下选项:

Expand
表 1.1. Service Registry 数据存储选项
存储选项描述

PostgreSQL 12 数据库

PostgreSQL 是生产环境中的性能、稳定性和数据管理(backup/restore 等)的建议数据存储选项。

AMQ Streams 2.1

对于没有可用的数据库管理专业知识或 Kafka 中的存储是特定的要求,为生产环境提供了 Kafka 存储。

Kafka producer 应用程序可以使用序列化器对符合特定事件 schema 的消息进行编码。然后,Kafka 使用者应用程序可以使用反序列化器验证消息已使用正确的模式序列化,具体取决于特定的模式 ID。

图 1.2. Service Registry 和 Kafka 客户端架构

Service Registry 提供 Kafka 客户端序列化rs/deserializers(SerDes)来在运行时验证以下消息类型:

  • Apache Avro
  • Google 协议缓冲
  • JSON 架构

Service Registry Maven 存储库和源代码发行版本包括这些消息类型的 Kafka SerDes 实施,Kafka 客户端应用程序开发人员可以与 registry 集成。

这些实施包括每个支持的消息类型的自定义 Java 类,如 io.apicurio.registry.serde.avro,客户端应用程序在运行时用于从 registry 中拉取 schema 进行验证。

您可以将 Service Registry 与 Apache Kafka Connect 搭配使用,在 Kafka 和外部系统间流数据。使用 Kafka Connect,您可以为不同的系统定义连接器,将大量数据移出基于 Kafka 的系统。

图 1.3. Service Registry 和 Kafka Connect 架构

Service Registry 为 Kafka Connect 提供了以下功能:

  • Kafka 连接模式存储
  • Kafka Connect converters for Apache Avro 和 JSON Schema
  • 用于管理模式的 registry REST API

您可以使用 Avro 和 JSON 架构转换器将 Kafka Connect 模式映射到 Avro 或 JSON 模式。这些模式随后可以将消息键和值序列化为紧凑 Avro 二进制格式或人类可读的 JSON 格式。转换的 JSON 也不详细,因为消息不包含 schema 信息,只包含 schema ID。

Service Registry 可以管理和跟踪 Kafka 主题中使用的 Avro 和 JSON 模式。由于模式存储在 Service Registry 中,并与消息内容分离,每种消息必须只包含 tiny 模式标识符。对于类似 Kafka 的 I/O 绑定系统,这意味着生产者和消费者的更多吞吐量。

Service Registry 提供的 Avro 和 JSON 架构序列化rs 和 deserializers(SerDes)也由 Kafka 生产者和消费者使用。您编写为消耗更改事件的 Kafka 消费者应用程序可以使用 Avro 或 JSON Serde 来反序列化这些更改事件。您可以将这些 SerDes 安装到任何基于 Kafka 的系统,并将它们与 Kafka Connect 一起使用,或者与基于 Kafka Connect 的系统(如 Debezium 和 Camel Kafka Connector)一起使用。

1.8. Service Registry 演示示例

Service Registry 提供开源示例应用程序,它演示了如何在不同用例中使用 Service Registry。例如,这包括存储 Kafka 序列化器和反序列化器(SerDes)类使用的模式。这些 Java 类从 registry 获取的 schema,以便在生成或消耗操作以序列化、去序列化或验证 Kafka 消息有效负载时使用。

这些示例应用程序包括以下内容:

  • Apache Avro SerDes
  • Google Protobuf SerDes
  • JSON Schema SerDes
  • Confluent SerDes
  • 自定义 ID 策略
  • REST 客户端
  • 云事件
  • Quarkus 和 Kafka
  • 带有 Quarkus 和 Kafka 的 Apache Camel

1.9. Service Registry 可用的发行版本

服务 Registry 提供以下分发选项。

Expand
表 1.2. Service Registry Operator 和镜像
分发位置发行类别

Service Registry Operator

OperatorsOperatorHub下的 OpenShift Web 控制台

公开发行

Service Registry Operator 的容器镜像

红帽生态系统目录

公开发行

AMQ Streams 中的 Kafka 存储的容器镜像

红帽生态系统目录

公开发行

PostgreSQL 中数据库存储的容器镜像

红帽生态系统目录

公开发行

Expand
表 1.3. Service Registry zip 下载
分发位置发行类别

安装自定义资源定义示例

Red Hat Software Downloads

公开发行

Service Registry v1 到 v2 迁移工具

Red Hat Software Downloads

公开发行

Maven 软件仓库

Red Hat Software Downloads

公开发行

源代码

Red Hat Software Downloads

公开发行

Kafka Connect converters

Red Hat Software Downloads

公开发行

注意

您必须有 Red Hat Integration 订阅并登录红帽客户门户网站才能访问可用的服务 Registry 发行版本。

第 2 章 Service Registry 内容规则

本章论述了用来管理 registry 内容的可选规则,并提供了有关可用规则配置的详情:

2.1. 使用规则管理 registry 内容

要管理 registry 内容的演进,您可以为添加到 registry 中的工件内容配置可选规则。所有配置的全局规则或构件规则都必须通过,然后才能将新的工件版本上传到 registry。配置工件规则覆盖任何配置的全局规则。

这些规则的目的是防止将无效的内容添加到 registry 中。例如,内容可能会因为以下原因无效:

  • 给定工件类型的无效语法(例如 AVROPROTOBUF
  • 有效语法,但语义违反规格
  • 不兼容,当新内容包含与当前工件版本相关的中断更改时

您可以使用 Service Registry Web 控制台、REST API 命令或 Java 客户端应用程序启用可选内容规则。

2.1.1. 应用规则

只有在内容添加到 registry 时,才会应用规则。这包括以下 REST 操作:

  • 添加工件
  • 更新工件
  • 添加工件版本

如果违反规则,Service Registry 会返回 HTTP 错误。响应正文包含违反的规则,以及显示错误的消息。

2.1.2. 规则优先级

您可以在全局级别和工件级别配置 Service Registry 内容规则。优先级顺序如下:

  • 如果您启用工件规则和对应的全局规则,则工件规则会覆盖全局规则。
  • 如果您禁用工件规则,并且启用相同的全局规则,则应用全局规则。
  • 如果您在工件级别和全局级别上禁用规则,您可以禁用所有工件的规则。
  • 如果您在工件级别将规则值设置为 NONE,则会覆盖启用的全局规则。在本例中,工件规则值 NONE 优先于这个工件,但启用的全局规则将继续应用到工件级别禁用该规则的任何其他工件。

2.1.3. 规则如何工作

每个规则都有一个名称和配置信息。registry 维护每个工件和全局规则列表的规则列表。列表中的每个规则都包含规则实施的名称和配置。

提供了包含工件当前版本的内容(如果存在)以及正在添加的工件的新版本。规则实施根据工件通过规则返回 true 或 false。如果没有,registry 会报告 HTTP 错误响应的原因。有些规则可能无法使用旧版本的内容。例如,兼容性规则使用之前的版本,但语法或语义有效规则不会发生。

2.1.4. 内容规则配置

您可以为每个工件以及全局配置规则。Service Registry 应用为特定工件配置的规则。如果没有在该级别上配置规则,则 Service Registry 将应用全局配置的规则。如果没有配置全局规则,则不会应用任何规则。

配置工件规则

您可以使用 Service Registry web 控制台或 REST API 配置工件规则。详情请查看以下内容:

配置全局规则

您可以通过几种方法配置全局规则:

  • 使用 REST API 中的 /rules 操作
  • 使用 Service Registry Web 控制台
  • 使用 Service Registry 应用程序属性设置默认全局规则

配置默认全局规则

您可以在应用程序级别上配置 Service Registry,以启用或禁用全局规则。您可以在安装时使用以下应用程序属性格式配置默认全局规则,而无需安装后配置:

registry.rules.global.<ruleName>
Copy to Clipboard Toggle word wrap

目前支持以下规则名称:

  • 兼容性
  • 有效期

application 属性的值必须是有效的配置选项,特定于所配置的规则。

注意

您可以将这些应用程序属性配置为 Java 系统属性,或者在 Quarkus application.properties 文件中包含它们。如需了解更多详细信息,请参阅 Quarkus 文档

本章论述了如何使用 Service Registry Web 控制台管理存储在 registry 中的 schema 和 API 工件。这包括上传和浏览 registry 内容以及配置可选规则:

3.1. 使用 Service Registry Web 控制台查看工件

您可以使用 Service Registry Web 控制台浏览 registry 中存储的事件 schema 和 API 工件。本节显示了查看 Service Registry 工件、组、版本和工件规则的简单示例。

先决条件

  • Service Registry 在您的环境中安装并运行。
  • 登录到 Service Registry web 控制台:

    http://MY_REGISTRY_URL/ui

  • 使用 Web 控制台、命令行、Maven 插件或 Java 客户端应用程序已将工件添加到 Service Registry。

流程

  1. Artifacts 选项卡中,浏览 Service Registry 中存储的工件列表,或者输入搜索字符串来查找工件。您可以从列表中选择特定条件(如名称、组、标签或全局 ID)进行搜索。

    图 3.1. Service Registry web 控制台中的工件

  2. 点击工件来查看以下详情:

    • 概述 :显示工件版本元数据,如名称、可选组和 ID、全局 ID、内容 ID、标签和属性。另外,还显示您可以为工件内容配置的有效性和兼容性的规则。
    • 文档 (仅限 OpenAPI 和 AsyncAPI):显示自动生成的 REST API 文档。
    • 内容 :显示完整工件内容的只读视图。对于 JSON 内容,您可以点击 JSONYAML 来显示您首选的格式。
  3. 如果添加了此工件的额外版本,您可以从页面标头中的 Version 列表中选择它们。
  4. 要将工件内容保存到本地文件,例如 my-protobuf-schema.proto,请单击页面末尾的 Download

3.2. 使用 Service Registry Web 控制台添加工件

您可以使用 Service Registry Web 控制台将事件 schema 和 API 工件上传到 registry。本节演示了上传 Service Registry 工件和添加新的工件版本的简单示例。

先决条件

  • Service Registry 在您的环境中安装并运行。
  • 登录到 Service Registry web 控制台:

    http://MY_REGISTRY_URL/ui

流程

  1. Artifacts 选项卡中,单击 Upload artifact,并指定以下详情:

    • group 和 ID :使用默认空设置自动生成工件 ID,并将工件 添加到默认 工件组中。或者,您可以输入可选的工件组名称或 ID。
    • 类型 :使用默认 Auto-Detect 设置来自动检测工件类型,或从列表中选择工件类型,如 Avro SchemaOpenAPI

      注意

      Service Registry 无法自动检测 Kafka Connect Schema 工件类型。您必须手动选择这个工件类型。

    • 工件 :使用以下选项之一指定工件位置:

      • 从文件 :单击 Browse,然后选择一个文件,或者拖放文件。例如,my-openapi.jsonmy-schema.proto
      • 从 URL :输入有效并可访问 URL,然后单击 Fetch。例如: https://petstore3.swagger.io/api/v3/openapi.json
  2. Upload,查看工件详情:

    • 概述 :显示工件版本元数据,如名称、工件 ID、全局 ID、内容 ID、标签和属性。另外,还显示您可以为工件内容配置的有效性和兼容性的规则。
    • 文档 (仅限 OpenAPI 和 AsyncAPI):显示自动生成的 REST API 文档。
    • 内容 :显示完整工件内容的只读视图。对于 JSON 内容,您可以点击 JSONYAML 来显示您首选的格式。

      以下示例显示了 Protobuf 模式工件示例:

      图 3.2. Service Registry web 控制台中的工件详情

  3. Overview 选项卡上,点击 Edit 铅笔图标以编辑工件元数据,如名称或描述。

    您还可以输入以逗号分隔的标签列表来搜索,或者添加与工件关联的任意属性的键值对。要添加属性,请执行以下步骤:

    1. 单击 Add property
    2. 输入键名称和值。
    3. 重复前两个步骤来添加多个属性。
    4. Save
  4. 要将工件内容保存到本地文件,例如 my-protobuf-schema.proto,请单击页面末尾的 Download
  5. 要添加一个新的工件版本,点页面标头中的 Upload new version,然后拖放,或者点击 Browse 上传该文件,例如 my-avro-schema.jsonmy-openapi.json
  6. 要删除工件,点页面标头中的 Delete

    警告

    删除工件将删除工件及其所有版本,无法撤消。工件版本不可变,无法单独删除。

您可以使用 Service Registry web 控制台配置可选规则,以防止将无效的内容添加到 registry 中。所有配置的工件规则或全局规则都必须传递,然后才能将新的工件版本上传到 Service Registry。配置工件规则覆盖任何配置的全局规则。本节演示了配置全局和工件规则的简单示例。

先决条件

  • Service Registry 在您的环境中安装并运行。
  • 登录到 Service Registry web 控制台:

    http://MY_REGISTRY_URL/ui

  • 使用 Web 控制台、命令行、Maven 插件或 Java 客户端应用程序已将工件添加到 Service Registry。

流程

  1. Artifacts 选项卡中,浏览 Service Registry 中的工件列表,或者输入搜索字符串来查找工件。您可以从列表中选择根据特定条件(如工件名称、组、标签或全局 ID)进行搜索。
  2. 点工件查看其版本详情和内容规则。
  3. Content rules 中,点 Enable 为工件内容配置有效规则或兼容性规则,并从列表中选择适当的规则配置,例如:完全了解有效期规则。

    图 3.3. Service Registry web 控制台中的工件内容规则

  4. 若要访问全局规则,请单击 Service Registry 实例,再单击 Global rules 选项卡。点击 Enable 为所有工件内容配置全局有效规则或兼容性规则,并从列表中选择适当的规则配置。
  5. 要禁用工件规则或全局规则,请点击规则旁边的垃圾箱图标。

作为管理员,您可以使用 Service Registry web 控制台在运行时为 Service Registry 实例配置动态设置。您可以管理身份验证、授权和 API 兼容性等功能的配置选项。

注意

只有在部署了 Service Registry 实例时,身份验证和授权设置才会在 web 控制台中显示。如需了解更多详细信息,请参阅在 OpenShift 上安装和部署 Service Registry

先决条件

  • Service Registry 实例已部署。
  • 使用管理员访问权限登录到 Service Registry web 控制台:

    http://MY_REGISTRY_URL/ui

流程

  1. 在 Service Registry web 控制台中点 Settings 选项卡。
  2. 选择您要为此 Service Registry 实例配置的设置:

    Expand
    表 3.1. 身份验证设置
    设置描述

    HTTP 基本身份验证

    仅在已经启用身份验证时显示。选择后,除了 OAuth 外,Service Registry 用户可以使用 HTTP 基本身份验证进行身份验证。默认未选择。

    Expand
    表 3.2. 授权设置
    设置描述

    匿名读访问

    仅在已经选择身份验证时显示。选择了 Service Registry 时,Service Registry 会为来自匿名用户的请求提供只读访问权限,而无需任何凭证。如果要使用这个实例在外部发布架构或 API,则此设置很有用。默认未选择。

    工件所有者授权

    仅在已经启用身份验证时显示。选择后,只有创建工件的用户才能修改该工件。默认未选择。

    工件组所有者授权

    只有在已经启用身份验证并且选择了 Artifact 所有者授权时,才会显示。选择后,只有创建工件组的用户才具有对该工件组的写入权限,例如,在该组中添加或删除工件。默认未选择。

    经身份验证的读取访问权限

    仅在已经启用身份验证时显示。选择了后,Service Registry 会为任何经过身份验证的用户授予对来自任何经过身份验证的用户请求的只读访问权限,而不考虑用户角色。默认未选择。

    Expand
    表 3.3. 兼容性设置
    设置描述

    传统 ID 模式(兼容性 API)

    选择了 Confluent Schema Registry 兼容性 API 使用 globalId 而不是 contentId 作为工件标识符。此设置在根据 v1 Core Registry API 从旧的 Service Registry API 迁移时很有用。默认未选择。

    Expand
    表 3.4. Web 控制台设置
    设置描述

    下载链接过期

    为安全起见(例如,从实例导出工件数据时,生成到 .zip 下载文件的链接处于活跃状态)的秒数。默认为 30 秒。

    UI 只读模式

    选择了 Service Registry web 控制台时,Service Registry Web 控制台被设置为只读,防止创建、读取、更新或删除操作。使用 Core Registry API 所做的更改不受此设置的影响。默认未选择。

作为管理员,或作为 schema 或 API 工件的所有者,您可以使用 Service Registry Web 控制台将工件所有者更改为另一个用户帐户。

例如,如果在 Settings 选项卡上为 Service Registry 实例设置了 Artifact owner-only authorization 选项,此功能很有用,以便只有所有者或管理员才可以修改工件。如果所有者用户离开组织或所有者帐户,您可能需要更改所有者。

注意

只有在部署了 Service Registry 实例时,才会显示 Artifact owner- only authorization 设置和 artifact Owner 字段。如需了解更多详细信息,请参阅在 OpenShift 上安装和部署 Service Registry

先决条件

  • 部署 Service Registry 实例,并创建了构件。
  • 以工件的当前所有者或管理员的身份登录到 Service Registry web 控制台:

    http://MY_REGISTRY_URL/ui

流程

  1. Artifacts 选项卡中,浏览 Service Registry 中存储的工件列表,或者输入搜索字符串以查找工件。您可以从列表中选择要按条件进行搜索,如名称、组、标签或全局 ID。
  2. 点击您要重新分配的工件。
  3. Version metadata 部分中,点击 Owner 字段旁边的铅笔图标。
  4. New owner 字段中,选择或输入帐户名称。
  5. Change owner

作为管理员,您可以使用 Service Registry web 控制台从一个 Service Registry 实例导出数据,并将它导入到另一个 Service Registry 实例。您可以使用此功能在不同的实例之间轻松迁移数据。

以下示例演示了如何在 .zip 文件中导出并导入一个 Service Registry 实例中的现有数据到另一个实例。Service Registry 实例中包含的所有构件数据都在 .zip 文件中导出。

注意

您只能导入从另一个服务 Registry 实例导出的 Service Registry 数据。

先决条件

  • 服务 Registry 实例已创建如下:

    • 从导出的源实例至少包含一个 schema 或 API 工件
    • 您导入的目标实例为空来保留唯一 ID
  • 使用管理员访问权限登录到 Service Registry web 控制台:

    http://MY_REGISTRY_URL/ui

流程

  1. 在源 Service Registry 实例的 web 控制台中,查看 Artifacts 选项卡。
  2. 单击 Upload artifact 旁边的选项图标(three vertical dots),然后选择 Download all artifacts (.zip file),将这个实例的 registry 数据导出到 .zip 下载文件。
  3. 在目标 Service Registry 实例的 web 控制台中,查看 Artifacts 选项卡。
  4. Upload artifact 旁边的选项图标,然后选择 Upload multiple artifacts
  5. 拖放或浏览到您之前导出的 .zip 下载文件。
  6. Upload 并等待导入数据。

第 4 章 使用 REST API 管理 Service Registry 内容

客户端应用程序可以使用 Registry REST API 操作来管理 Service Registry 中的 schema 和 API 工件,例如在生产环境中部署的 CI/CD 管道中。Registry REST API 为存储在 registry 中的工件、版本、元数据和规则提供创建、读取、更新和删除操作。如需更多信息,请参阅 Apicurio Registry REST API 文档

本章论述了 Service Registry core REST API,并演示了如何使用它来管理 registry 中存储的模式和 API 工件:

本节演示了一个简单的基于 curl 的示例,它使用了 Service Registry 核心 REST API 在 Service Registry 中添加和检索 Apache Avro schema 工件。

先决条件

  • Service Registry 在您的环境中安装并运行

流程

  1. 使用 /groups/{group}/artifacts 操作向 registry 添加工件。以下示例 curl 命令为共享价格应用程序添加一个简单的工件:

    $ curl -X POST -H "Content-Type: application/json; artifactType=AVRO" \
      -H "X-Registry-ArtifactId: share-price" \
      -H "Authorization: Bearer $ACCESS_TOKEN" \
      --data '{"type":"record","name":"price","namespace":"com.example", \
       "fields":[{"name":"symbol","type":"string"},{"name":"price","type":"string"}]}' \
      MY-REGISTRY-URL/apis/registry/v2/groups/my-group/artifacts
    Copy to Clipboard Toggle word wrap
    • 这个示例添加了一个 Avro schema 工件 ID,其工件 ID 为 share-price。如果没有指定唯一的工件 ID,Service Registry 会自动生成一个 UUID。
    • MY-REGISTRY-URL 是在其上部署 Service Registry 的主机名。例如: my-cluster-service-registry-myproject.example.com
    • 本例在 API 路径中指定 my-group 的组 ID。如果没有指定唯一组 ID,则必须在 API 路径中指定 ../groups/default
  2. 验证响应是否包含预期的 JSON 正文,以确认工件已被添加。例如:

    {"createdBy":"","createdOn":"2021-04-16T09:07:51+0000","modifiedBy":"",
    "modifiedOn":"2021-04-16T09:07:51+0000","id":"share-price","version":"1",
    "type":"AVRO","globalId":2,"state":"ENABLED","groupId":"my-group","contentId":2}
    Copy to Clipboard Toggle word wrap
    • 在添加工件时没有指定版本,因此会自动创建默认版本 1
    • 这是添加到 registry 的第二个工件,因此全局 ID 和内容 ID 的值为 2
  3. 在 API 路径中使用其工件 ID 从 registry 检索工件内容。在这个示例中,指定的 ID 是 shared -price

    $ curl -H "Authorization: Bearer $ACCESS_TOKEN" \
     MY-REGISTRY-URL/apis/registry/v2/groups/my-group/artifacts/share-price \
     {"type":"record","name":"price","namespace":"com.example",
      "fields":[{"name":"symbol","type":"string"},{"name":"price","type":"string"}]}
    Copy to Clipboard Toggle word wrap

如果您没有在使用 v2 核心 REST API 添加 schema 和 API 工件到 Service Registry 时指定工件版本,Service Registry 会自动生成一个。创建新工件时的默认版本为 1

Service Registry 还支持自定义版本,您可以在其中使用 X-Registry-Version HTTP 请求标头作为字符串来指定版本。指定自定义版本值会覆盖通常会在创建或更新工件时分配的默认版本。然后,您可以在执行需要版本的 REST API 操作时使用此版本值。

本节演示了一个简单的基于 curl 的示例,它使用 registry v2 核心 REST API 添加和检索 registry 中的自定义 Apache Avro 模式版本。在使用 REST API 添加或更新工件或添加工件版本时,可以指定自定义版本。

先决条件

  • Service Registry 在您的环境中安装并运行

流程

  1. 使用 /groups/{group}/artifacts 操作在 registry 中添加工件版本。以下示例 curl 命令为共享价格应用程序添加一个简单的工件:

    $ curl -X POST -H "Content-Type: application/json; artifactType=AVRO" \
      -H "X-Registry-ArtifactId: my-share-price" -H "X-Registry-Version: 1.1.1" \
      -H "Authorization: Bearer $ACCESS_TOKEN" \
      --data '{"type":"record","name":" p","namespace":"com.example", \
       "fields":[{"name":"symbol","type":"string"},{"name":"price","type":"string"}]}' \
       MY-REGISTRY-URL/apis/registry/v2/groups/my-group/artifacts
    Copy to Clipboard Toggle word wrap
    • 这个示例添加了一个 Avro 模式工件 ID,其工件 ID 为 my-share-price1.1.1 版本。如果没有指定版本,Service Registry 会自动生成默认版本 1
    • MY-REGISTRY-URL 是在其上部署 Service Registry 的主机名。例如: my-cluster-service-registry-myproject.example.com
    • 本例在 API 路径中指定 my-group 的组 ID。如果没有指定唯一组 ID,则必须在 API 路径中指定 ../groups/default
  2. 验证响应是否包含预期的 JSON 正文,以确认是否已添加了自定义工件版本。例如:

    {"createdBy":"","createdOn":"2021-04-16T10:51:43+0000","modifiedBy":"",
    "modifiedOn":"2021-04-16T10:51:43+0000","id":"my-share-price","version":"1.1.1",
    "type":"AVRO","globalId":3,"state":"ENABLED","groupId":"my-group","contentId":3}
    Copy to Clipboard Toggle word wrap
    • 添加工件时,指定了 1.1.1 的自定义版本。
    • 这是添加到 registry 中的第三个构件,因此全局 ID 和内容 ID 的值为 3
  3. 使用其工件 ID 和 API 路径中的版本从 registry 检索工件内容。在本例中,指定的 ID 是 my-share-price,版本是 1.1.1

    $ curl -H "Authorization: Bearer $ACCESS_TOKEN" \
    MY-REGISTRY-URL/apis/registry/v2/groups/my-group/artifacts/my-share-price/versions/1.1.1
    {"type":"record","name":"price","namespace":"com.example",
      "fields":[{"name":"symbol","type":"string"},{"name":"price","type":"string"}]}
    Copy to Clipboard Toggle word wrap

服务 Registry 工件类型,如 Apache Avro、Protobuf 和 JSON Schema 可以包括从一个 工件文件到另一个工件文件中的工件引用。您可以通过定义可重复使用的模式和 API 工件来创建效率,然后从多个位置引用它们。

本节演示了一个简单的基于 curl 的示例,它使用了 Service Registry 核心 REST API 来添加和检索到 Service Registry 中简单 Avro 模式工件的工件引用。

这个示例首先创建一个名为 ItemId 的 schema 工件:

ItemId 模式

{
    "namespace":"com.example.common",
    "name":"ItemId",
    "type":"record",
    "fields":[
        {
            "name":"id",
            "type":"int"
        }
    ]
}
Copy to Clipboard Toggle word wrap

然后,创建名为 Item 的 schema 构件,其中包含对嵌套 ItemId 构件的引用。

项 schema 带有嵌套的 ItemId 模式

{
    "namespace":"com.example.common",
    "name":"Item",
    "type":"record",
    "fields":[
        {
            "name":"itemId",
            "type":"com.example.common.ItemId"
        },
    ]
}
Copy to Clipboard Toggle word wrap

先决条件

  • Service Registry 在您的环境中安装并运行

流程

  1. 添加您要创建嵌套工件引用的 ItemId 模式工件,以使用 /groups/{group}/artifacts 操作:

    $ curl -X POST MY-REGISTRY-URL/apis/registry/v2/groups/my-group/artifacts \
       -H "Content-Type: application/json; artifactType=AVRO" \
       -H "X-Registry-ArtifactId: ItemId" \
       -H "Authorization: Bearer $ACCESS_TOKEN" \
       --data '{"namespace": "com.example.common", "type": "record", "name": "ItemId", "fields":[{"name":"id", "type":"int"}]}'
    Copy to Clipboard Toggle word wrap
    • 这个示例添加了一个 Avro schema 工件,其工件 ID 为 ItemId。如果没有指定唯一的工件 ID,Service Registry 会自动生成一个 UUID。
    • MY-REGISTRY-URL 是在其上部署 Service Registry 的主机名。例如: my-cluster-service-registry-myproject.example.com
    • 本例在 API 路径中指定 my-group 的组 ID。如果没有指定唯一组 ID,则必须在 API 路径中指定 ../groups/default
  2. 验证响应是否包含预期的 JSON 正文,以确认工件已被添加。例如:

    {"name":"ItemId","createdBy":"","createdOn":"2022-04-14T10:50:09+0000","modifiedBy":"","modifiedOn":"2022-04-14T10:50:09+0000","id":"ItemId","version":"1","type":"AVRO","globalId":1,"state":"ENABLED","groupId":"my-group","contentId":1,"references":[]}
    Copy to Clipboard Toggle word wrap
  3. 使用 /groups/{group}/artifacts 操作添加包含对 Item Id 架构的 artifact 引用的 Item 模式工件:

    $ curl -X POST MY-REGISTRY-URL/apis/registry/v2/groups/my-group/artifacts \
    -H 'Content-Type: application/create.extended+json' \
    -H "X-Registry-ArtifactId: Item" \
    -H 'X-Registry-ArtifactType: AVRO' \
    -H "Authorization: Bearer $ACCESS_TOKEN" \
    --data-raw '{
        "content": "{\r\n \"namespace\":\"com.example.common\",\r\n  \"name\":\"Item\",\r\n  \"type\":\"record\",\r\n  \"fields\":[\r\n   {\r\n  \"name\":\"itemId\",\r\n   \"type\":\"com.example.common.ItemId\"\r\n        }\r\n    ]\r\n}",
        "references": [
            {
                "groupId": "my-group",
                "artifactId": "ItemId",
                "name": "com.example.common.ItemId",
                "version": "1"
            }
        ]
    }'
    Copy to Clipboard Toggle word wrap
    • 对于工件引用,您必须指定自定义内容类型 application/create.extended+json,这会扩展 application/json 内容类型。
  4. 验证响应是否包含预期的 JSON 正文,以确认已使用引用创建工件。例如:

    {"name":"Item","createdBy":"","createdOn":"2022-04-14T11:52:15+0000","modifiedBy":"","modifiedOn":"2022-04-14T11:52:15+0000","id":"Item","version":"1","type":"AVRO","globalId":2,"state":"ENABLED","groupId":"my-group","contentId":2,"references":[1]}
    Copy to Clipboard Toggle word wrap
  5. 通过指定包含引用的工件的工件 ID,从 Service Registry 检索工件引用。在本例中,指定的全局 ID 是 2:

    $ curl MY-REGISTRY-URL/apis/registry/v2/ids/globalIds/2/references
    Copy to Clipboard Toggle word wrap
  6. 验证响应是否包含此工件引用的预期的 JSON 正文。例如:

    [{"groupId":"my-group","artifactId":"ItemId","version":"1","name":"com.example.common.ItemId"}]
    Copy to Clipboard Toggle word wrap

作为管理员,您可以使用 Service Registry REST API 从一个 Service Registry 实例导出数据,并将它导入到另一个 Service Registry 实例,以便您可以在不同实例之间迁移数据。

本节演示了一个简单的基于 curl 的示例,它使用了核心 registry v2 REST API 以 .zip 格式从一个 Service Registry 实例导出并导入现有的 registry 数据。Service Registry 实例中包含的所有构件数据都在 .zip 文件中导出。

注意

您只能导入从另一个 Service Registry 实例导出的 Service Registry 数据。

先决条件

  • Service Registry 在您的环境中安装并运行
  • 已创建服务 Registry 实例:

    • 要从导出数据的源实例,至少包含一个 schema 或 API 工件
    • 要导入数据的目标实例为空,用于节省唯一 ID

流程

  1. 从现有的源 Service Registry 实例导出 registry 数据:

    $ curl MY-REGISTRY-URL/apis/registry/v2/admin/export \
      -H "Authorization: Bearer $ACCESS_TOKEN" \
      --output my-registry-data.zip
    Copy to Clipboard Toggle word wrap

    MY-REGISTRY-URL 是在其上部署源服务注册表的主机名。例如: my-cluster-source-registry-myproject.example.com

  2. 将 registry 数据导入到您的目标 Service Registry 实例:

    $ curl -X POST "MY-REGISTRY-URL/apis/registry/v2/admin/import" \
      -H "Content-Type: application/zip" -H "Authorization: Bearer $ACCESS_TOKEN" \
      --data-binary @my-registry-data.zip
    Copy to Clipboard Toggle word wrap

    MY-REGISTRY-URL 是部署目标 Service Registry 的主机名。例如: my-cluster-target-registry-myproject.example.com

本章介绍了如何使用 Service Registry Maven 插件管理存储在 registry 中的模式和 API 工件:

先决条件

5.1. 使用 Maven 插件添加 schema 和 API 工件

Maven 插件的最常见用例是在构建期间添加工件。使用 寄存器 执行目标可以达到此目的。

先决条件

  • Service Registry 在您的环境中安装并运行

流程

更新您的 Maven pom.xml 文件,以使用 apicurio-registry-maven-plugin 来注册工件。以下示例显示了注册 Apache Avro 和 GraphQL 模式:

<plugin>
  <groupId>io.apicurio</groupId>
  <artifactId>apicurio-registry-maven-plugin</artifactId>
  <version>${apicurio.version}</version>
  <executions>
      <execution>
        <phase>generate-sources</phase>
        <goals>
            <goal>register</goal>  
1

        </goals>
        <configuration>
            <registryUrl>MY-REGISTRY-URL/apis/registry/v2</registryUrl> 
2

            <authServerUrl>MY-AUTH-SERVER</authServerUrl>
            <clientId>MY-CLIENT-ID</clientId>
            <clientSecret>MY-CLIENT-SECRET</clientSecret> 
3

            <artifacts>
                <artifact>
                    <groupId>TestGroup</groupId> 
4

                    <artifactId>FullNameRecord</artifactId>
                    <file>${project.basedir}/src/main/resources/schemas/record.avsc</file>
                    <ifExists>FAIL</ifExists>
                </artifact>
                <artifact>
                    <groupId>TestGroup</groupId>
                    <artifactId>ExampleAPI</artifactId> 
5

                    <type>GRAPHQL</type>
                    <file>${project.basedir}/src/main/resources/apis/example.graphql</file>
                    <ifExists>RETURN_OR_UPDATE</ifExists>
                    <canonicalize>true</canonicalize>
                </artifact>
            </artifacts>
        </configuration>
    </execution>
  </executions>
 </plugin>
Copy to Clipboard Toggle word wrap
  1. 指定 register 作为将 schema 工件上传到 registry 的执行目标。
  2. 使用 ../apis/registry/v2 端点指定 Service Registry URL。
  3. 如果需要身份验证,您可以指定身份验证服务器和客户端凭证。
  4. 指定 Service Registry 工件组 ID。如果您不想使用唯一组 ID,可以指定 default 组。
  5. 您可以使用指定的组 ID、工件 ID 和位置来注册多个工件。

5.2. 使用 Maven 插件下载 schema 和 API 工件

您可以使用 Maven 插件从 Service Registry 下载工件。例如,这在从注册的 schema 生成代码时通常很有用。

先决条件

  • Service Registry 在您的环境中安装并运行

流程

更新您的 Maven pom.xml 文件,以使用 apicurio-registry-maven-plugin 下载工件。以下示例显示了下载 Apache Avro 和 GraphQL 模式。

<plugin>
  <groupId>io.apicurio</groupId>
  <artifactId>apicurio-registry-maven-plugin</artifactId>
  <version>${apicurio.version}</version>
  <executions>
    <execution>
      <phase>generate-sources</phase>
      <goals>
        <goal>download</goal> 
1

      </goals>
      <configuration>
          <registryUrl>MY-REGISTRY-URL/apis/registry/v2</registryUrl> 
2

          <authServerUrl>MY-AUTH-SERVER</authServerUrl>
          <clientId>MY-CLIENT-ID</clientId>
          <clientSecret>MY-CLIENT-SECRET</clientSecret> 
3

          <artifacts>
              <artifact>
                  <groupId>TestGroup</groupId> 
4

                  <artifactId>FullNameRecord</artifactId> 
5

                  <file>${project.build.directory}/classes/record.avsc</file>
                  <overwrite>true</overwrite>
              </artifact>
              <artifact>
                  <groupId>TestGroup</groupId>
                  <artifactId>ExampleAPI</artifactId>
                  <version>1</version>
                  <file>${project.build.directory}/classes/example.graphql</file>
                  <overwrite>true</overwrite>
              </artifact>
          </artifacts>
      </configuration>
    </execution>
  </executions>
</plugin>
Copy to Clipboard Toggle word wrap
  1. download 指定为执行目标。
  2. 使用 ../apis/registry/v2 端点指定 Service Registry URL。
  3. 如果需要身份验证,您可以指定身份验证服务器和客户端凭证。
  4. 指定 Service Registry 工件组 ID。如果您不想使用唯一组,您可以指定 default 组。
  5. 您可以使用工件 ID 将多个工件下载到指定目录中。

5.3. 使用 Service Registry Maven 插件添加工件引用

服务 Registry 工件类型,如 Apache Avro、Protobuf 和 JSON Schema 可以包括从一个 工件文件到另一个工件文件中的工件引用。您可以通过定义可重复使用的模式和 API 工件来创建效率,然后从工件引用的多个位置引用它们。

本节演示了一个简单的示例,它使用 Service Registry Maven 插件将工件引用注册到 Service Registry 中的简单 Avro schema 工件。本例假定服务 Registry 中已创建了以下 Exchange schema 工件:

Exchange schema

{
  "namespace": "com.kubetrade.schema.common",
  "type": "enum",
  "name": "Exchange",
  "symbols" : ["GEMINI"]
}
Copy to Clipboard Toggle word wrap

然后,创建一个 TradeKey 模式工件,其中包括对嵌套 Exchange schema 工件的引用:

带有嵌套交换模式的 TradeKey 模式

{
  "namespace": "com.kubetrade.schema.trade",
  "type": "record",
  "name": "TradeKey",
  "fields": [
    {
      "name": "exchange",
      "type": "com.kubetrade.schema.common.Exchange"
    },
    {
      "name": "key",
      "type": "string"
    }
  ]
}
Copy to Clipboard Toggle word wrap

先决条件

  • Service Registry 在您的环境中安装并运行
  • 在 Service Registry 中已创建了 Exchange schema 工件

流程

更新您的 Maven pom.xml 文件,以使用 apicurio-registry-maven-plugin 注册 TradeKey 模式,其中包含对 Exchange 模式的嵌套引用,如下所示:

<plugin>
    <groupId>io.apicurio</groupId>
    <artifactId>apicurio-registry-maven-plugin</artifactId>
    <version>${apicurio-registry.version}</version>
    <executions>
        <execution>
            <id>register-artifact</id>
            <goals>
                <goal>register</goal> 
1

            </goals>
            <configuration>
                <registryUrl>MY-REGISTRY-URL/apis/registry/v2</registryUrl> 
2

                <authServerUrl>MY-AUTH-SERVER</authServerUrl>
                <clientId>MY-CLIENT-ID</clientId>
                <clientSecret>MY-CLIENT-SECRET</clientSecret> 
3

                <artifacts>
                    <artifact>
                        <groupId>test-group</groupId> 
4

                        <artifactId>TradeKey</artifactId>
                        <version>2.0</version>
                        <type>AVRO</type>
                        <file>
                            ${project.basedir}/src/main/resources/schemas/TradeKey.avsc
                        </file>
                        <ifExists>RETURN_OR_UPDATE</ifExists>
                        <canonicalize>true</canonicalize>
                        <references>
                            <reference> 
5

                                <name>com.kubetrade.schema.common.Exchange</name>
                                <groupId>test-group</groupId>
                                <artifactId>Exchange</artifactId>
                                <version>2.0</version>
                                <type>AVRO</type>
                                <file>
                                    ${project.basedir}/src/main/resources/schemas/Exchange.avsc
                                </file>
                                <ifExists>RETURN_OR_UPDATE</ifExists>
                                <canonicalize>true</canonicalize>
                            </reference>
                        </references>
                    </artifact>
                </artifacts>
            </configuration>
        </execution>
    </executions>
</plugin>
Copy to Clipboard Toggle word wrap
  1. 指定 register 作为将 schema 工件上传到 registry 的执行目标。
  2. 使用 ../apis/registry/v2 端点指定 Service Registry URL。
  3. 如果需要身份验证,您可以指定身份验证服务器和客户端凭证。
  4. 指定 Service Registry 工件组 ID。如果您不想使用唯一组 ID,可以指定 default 组。
  5. 使用其组 ID、工件 ID、版本、类型和位置指定 Service Registry 工件引用。您可以以这种方式注册多个构件引用。

5.4. 使用 Maven 插件测试模式和 API 工件

您可能需要验证能否注册工件,而无需实际进行任何更改。这在 Service Registry 中配置规则时通常很有用。测试工件会导致在工件内容违反任何配置的规则时失败。

注意

当使用 Maven 插件测试工件时,即使工件通过测试,也不会将任何内容添加到 Service Registry。

先决条件

  • 必须在您的环境中安装并运行 Service Registry

流程

更新您的 Maven pom.xml 文件,以使用 apicurio-registry-maven-plugin 测试工件。以下示例显示了测试 Apache Avro 模式:

<plugin>
  <groupId>io.apicurio</groupId>
  <artifactId>apicurio-registry-maven-plugin</artifactId>
  <version>${apicurio.version}</version>
  <executions>
      <execution>
        <phase>generate-sources</phase>
        <goals>
            <goal>test-update</goal>  
1

        </goals>
        <configuration>
            <registryUrl>MY-REGISTRY-URL/apis/registry/v2</registryUrl> 
2

            <authServerUrl>MY-AUTH-SERVER</authServerUrl>
            <clientId>MY-CLIENT-ID</clientId>
            <clientSecret>MY-CLIENT-SECRET</clientSecret> 
3

            <artifacts>
                <artifact>
                    <groupId>TestGroup</groupId> 
4

                    <artifactId>FullNameRecord</artifactId>
                    <file>${project.basedir}/src/main/resources/schemas/record.avsc</file> 
5

                </artifact>
                <artifact>
                    <groupId>TestGroup</groupId>
                    <artifactId>ExampleAPI</artifactId>
                    <type>GRAPHQL</type>
                    <file>${project.basedir}/src/main/resources/apis/example.graphql</file>
                </artifact>
            </artifacts>
        </configuration>
    </execution>
  </executions>
 </plugin>
Copy to Clipboard Toggle word wrap
  1. 指定 test-update 作为测试 schema 工件的执行目的。
  2. 使用 ../apis/registry/v2 端点指定 Service Registry URL。
  3. 如果需要身份验证,您可以指定身份验证服务器和客户端凭证。
  4. 指定 Service Registry 工件组 ID。如果您不想使用唯一组,您可以指定 default 组。
  5. 您可以使用工件 ID 从指定目录中测试多个工件。

本章介绍了如何使用 Service Registry Java 客户端:

6.1. Service Registry Java 客户端

您可以使用 Java 客户端应用程序管理存储在 Service Registry 中的工件。您可以使用 Service Registry Java 客户端类创建、读取、更新或删除存储在 registry 中的工件。您还可以使用客户端执行管理员功能,如管理全局规则或导入和导出 registry 数据。

您可以通过向项目添加正确的依赖项来访问 Service Registry Java 客户端。如需了解更多详细信息,请参阅 第 6.2 节 “编写 Service Registry Java 客户端应用程序”

Service Registry 客户端使用 JDK 提供的 HTTP 客户端实现。这可让您自定义其用途,例如,添加自定义标头或启用用于传输层安全性(TLS)身份验证的选项。如需了解更多详细信息,请参阅 第 6.3 节 “Service Registry Java 客户端配置”

6.2. 编写 Service Registry Java 客户端应用程序

本节介绍如何使用 Java 客户端应用程序管理存储在 Service Registry 中的工件。

先决条件

  • Service Registry 在您的环境中安装并运行

流程

  1. 在您的 Maven 项目中添加以下依赖项:

    <dependency>
        <groupId>io.apicurio</groupId>
        <artifactId>apicurio-registry-client</artifactId>
        <version>${apicurio-registry.version}</version>
    </dependency>
    Copy to Clipboard Toggle word wrap
  2. 创建 registry 客户端,如下所示:

    public class ClientExample {
    
        private static final RegistryRestClient client;
    
         public static void main(String[] args) throws Exception {
            // Create a registry client
            String registryUrl = "https://my-registry.my-domain.com/apis/registry/v2";
            RegistryClient client = RegistryClientFactory.create(registryUrl);
        }
    }
    Copy to Clipboard Toggle word wrap
    • 如果您指定了 https://my-registry.my-domain.com 的示例 registry URL,客户端将自动附加 /apis/registry/v2
    • 有关创建 Service Registry 客户端时的更多信息,请参阅下一节中的 Java 客户端配置。

创建客户端后,您可以使用客户端中的 Service Registry REST API 中的所有操作。如需了解更多详细信息,请参阅 Apicurio Registry REST API 文档

6.3. Service Registry Java 客户端配置

Service Registry Java 客户端根据客户端因素包括以下配置选项:

Expand
表 6.1. Service Registry Java 客户端配置选项
选项描述参数

普通客户端

用于与正在运行的 registry 交互的基本 REST 客户端。

baseUrl

带有自定义配置的客户端

使用用户提供的配置,注册客户端。

baseurl,Map<String Object> 配置

带有自定义配置和身份验证的客户端

接受包含自定义配置的 map 的 registry 客户端。例如,这可用于添加自定义标头到调用。您还必须提供身份验证服务器来验证请求。

baseurl, Map<String Object> 配置, Auth auth

自定义标头配置

要配置自定义标头,您必须将 apicurio.registry.request.headers 前缀添加到 配置映射键。例如,一个带有 Basic: xxxxx 的值的 apicurio.registry.request.headers. Authorization 的键会生成一个值为 Basic: xxxxx 的标头。

TLS 配置选项

您可以使用以下属性为 Service Registry Java 客户端配置传输层安全(TLS)身份验证:

  • apicurio.registry.request.ssl.truststore.location
  • apicurio.registry.request.ssl.truststore.password
  • apicurio.registry.request.ssl.truststore.type
  • apicurio.registry.request.ssl.keystore.location
  • apicurio.registry.request.ssl.keystore.password
  • apicurio.registry.request.ssl.keystore.type
  • apicurio.registry.request.ssl.key.password

Service Registry 为 Kafka producer 和使用 Java 编写的消费者应用程序提供客户端序列化程序/反序列化器(SerDes)。Kafka producer 应用程序使用序列化器对符合特定事件 schema 的消息进行编码。Kafka 用户应用程序使用 deserializers 验证消息已使用正确的模式序列化,具体取决于特定的模式 ID。这样可确保使用一致的模式,并帮助防止运行时的数据错误。

本章论述了如何在制作者和消费者应用程序中使用 Kafka 客户端 SerDes:

先决条件

7.1. Kafka 客户端应用程序和 Service Registry

Service Registry 将架构管理与客户端应用程序配置分离。您可以通过在客户端代码中指定其 URL,启用 Java 客户端应用程序从 Service Registry 中使用 schema。

您可以将模式存储在 registry 中,以序列化和反序列化消息,这些消息可以从客户端应用程序引用,以确保它们发送和接收的消息与这些架构兼容。Kafka 客户端应用程序可以在运行时从 Service Registry 中推送或拉取其模式。

模式可以演进,因此您可以在 Service Registry 中定义规则,例如确保模式更改有效且不会影响应用程序使用的旧版本。Service Registry 通过比较修改的 schema 与之前的 schema 版本进行比较,以检查兼容性。

Service Registry 架构技术

Service Registry 为 schema 技术提供架构 registry 支持,例如:

  • Avro
  • protobuf
  • JSON 架构

客户端应用程序可通过服务 Registry 提供的 SerDes (SerDes)服务使用这些模式技术。Service Registry 提供的 SerDes 类的成熟度和使用可能有所不同。后面的部分提供了有关每种 schema 类型的更多详情。

制作者模式配置

制作者客户端应用使用序列化器将消息放入特定的代理主题到正确的数据格式。

启用制作者以使用 Service Registry 序列化:

注册模式后,当您启动 Kafka 和 Service Registry 时,您可以通过制作者访问发送到 Kafka 代理的消息的 schema。另外,根据配置,制作者可以在第一次使用时注册该架构。

如果 schema 已存在,您可以根据 Service Registry 中定义的兼容性规则,使用 registry REST API 创建一个新版本。随着架构演进,版本用于兼容性检查。组 ID、工件 ID 和版本代表标识 schema 的唯一元组。

消费者架构配置

消费者客户端应用程序使用反序列化程序将信息从特定代理主题获取正确的数据格式。

启用消费者使用 Service Registry 进行反序列化:

使用全局 ID 检索 schema

默认情况下,通过 deserializer 使用一个全局 ID 从 Service Registry 中检索 schema,该 ID 在被使用的消息中指定。模式全局 ID 可以位于消息标头中,或消息有效负载中,具体取决于制作者应用的配置。

在消息有效负载中查找全局 ID 时,数据的格式以magic 字节开头,用作消费者信号,后跟全局 ID,并以正常方式的消息数据。例如:

# ...
[MAGIC_BYTE]
[GLOBAL_ID]
[MESSAGE DATA]
Copy to Clipboard Toggle word wrap

然后,当您启动 Kafka 和 Service Registry 时,您可以访问 schema 来格式化从 Kafka 代理主题接收的消息。

使用内容 ID 检索 schema

另外,您还可以将 配置为基于内容 ID 从 Service Registry 检索 schema,这是工件内容的唯一 ID。虽然全局 ID 是工件版本的唯一 ID。

内容 ID 不唯一标识一个版本,只是唯一标识版本内容。如果多个版本共享相同的内容,则它们具有不同的全局 ID,但其内容 ID 相同。Confluent Schema Registry 默认使用内容 ID。

7.2. 在 Service Registry 中查找 schema 的策略

Kafka 客户端序列化程序使用 查找策略来 决定在 Service Registry 中注册消息 schema 的工件 ID 和全局 ID。对于给定的主题和消息,您可以使用 ArtifactReferenceResolverStrategy Java 接口的不同实现来返回对 registry 中工件的引用。

每个策略的类位于 io.apicurio.registry.serde.strategy 软件包中。Avro SerDes 的特定策略类位于 io.apicurio.registry.serde.avro.strategy 软件包中。默认策略是 TopicIdStrategy,它查找 Service Registry 工件,其名称与 Kafka 主题的信息相同。

示例

public ArtifactReference artifactReference(String topic, boolean isKey, T schema) {
        return ArtifactReference.builder()
                .groupId(null)
                .artifactId(String.format("%s-%s", topic, isKey ? "key" : "value"))
                .build();
Copy to Clipboard Toggle word wrap

  • topic 参数是接收消息的 Kafka 主题的名称。
  • 当消息键被序列化时,isKey 参数为 true,当消息值被序列化时为 false
  • schema 参数是消息序列化或反序列化的 schema。
  • 返回的 ArtifactReference 包含注册 schema 的工件 ID。

您使用的查找策略取决于您存储模式的方式和位置。例如,如果您有具有不同 Avro 消息类型的 Kafka 主题,则可能会使用 记录 ID 的策略。

工件解析器策略

工件解析器策略提供了一种将 Kafka 主题和消息信息映射到 Service Registry 中的工件的方法。映射的常见约定是将 Kafka 主题名称与 键或 合并,具体取决于 serializer 是否用于 Kafka 消息键或值。

但是,您可以使用 Service Registry 提供的策略,或创建自定义 Java 类来实现 io. apicurio.registry.registry.serde.strategy.ArtifactReferenceResolverStrategy 来使用映射。

返回对工件的引用的策略

Service Registry 提供以下策略,以根据 ArtifactReferenceResolverStrategy 的实现返回对工件的引用:

RecordIdStrategy
Avro 特定策略使用 schema 的完整名称。
TopicRecordIdStrategy
Avro 特定策略使用主题名称和 schema 的全名。
TopicIdStrategy
使用主题名称和 键或 值后缀的默认策略
SimpleTopicIdStrategy
仅使用主题名称的简单策略。
DefaultSchemaResolver 接口

默认模式解析器会查找并识别工件解析器策略提供的工件引用下注册的 schema 的特定版本。每个工件的每个版本都有一个全局唯一标识符,可用于检索该工件的内容。这个全局 ID 包括在每个 Kafka 消息中,以便 deserializer 可以正确从 Apicurio Registry 获取 schema。

默认模式解析器可以查找现有的工件版本,或者如果找不到,可以根据使用哪个策略来注册一个版本。您也可以通过创建一个实现 io.apicurio.registry.resolver.SchemaResolver 的自定义 Java 类来提供自己的策略。不过,建议您使用 DefaultSchemaResolver 并指定配置属性。

配置 registry 查找选项

使用 DefaultSchemaResolver 时,您可以使用应用程序属性配置其行为。下表显示了一些常用的示例:

Expand
表 7.1. Service Registry 查找配置选项
属性类型描述默认

apicurio.registry.find-latest

布尔值

指定序列化器是否尝试在 registry 中查找对应的组 ID 和工件 ID 的最新工件。

false

apicurio.registry.use-id

字符串

指示 serializer 将指定的 ID 写入 Kafka,并指示 deserializer 使用这个 ID 找到 schema。

apicurio.registry.auto-register

布尔值

指定序列化器是否试图在 registry 中创建工件。JSON 架构序列化器不支持它。

false

apicurio.registry.check-period-ms

字符串

指定以毫秒为单位缓存全局 ID 的时长。如果没有配置,则每次都会获取全局 ID。

7.3. 在 Service Registry 中注册 schema

在定义了适当格式的 schema(如 Apache Avro)后,您可以将 schema 添加到 Service Registry。

您可以使用以下方法添加 schema:

  • Service Registry Web 控制台
  • 使用 Service Registry REST API 的 curl 命令
  • 随 Service Registry 提供的 Maven 插件
  • 添加到客户端代码中的模式配置

在注册了模式前,客户端应用程序无法使用 Service Registry。

Service Registry Web 控制台

安装 Service Registry 时,您可以从 ui 端点连接到 web 控制台:

http://MY-REGISTRY-URL/ui

在控制台中,您可以添加、查看和配置模式。您还可以创建防止将无效内容添加到 registry 中的规则。

curl 命令示例
 curl -X POST -H "Content-type: application/json; artifactType=AVRO" \
   -H "X-Registry-ArtifactId: share-price" \ 
1

   --data '{
     "type":"record",
     "name":"price",
     "namespace":"com.example",
     "fields":[{"name":"symbol","type":"string"},
     {"name":"price","type":"string"}]}'
   https://my-cluster-my-registry-my-project.example.com/apis/registry/v2/groups/my-group/artifacts -s 
2
Copy to Clipboard Toggle word wrap
  1. 简单 Avro 模式工件。
  2. 公开 Service Registry 的 OpenShift 路由名称。
Maven 插件示例
<plugin>
  <groupId>io.apicurio</groupId>
  <artifactId>apicurio-registry-maven-plugin</artifactId>
  <version>${apicurio.version}</version>
  <executions>
      <execution>
        <phase>generate-sources</phase>
        <goals>
            <goal>register</goal>  
1

        </goals>
        <configuration>
            <registryUrl>http://REGISTRY-URL/apis/registry/v2</registryUrl> 
2

            <artifacts>
                <artifact>
                    <groupId>TestGroup</groupId> 
3

                    <artifactId>FullNameRecord</artifactId>
                    <file>${project.basedir}/src/main/resources/schemas/record.avsc</file>
                    <ifExists>FAIL</ifExists>
                </artifact>
                <artifact>
                    <groupId>TestGroup</groupId>
                    <artifactId>ExampleAPI</artifactId> 
4

                    <type>GRAPHQL</type>
                    <file>${project.basedir}/src/main/resources/apis/example.graphql</file>
                    <ifExists>RETURN_OR_UPDATE</ifExists>
                    <canonicalize>true</canonicalize>
                </artifact>
            </artifacts>
        </configuration>
    </execution>
  </executions>
 </plugin>
Copy to Clipboard Toggle word wrap
  1. 指定 register 作为将 schema 工件上传到 registry 的执行目标。
  2. 使用 ../apis/registry/v2 端点指定 Service Registry URL。
  3. 指定 Service Registry 工件组 ID。
  4. 您可以使用指定的组 ID、工件 ID 和位置来上传多个工件。
使用制作者客户端示例配置
String registryUrl_node1 = PropertiesUtil.property(clientProperties, "registry.url.node1",
    "https://my-cluster-service-registry-myproject.example.com/apis/registry/v2"); 
1

try (RegistryService service = RegistryClient.create(registryUrl_node1)) {
    String artifactId = ApplicationImpl.INPUT_TOPIC + "-value";
    try {
        service.getArtifactMetaData(artifactId); 
2

    } catch (WebApplicationException e) {
        CompletionStage <ArtifactMetaData> csa = service.createArtifact(
            "AVRO",
            artifactId,
            new ByteArrayInputStream(LogInput.SCHEMA$.toString().getBytes())
        );
        csa.toCompletableFuture().get();
    }
}
Copy to Clipboard Toggle word wrap
  1. 您可以针对多个 URL 节点注册属性。
  2. 查看该架构是否已存在基于工件 ID。

7.4. 使用 Kafka 消费者客户端的 schema

此流程描述了如何配置以 Java 编写的 Kafka 消费者客户端,以使用 Service Registry 的 schema。

先决条件

  • 已安装 Service Registry
  • 该 schema 使用 Service Registry 注册

流程

  1. 使用 Service Registry 的 URL 配置客户端。例如:

    String registryUrl = "https://registry.example.com/apis/registry/v2";
    Properties props = new Properties();
    props.putIfAbsent(SerdeConfig.REGISTRY_URL, registryUrl);
    Copy to Clipboard Toggle word wrap
  2. 使用 Service Registry deserializer 配置客户端。例如:

    // Configure Kafka settings
    props.putIfAbsent(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, SERVERS);
    props.putIfAbsent(ConsumerConfig.GROUP_ID_CONFIG, "Consumer-" + TOPIC_NAME);
    props.putIfAbsent(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "true");
    props.putIfAbsent(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, "1000");
    props.putIfAbsent(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");
    // Configure deserializer settings
    props.putIfAbsent(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG,
        AvroKafkaDeserializer.class.getName()); 
    1
    
    props.putIfAbsent(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,
        AvroKafkaDeserializer.class.getName()); 
    2
    Copy to Clipboard Toggle word wrap
    • 1. Service Registry 提供的 deserializer。
    • 2.deserialization 是 Apache Avro JSON 格式。

7.5. 使用 Kafka producer 客户端的 schema

此流程描述了如何配置使用 Java 编写的 Kafka producer 客户端,以使用 Service Registry 的 schema。

先决条件

  • 已安装 Service Registry
  • 该 schema 使用 Service Registry 注册

流程

  1. 使用 Service Registry 的 URL 配置客户端。例如:

    String registryUrl = "https://registry.example.com/apis/registry/v2";
    Properties props = new Properties();
    props.putIfAbsent(SerdeConfig.REGISTRY_URL, registryUrl);
    Copy to Clipboard Toggle word wrap
  2. 使用序列化程序和策略配置客户端,以在 Service Registry 中查找 schema。例如:

    props.put(CommonClientConfigs.BOOTSTRAP_SERVERS_CONFIG, "my-cluster-kafka-bootstrap:9092");
    props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, AvroKafkaSerializer.class.getName()); 
    1
    
    props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, AvroKafkaSerializer.class.getName()); 
    2
    
    props.put(SerdeConfig.FIND_LATEST_ARTIFACT, Boolean.TRUE); 
    3
    Copy to Clipboard Toggle word wrap
    • 1. Service Registry 提供的消息键的序列化器。
    • 2.Service Registry 提供的消息值的序列化器。
    • 3.查找策略查找架构的全局 ID。

7.6. 使用 Kafka Streams 应用程序的 schema

此流程描述了如何配置以 Java 编写的 Kafka Streams 客户端,以使用 Service Registry 的 Apache Avro 模式。

先决条件

  • 已安装 Service Registry
  • 该 schema 使用 Service Registry 注册

流程

  1. 使用 Service Registry URL 创建并配置 Java 客户端:

    String registryUrl = "https://registry.example.com/apis/registry/v2";
    
    RegistryService client = RegistryClient.cached(registryUrl);
    Copy to Clipboard Toggle word wrap
  2. 配置 serializer 和 deserializer:

    Serializer<LogInput> serializer = new AvroKafkaSerializer<LogInput>(); 
    1
    
    
    Deserializer<LogInput> deserializer = new AvroKafkaDeserializer <LogInput>(); 
    2
    
    
    Serde<LogInput> logSerde = Serdes.serdeFrom(
        serializer,
        deserializer
    );
    
    Map<String, Object> config = new HashMap<>();
    config.put(SerdeConfig.REGISTRY_URL, registryUrl);
    config.put(AvroKafkaSerdeConfig.USE_SPECIFIC_AVRO_READER, true);
    logSerde.configure(config, false); 
    3
    Copy to Clipboard Toggle word wrap
    • 1. Service Registry 提供的 Avro serializer。
    • 2.Service Registry 提供的 Avro deserializer。
    • 3.以 Avro 格式配置 Service Registry URL 和 Avro 读取器进行反序列化。
  3. 创建 Kafka Streams 客户端:

    KStream<String, LogInput> input = builder.stream(
        INPUT_TOPIC,
        Consumed.with(Serdes.String(), logSerde)
    );
    Copy to Clipboard Toggle word wrap

本章详细介绍了如何在您的制作者和消费者 Java 客户端应用程序中配置 Kafka SerD:

您可以使用本节中的示例常量在客户端应用程序中直接配置特定的客户端序列化/反序列化器(SerDe)服务和架构查找策略。另外,您还可以在文件或实例中配置对应的 Service Registry 应用程序属性。

以下小节显示了常用的 SerDe constants 和 配置选项示例。

配置 SerDe 服务
public class SerdeConfig {

   public static final String REGISTRY_URL = "apicurio.registry.url"; 
1

   public static final String ID_HANDLER = "apicurio.registry.id-handler"; 
2

   public static final String ENABLE_CONFLUENT_ID_HANDLER = "apicurio.registry.as-confluent"; 
3
Copy to Clipboard Toggle word wrap
  1. Service Registry 所需 URL。
  2. 扩展 ID 处理以支持其他 ID 格式,并使其与 Service Registry SerDe 服务兼容。例如,将默认 ID 格式从 Long 改为 Integer 支持 Confluent ID 格式。
  3. 简化 Confluent ID 的处理。如果设置为 true,则使用 Integer 用于全局 ID 查找。此设置不应与 ID_HANDLER 选项一起使用。
配置 SerDe 查找策略
public class SerdeConfig {

   public static final String ARTIFACT_RESOLVER_STRATEGY = "apicurio.registry.artifact-resolver-strategy"; 
1

   public static final String SCHEMA_RESOLVER = "apicurio.registry.schema-resolver"; 
2

...
Copy to Clipboard Toggle word wrap
  1. 实现工件解析器策略的 Java 类,并在 Kafka SerDe 和工件 ID 之间映射。默认为主题 ID 策略。这仅由 serializer 类使用。
  2. 实现 schema 解析器的 Java 类。默认为 DefaultSchemaResolver。这被 serializer 和 deserializer 类使用。
配置 Kafka converters
public class SerdeBasedConverter<S, T> extends SchemaResolverConfigurer<S, T> implements Converter, Closeable {

   public static final String REGISTRY_CONVERTER_SERIALIZER_PARAM = "apicurio.registry.converter.serializer"; 
1

   public static final String REGISTRY_CONVERTER_DESERIALIZER_PARAM = "apicurio.registry.converter.deserializer"; 
2
Copy to Clipboard Toggle word wrap
  1. 与 Service Registry Kafka converter 搭配使用所需的序列化器。
  2. 与 Service Registry Kafka converter 搭配使用所需的 deserializer。
配置不同的模式类型

有关如何为不同的模式技术配置 SerDe 的详情,请查看以下操作:

8.2. Service Registry serializer/deserializer 配置属性

本节提供有关 Service Registry Kafka serializers/deserializers(SerDes)的 Java 配置属性的参考信息。

SchemaResolver 接口

Service Registry SerDes 基于 SchemaResolver 接口,它抽象可以访问 registry,并为所有支持的格式应用相同的查找逻辑。

Expand
表 8.1. SchemaResolver 接口的配置属性
常数属性描述类型默认

SCHEMA_RESOLVER

apicurio.registry.schema-resolver

被序列化和反序列化器使用。实施 SchemaResolver 的完全限定 Java 类名称。

字符串

io.apicurio.registry.resolver.DefaultSchemaResolver

注意

建议使用 DefaultSchemaResolver,为大多数用例提供有用的功能。对于某些高级用例,您可以使用自定义实施 SchemaResolver

DefaultSchemaResolver 类

您可以使用 DefaultSchemaResolver 来配置功能,例如:

  • 访问 registry API
  • 如何在 registry 中查找工件
  • 如何从 Kafka 编写和读取工件信息
  • deserializers 的回退选项
配置 registry API 访问选项

DefaultSchemaResolver 提供了以下属性来配置对核心 registry API 的访问:

Expand
表 8.2. 用于访问 registry API 的配置属性
常数属性描述类型默认

REGISTRY_URL

apicurio.registry.url

被序列化和反序列化器使用。用于访问 registry API 的 URL。

字符串

AUTH_SERVICE_URL

apicurio.auth.service.url

被序列化和反序列化器使用。身份验证服务的 URL。在使用 OAuth 客户端凭证流访问安全 registry 时,需要此项。

字符串

AUTH_REALM

apicurio.auth.realm

被序列化和反序列化器使用。访问身份验证服务的域。在使用 OAuth 客户端凭证流访问安全 registry 时,需要此项。

字符串

AUTH_CLIENT_ID

apicurio.auth.client.id

被序列化和反序列化器使用。用于访问身份验证服务的客户端 ID。在使用 OAuth 客户端凭证流访问安全 registry 时,需要此项。

字符串

AUTH_CLIENT_SECRET

apicurio.auth.client.secret

被序列化和反序列化器使用。用于访问身份验证服务的客户端机密。在使用 OAuth 客户端凭证流访问安全 registry 时,需要此项。

字符串

AUTH_USERNAME

apicurio.auth.username

被序列化和反序列化器使用。用于访问 registry 的用户名。在使用 HTTP 基本身份验证访问安全 registry 时,需要此项。

字符串

AUTH_PASSWORD

apicurio.auth.password

被序列化和反序列化器使用。用于访问 registry 的密码。在使用 HTTP 基本身份验证访问安全 registry 时,需要此项。

字符串

配置 registry 查找选项

DefaultSchemaResolver 使用以下属性来配置如何在 Service Registry 中查找工件。

Expand
表 8.3. registry 工件查找的配置属性
常数属性描述类型默认

ARTIFACT_RESOLVER_STRATEGY

apicurio.registry.artifact-resolver-strategy

仅被序列化器使用。实现 ArtifactReferenceResolverStrategy 的完全限定 Java 类名称并将每个 Kafka 消息映射到 ArtifactReference (groupIdartifactId 和 version)。例如,默认策略使用主题名称作为 schema artifactId

字符串

io.apicurio.registry.serde.strategy.TopicIdStrategy

EXPLICIT_ARTIFACT_GROUP_ID

apicurio.registry.artifact.group-id

仅被序列化器使用。设置用于查询或创建工件的 groupId。覆盖 ArtifactResolverStrategy 返回的 groupId

字符串

EXPLICIT_ARTIFACT_ID

apicurio.registry.artifact.artifact-id

仅被序列化器使用。设置用于查询或创建工件的 artifactId。覆盖 ArtifactResolverStrategy 返回的 artifactId

字符串

EXPLICIT_ARTIFACT_VERSION

apicurio.registry.artifact.version

仅被序列化器使用。设置用于查询或创建工件的工件版本。覆盖 ArtifactResolverStrategy 返回的版本。

字符串

FIND_LATEST_ARTIFACT

apicurio.registry.find-latest

仅被序列化器使用。指定序列化器是否尝试在 registry 中查找对应的组 ID 和工件 ID 的最新工件。

布尔值

false

AUTO_REGISTER_ARTIFACT

apicurio.registry.auto-register

仅被序列化器使用。指定序列化器是否在 registry 中创建工件。JSON 架构序列化器不支持此功能。

布尔值

false

AUTO_REGISTER_ARTIFACT_IF_EXISTS

apicurio.registry.auto-register.if-exists

仅被序列化器使用。配置在创建工件冲突时客户端的行为,因为工件已存在。可用值有 FAILUPDATERETURN _OR_UPDATE

字符串

RETURN_OR_UPDATE

CHECK_PERIOD_MS

apicurio.registry.check-period-ms

被序列化和反序列化器使用。指定在自动驱除前缓存工件的时长。如果没有设置,则每次都会获取工件。

字符串

USE_ID

apicurio.registry.use-id

被序列化和反序列化器使用。配置,以使用指定的 IdOption 作为工件标识符。选项为 globalIdcontentId。指示 serializer 将指定的 ID 写入 Kafka,并指示 deserializer 使用这个 ID 查找 schema。

字符串

globalId

配置在 Kafka 中读/写 registry 工件

DefaultSchemaResolver 使用以下属性来配置如何写入工件信息并从 Kafka 读取。

Expand
表 8.4. 在 Kafka 中读/写工件信息的配置属性
常数属性描述类型默认

ENABLE_HEADERS

apicurio.registry.headers.enabled

被序列化和反序列化器使用。配置 将工件标识符改为 Kafka 消息标头,而不是在消息有效负载中。

布尔值

true

HEADERS_HANDLER

apicurio.registry.headers.handler

被序列化和反序列化器使用。实现 HeadersHandler 并将工件标识符写入/从 Kafka 消息标头的全限定 Java 类名称。

字符串

io.apicurio.registry.serde.headers.DefaultHeadersHandler

ID_HANDLER

apicurio.registry.id-handler

被序列化和反序列化器使用。实现 IdHandler 并将工件标识符写入/从消息有效负载到/读取的类的完全限定 Java 类名称。只有在将 apicurio.registry.headers.enabled 设置为 false 时才使用。

字符串

io.apicurio.registry.serde.DefaultIdHandler

ENABLE_CONFLUENT_ID_HANDLER

apicurio.registry.as-confluent

被序列化和反序列化器使用。启用 IdHandler 的传统 Confluent 兼容实施的快捷方式。只有在将 apicurio.registry.headers.enabled 设置为 false 时才使用。

布尔值

true

配置 deserializer fall-back 选项

DefaultSchemaResolver 使用以下属性为所有 deserializer 配置回退提供程序。

Expand
表 8.5. deserializer fall-back provider 的配置属性
常数属性描述类型默认

FALLBACK_ARTIFACT_PROVIDER

apicurio.registry.fallback.provider

仅对反序列化器使用。设置 FallbackArtifactProvider 的自定义实施,以解析用于反序列化的工件。FallbackArtifactProvider 配置一个回退工件,以便在查找失败时从 registry 获取。

字符串

io.apicurio.registry.serde.fallback.DefaultFallbackArtifactProvider

DefaultFallbackArtifactProvider 使用以下属性来配置 deserializer fall-back 选项:

Expand
表 8.6. deserializer fall-back 选项的配置属性
常数属性描述类型默认

FALLBACK_ARTIFACT_ID

apicurio.registry.fallback.artifact-id

仅供反序列化器使用。设置 artifactId,用作解析用于反序列化的工件。

字符串

FALLBACK_ARTIFACT_GROUP_ID

apicurio.registry.fallback.group-id

仅供反序列化器使用。设置 groupId 用作回退,以解析用于反序列化的组。

字符串

FALLBACK_ARTIFACT_VERSION

apicurio.registry.fallback.version

仅供反序列化器使用。将版本设置为回退,用于解析用于反序列化的工件。

字符串

其他资源

  • 如需了解更多详细信息,请参阅 SerdeConfig Java 类
  • 您可以将应用程序属性配置为 Java 系统属性,或者在 Quarkus application.properties 文件中包含它们。如需了解更多详细信息,请参阅 Quarkus 文档

当在 Kafka 客户端应用程序中使用 schema 时,必须根据您的用例选择要使用的特定模式类型。Service Registry 为 Apache Avro、JSON 架构和 Google Protobuf 提供 SerDe Java 类。以下小节解释了如何配置 Kafka 应用程序以使用每种类型。

您还可以使用 Kafka 来实现自定义序列化和反序列化器类,并使用 Service Registry REST Java 客户端利用 Service Registry REST Java 客户端利用 Service Registry 功能。

用于 serializers/deserializers 的 Kafka 应用程序配置

使用 Kafka 应用程序中的 Service Registry 提供的 SerDe 类涉及设置正确的配置属性。以下简单的 Avro 示例演示了如何在 Kafka producer 应用程序中配置序列化器,以及如何在 Kafka 消费者应用程序中配置反序列化器。

Kafka producer 中的序列化器配置示例

// Create the Kafka producer
private static Producer<Object, Object> createKafkaProducer() {
    Properties props = new Properties();

    // Configure standard Kafka settings
    props.putIfAbsent(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, SERVERS);
    props.putIfAbsent(ProducerConfig.CLIENT_ID_CONFIG, "Producer-" + TOPIC_NAME);
    props.putIfAbsent(ProducerConfig.ACKS_CONFIG, "all");

    // Use Service Registry-provided Kafka serializer for Avro
    props.putIfAbsent(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
    props.putIfAbsent(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, AvroKafkaSerializer.class.getName());

    // Configure the Service Registry location
    props.putIfAbsent(SerdeConfig.REGISTRY_URL, REGISTRY_URL);

    // Register the schema artifact if not found in the registry.
    props.putIfAbsent(SerdeConfig.AUTO_REGISTER_ARTIFACT, Boolean.TRUE);

    // Create the Kafka producer
    Producer<Object, Object> producer = new KafkaProducer<>(props);
    return producer;
}
Copy to Clipboard Toggle word wrap

Kafka 消费者中的 deserializer 配置示例

// Create the Kafka consumer
private static KafkaConsumer<Long, GenericRecord> createKafkaConsumer() {
    Properties props = new Properties();

    // Configure standard Kafka settings
    props.putIfAbsent(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, SERVERS);
    props.putIfAbsent(ConsumerConfig.GROUP_ID_CONFIG, "Consumer-" + TOPIC_NAME);
    props.putIfAbsent(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "true");
    props.putIfAbsent(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, "1000");
    props.putIfAbsent(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");

    // Use Service Registry-provided Kafka deserializer for Avro
    props.putIfAbsent(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
    props.putIfAbsent(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, AvroKafkaDeserializer.class.getName());

    // Configure the Service Registry location
    props.putIfAbsent(SerdeConfig.REGISTRY_URL, REGISTRY_URL);

    // No other configuration needed because the schema globalId the deserializer uses is sent
    // in the payload. The deserializer extracts the globalId and uses it to look up the schema
    // from the registry.

    // Create the Kafka consumer
    KafkaConsumer<Long, GenericRecord> consumer = new KafkaConsumer<>(props);
    return consumer;
}
Copy to Clipboard Toggle word wrap

8.3.1. 使用 Service Registry 配置 Avro SerDes

本主题解释了如何使用 Apache Avro 的 Kafka 客户端序列化器(SerDes)类。

Service Registry 为 Avro 提供以下 Kafka 客户端 SerDes 类:

  • io.apicurio.registry.serde.avro.AvroKafkaSerializer
  • io.apicurio.registry.serde.avro.AvroKafkaDeserializer

配置 Avro serializer

您可以使用以下方法配置 Avro serializer 类:

  • Service Registry URL
  • 工件解析器策略
  • ID 位置
  • ID 编码
  • Avro datum 供应商
  • Avro 编码

ID 位置

作为 Kafka 消息的一部分,序列化器会传递 schema 的唯一 ID,以便消费者使用正确的模式进行反序列化。ID 可以位于消息有效负载中,也可以在消息标头中进行。默认位置是消息有效负载。要在消息标头中发送 ID,请设置以下配置属性:

props.putIfAbsent(SerdeConfig.ENABLE_HEADERS, "true")
Copy to Clipboard Toggle word wrap

属性名称为 apicurio.registry.headers.enabled

ID 编码

您可以在 Kafka 消息正文中传递时,自定义 schema ID 的编码方式。将 apicurio.registry.id-handler 配置属性设置为实施 io.apicurio.registry.serde.IdHandler 接口的类。Service Registry 提供以下实现:

  • io.apicurio.registry.serde.DefaultIdHandler: 将 ID 存储为 8 字节长
  • io.apicurio.registry.serde.Legacy4ByteIdHandler: 将 ID 保存为 4 字节整数

Service Registry 代表 schema ID,但出于旧原因,或者出于与其它 registry 或 SerDe 类的兼容性,您可能想在发送 ID 时使用 4 字节。

Avro datum 供应商

Avro 提供不同的 datum 写入和读取数据。Service Registry 支持三种不同的类型:

  • 通用
  • 特定
  • reflect

Service Registry AvroDatumProvider 是使用其类型的抽象,其中默认使用 DefaultAvroDatumProvider

您可以设置以下配置选项:

  • apicurio.registry.avro-datum-provider: 指定 AvroDatumProvider 实施的完全限定域名,如 io.apicurio.registry.serde.avro.ReflectAvroDatumProvider
  • apicurio.registry.use- specific-avro-reader: 设置为 true,在使用 DefaultAvroDatumProvider时使用特定类型。

Avro 编码

当使用 Avro 序列化数据时,您可以使用 Avro 二进制编码格式来确保数据以高效格式编码。Avro 还支持将数据编码为 JSON,这有助于检查每条消息的有效负载,例如日志记录或调试。

您可以通过配置值为 JSONBINARYapicurio.registry.avro.encoding 属性来设置 Avro 编码。默认值为 BINARY

配置 Avro deserializer

您必须将 Avro deserializer 类配置为与 serializer 的以下配置设置匹配:

  • Service Registry URL
  • ID 编码
  • Avro datum 供应商
  • Avro 编码

有关这些配置选项,请参阅 serializer 部分。属性名称和值相同。

注意

配置 deserializer 时不需要以下选项:

  • 工件解析器策略
  • ID 位置

deserializer 类可以从消息中决定这些选项的值。策略并不是必需的,因为序列化器负责发送 ID 作为消息的一部分。

ID 位置是通过检查消息有效负载开始时的 magic 字节来确定的。如果找到该字节,则使用配置的处理程序从消息有效负载中读取 ID。如果没有找到音量字节,则 ID 会从邮件标头读取。

Avro SerDes 和 artifact 引用

在使用 Avro 消息和带有嵌套记录的模式时,会为每个嵌套记录注册一个新的工件。例如,以下 TradeKey 模式包括嵌套的 Exchange 模式:

带有嵌套交换模式的 TradeKey 模式

{
  "namespace": "com.kubetrade.schema.trade",
  "type": "record",
  "name": "TradeKey",
  "fields": [
    {
      "name": "exchange",
      "type": "com.kubetrade.schema.common.Exchange"
    },
    {
      "name": "key",
      "type": "string"
    }
  ]
}
Copy to Clipboard Toggle word wrap

Exchange schema

{
  "namespace": "com.kubetrade.schema.common",
  "type": "enum",
  "name": "Exchange",
  "symbols" : ["GEMINI"]
}
Copy to Clipboard Toggle word wrap

当将这些方案与 Avro SerDes 搭配使用时,在 Service Registry 中创建两个工件,一个用于 TradeKey 模式,另一个用于 Exchange 模式。每当使用 TradeKey 模式的消息被序列化或反序列化时,都会检索这两个模式,以便您将定义分成不同的文件中。

8.3.2. 使用 Service Registry 配置 JSON Schema SerDes

本主题解释了如何使用 Kafka 客户端序列化r 和 deserializer (SerDes)类用于 JSON Schema。

Service Registry 为 JSON Schema 提供以下 Kafka 客户端 SerDes 类:

  • io.apicurio.registry.serde.jsonschema.JsonSchemaKafkaSerializer
  • io.apicurio.registry.serde.jsonschema.JsonSchemaKafkaDeserializer

与 Apache Avro 不同,JSON 架构不是序列化技术,而是是一种验证技术。因此,JSON 架构的配置选项有所不同。例如,没有编码选项,因为数据始终被编码为 JSON。

配置 JSON 架构序列化器

您可以配置 JSON 架构序列化器类,如下所示:

  • Service Registry URL
  • 工件解析器策略
  • 模式验证

唯一的非标准配置属性是 JSON 架构验证,默认是启用的。您可以通过将 apicurio.registry.serde.validation-enabled 设置为 "false" 来禁用此功能。例如:

props.putIfAbsent(SerdeConfig.VALIDATION_ENABLED, Boolean.FALSE)
Copy to Clipboard Toggle word wrap

配置 JSON 架构反序列化器

您可以配置 JSON Schema deserializer 类,如下所示:

  • Service Registry URL
  • 模式验证
  • 用于反序列化数据的类

您必须提供 Service Registry 的位置,以便可以加载 schema。其他配置是可选的。

注意

仅当序列化器传递 Kafka 信息中的全局 ID 时,Deserializer 验证才会正常工作,这只有在被序列化器中启用验证时才会发生。

JSON Schema SerDes 和 artifact 引用

JSON Schema SerDes 无法从消息有效负载发现 schema,因此必须预先注册架构工件,这也会应用工件引用。

根据方案的内容,如果 $ref 值是 URL,则 SerDes 会尝试使用该 URL 解析引用的 schema,然后验证针对主架构的数据,并对主模式验证嵌套值。还实施了对 Service Registry 中引用工件的支持。

例如,以下 citizen.json 模式引用 city.json 模式:

公民.json 模式,并参考 city.json 模式

{
 "$id": "https://example.com/citizen.schema.json",
 "$schema": "http://json-schema.org/draft-07/schema#",
 "title": "Citizen",
 "type": "object",
 "properties": {
   "firstName": {
     "type": "string",
     "description": "The citizen's first name."
   },
   "lastName": {
     "type": "string",
     "description": "The citizen's last name."
   },
   "age": {
     "description": "Age in years which must be equal to or greater than zero.",
     "type": "integer",
     "minimum": 0
   },
   "city": {
     "$ref": "city.json"
   }
 }
}
Copy to Clipboard Toggle word wrap

City.json 模式

{
 "$id": "https://example.com/city.schema.json",
 "$schema": "http://json-schema.org/draft-07/schema#",
 "title": "City",
 "type": "object",
 "properties": {
   "name": {
     "type": "string",
     "description": "The city's name."
   },
   "zipCode": {
     "type": "integer",
     "description": "The zip code.",
     "minimum": 0
   }
 }
}
Copy to Clipboard Toggle word wrap

在本例中,给定公民具有城市。在 Service Registry 中,会使用名称 city.json 创建对城市工件的引用的公民工件。在 SerDes 中,当公民架构获取时,也会获取城市架构,因为它是从公民架构中引用的。在对数据进行序列化/反序列化数据时,使用引用名称来解决嵌套模式,从而允许针对市民和嵌套城市模式进行验证。

8.3.3. 使用 Service Registry 配置 Protobuf SerDes

本主题解释了如何在 Google Protobuf 使用 Kafka 客户端序列化r 和 deserializer (SerDes)类。

Service Registry 为 Protobuf 提供以下 Kafka 客户端 SerDes 类:

  • io.apicurio.registry.serde.protobuf.ProtobufKafkaSerializer
  • io.apicurio.registry.serde.protobuf.ProtobufKafkaDeserializer

配置 Protobuf serializer

您可以配置 Protobuf serializer 类,如下所示:

  • Service Registry URL
  • 工件解析器策略
  • ID 位置
  • ID 编码
  • 模式验证

有关这些配置选项的详情,请查看以下部分:

配置 Protobuf deserializer

您必须将 Protobuf deserializer 类配置为与 serializer 中的以下配置设置匹配:

  • Service Registry URL
  • ID 编码

配置属性名称和值与 serializer 相同。

注意

配置 deserializer 时不需要以下选项:

  • 工件解析器策略
  • ID 位置

deserializer 类可以从消息中决定这些选项的值。策略并不是必需的,因为序列化器负责发送 ID 作为消息的一部分。

ID 位置是通过检查消息有效负载开始时的 magic 字节来确定的。如果找到该字节,则使用配置的处理程序从消息有效负载中读取 ID。如果没有找到音量字节,则 ID 会从邮件标头读取。

注意

Protobuf deserializer 不会反序列化到您确切的 Protobuf Message 实现,而是改为 DynamicMessage 实例。否则,没有适当的 API 来做。

protobuf SerDes 和 artifact 引用

当使用 导入 语句的复杂 Protobuf 消息时,导入的 Protobuf 消息会作为单独的工件存储在 Service Registry 中。然后,当 Service Registry 获取主 schema 来检查 Protobuf 消息时,还会检索引用的方案,以便可以检查和序列化的完整消息模式。

例如,下表_info.proto 模式文件包含导入的 mode.proto schema 文件:

带有导入的 .mode.proto 文件的 table_info.proto 文件

syntax = "proto3";
package sample;
option java_package = "io.api.sample";
option java_multiple_files = true;

import "sample/mode.proto";

message TableInfo {

 int32 winIndex = 1;
 Mode mode = 2;
 int32 min = 3;
 int32 max = 4;
 string id = 5;
 string dataAdapter = 6;
 string schema = 7;
 string selector = 8;
 string subscription_id = 9;
}
Copy to Clipboard Toggle word wrap

mode.proto file

syntax = "proto3";
package sample;
option java_package = "io.api.sample";
option java_multiple_files = true;

enum Mode {

MODE_UNKNOWN = 0;
RAW = 1;
MERGE = 2;
DISTINCT = 3;
COMMAND = 4;
}
Copy to Clipboard Toggle word wrap

在本例中,两个 Protobuf 工件存储在 Service Registry 中,一个用于 TableInfo,另一个用于 模式。但是,由于 Mode表Info 的一部分,因此当获取 表Info 来检查 SerDes 中的消息时,模式 也会作为 表Info 引用的工件返回。

第 9 章 Service Registry 工件参考

本章详细介绍了将支持的工件类型、状态、元数据和内容规则存储在 Service Registry 中。

9.1. Service Registry 工件类型

您可以在 Service Registry 中存储和管理各种 schema 和 API 工件类型。

Expand
表 9.1. Service Registry 工件类型
类型描述

ASYNCAPI

AsyncAPI 规格

AVRO

Apache Avro 模式

GRAPHQL

GraphQL 模式

JSON

JSON 架构

KCONNECT

Apache Kafka 连接模式

OPENAPI

OpenAPI 规格

PROTOBUF

Google 协议缓冲模式

WSDL

Web 服务定义语言

XSD

XML 架构定义

9.2. Service Registry 工件状态

Service Registry 中的有效工件状态为 ENABLEDDISABLEDDEPRECATED

Expand
表 9.2. Service Registry 工件状态
状态描述

ENABLED

基本状态,所有操作都可用。

DISABLED

工件及其元数据可使用 Service Registry Web 控制台查看并可搜索,但它的内容不能被任何客户端获取。

弃用

工件完全可用,但每当获取工件内容时,会把标头添加到 REST API 响应。Service Registry Rest Client 会在它看到已弃用的内容时记录警告。

9.3. Service Registry 工件元数据

当工件添加到 Service Registry 时,一组元数据属性会与工件内容一起存储。此元数据由一组生成的只读属性组成,以及您可以设置的一些属性。

Expand
表 9.3. Service Registry 元数据属性
属性类型可编辑

id

字符串

false

type

ArtifactType

false

state

ArtifactState

true

version

整数

false

createdBy

字符串

false

createdOn

date

false

modifiedBy

字符串

false

modifiedOn

date

false

name

字符串

true

description

字符串

true

labels

字符串数组

true

属性

map

true

更新工件元数据

  • 您可以使用 Service Registry REST API 使用元数据端点更新一组可编辑的属性集合。
  • 您只能使用状态转换 API 来编辑 state 属性。例如,您可以将工件标记为 已弃用 或禁用

9.4. Service Registry 内容规则类型

您可以指定 VALIDITYCOMPATIBILITY 规则类型,以管理服务 registry 中的内容演变。

Expand
表 9.4. Service Registry 内容规则类型
类型描述

有效期

在将数据添加到 registry 前验证数据。此规则可能的配置值有:

  • FULL :验证都是语法和语义。
  • SYNTAX_ONLY: 验证仅语法。
  • NONE :禁用所有验证检查。

兼容性

确保新添加的工件与之前添加的版本兼容。此规则可能的配置值有:

  • FULL :新的工件与最近添加的工件向后兼容。
  • FULL_TRANSITIVE :新工件向前和向后兼容所有之前添加的工件。
  • BACKWARD :使用新工件的客户端可读取使用最近添加的工件写入的数据。
  • BACKWARD_TRANSITIVE :使用新工件的客户端可读取使用以前添加的工件写入的数据。
  • FORWARD :使用最近添加的工件的客户端可以读取使用新工件写入的数据。
  • FORWARD_TRANSITIVE :使用以前添加的工件的客户端可使用新工件读取写入的数据。
  • NONE :所有向后兼容性检查都已禁用。

9.5. Service Registry 内容规则成熟度

并非所有内容规则都是为 Service Registry 支持的每个工件类型完全实现的。下表显示了每个规则和工件类型的当前成熟度:

Expand
表 9.5. Service Registry 内容规则成熟度列表
工件类型有效期规则兼容性规则

Avro

full

full

protobuf

full

full

JSON 架构

full

full

OpenAPI

full

AsyncAPI

只语法

GraphQL

只语法

Kafka Connect

只语法

WSDL

只语法

XSD

只语法

9.6. Service Registry 内容规则优先级

添加或更新工件时,Service Registry 会应用规则来检查工件内容的有效性和兼容性。配置的工件规则覆盖与配置相同的全局规则,如下表中所示。

Expand
表 9.6. Service Registry 内容规则优先级
工件规则全局规则应用到此工件的规则可用于其他工件的全局规则?

Enabled

Enabled

工件

Disabled

Enabled

全局

Disabled

Disabled

启用,设置为 None

Enabled

Disabled

启用,设置为 None

附录 A. 使用您的订阅

Service Registry 通过软件订阅提供。要管理您的订阅,请访问红帽客户门户中的帐户。

访问您的帐户

  1. 转至 access.redhat.com
  2. 如果您还没有帐户,请创建一个帐户。
  3. 登录到您的帐户。

激活订阅

  1. 转至 access.redhat.com
  2. 导航到 My Subscriptions
  3. 导航到 激活订阅 并输入您的 16 位激活号。

下载 ZIP 和 TAR 文件

要访问 ZIP 或 TAR 文件,请使用客户门户网站查找要下载的相关文件。如果您使用 RPM 软件包,则不需要这一步。

  1. 打开浏览器并登录红帽客户门户网站 产品下载页面,网址为 access.redhat.com/downloads
  2. 在 Integration 和 Automation 类别中找到 Red Hat Integration 条目。
  3. 选择所需的 Service Registry 产品。此时会打开 Software Downloads 页面。
  4. 单击组件的 Download 链接。

为系统注册软件包

要在 Red Hat Enterprise Linux 中安装 RPM 软件包,必须注册您的系统。如果使用 ZIP 或 TAR 文件,则不需要这一步。

  1. 转至 access.redhat.com
  2. 进入 Registration Assistant
  3. 选择您的操作系统版本,再继续到下一页。
  4. 使用您的系统终端中列出的命令完成注册。

如需了解更多信息 ,请参阅如何在红帽客户门户网站中注册和订阅系统

返回顶部
Red Hat logoGithubredditYoutubeTwitter

学习

尝试、购买和销售

社区

关于红帽文档

通过我们的产品和服务,以及可以信赖的内容,帮助红帽用户创新并实现他们的目标。 了解我们当前的更新.

让开源更具包容性

红帽致力于替换我们的代码、文档和 Web 属性中存在问题的语言。欲了解更多详情,请参阅红帽博客.

關於紅帽

我们提供强化的解决方案,使企业能够更轻松地跨平台和环境(从核心数据中心到网络边缘)工作。

Theme

© 2025 Red Hat