Manage Schemas in Confluent Cloud
Confluent Cloud provides a fully managed Schema Registry in each environment for defining, evolving, and validating the schemas that structure your Apache Kafka® topic data. Schema Registry is a key element of data governance.
Tip
Sign up or sign in to Confluent Cloud to try the guided workflows in the embedded interactive tutorials.
Work with schemas
A schema defines the structure of the data.
A subject is the scope in which schemas evolve. Schema Registry groups schemas under subjects. The name of the subject depends on the configured subject name strategy, which, by default, derives the subject name from the topic name. The Kafka topic name can be independent of the schema name.
A schema can include more than its structure, such as data quality rules, metadata, and tags. You can manage schemas and these additional elements for topics in Confluent Cloud.
To manage schemas with Terraform, use the confluent_schema resource.
To enable Schema Registry and try the basic workflows first, see Quick Start for Schema Management on Confluent Cloud. These topics assume that you enabled Schema Registry:
Note
Only single-zone Dedicated Kafka clusters are available in Jio Cloud regions. Stream Governance packages purchased in Jio Cloud regions support a maximum SLA of 99.95%. For more information, see Jio Cloud region availability.
View a schema
View the schema details for a specific topic.
Search for schemas
To find a schema, search for it. Search is global and spans environments and clusters.
In the search bar, type the name of a schema subject, data record, or data field.
Results appear as you type and include other entities, such as topics.
Press Enter to select an entity, such as a schema.
To learn more, see Search entities and tags.
View schemas for Confluent Platform with USM
To view schemas for a Confluent Platform cluster with USM, first register the cluster. A schema, optionally extended with rules, defines the structure of data published to a topic and ensures data quality and compatibility. To view the schema for a Confluent Platform topic:
In the Confluent Cloud Console, go to the Environments page and select your Confluent Platform environment.
From the Clusters page, select your cluster.
In the navigation menu, click Topics, and then select a topic.
Click the Schema tab to view its details.
If the tab is empty, click Create schema to add one. For instructions, see Create a schema.
To view schemas for all topics in the environment, go to Schema Registry and click the Schemas tab. Click a schema in the list to view its details.
If you use schema contexts to manage Confluent Platform schemas, select the schema context for your Confluent Platform Schema Registry when you add a new subject.
List all schemas from the environment view
Go to the environment you want to work with and select it as the current environment.
Click Schema Registry on the navigation menu, and then click the Schemas tab to list all schemas in the environment.
Browse the list to find the schema you want to view.
Click a schema in the list to view it.
By default, the schema appears in raw view. To learn more, see Switch between tree view and raw view.
Switch between tree view and raw view
By default, schemas open in raw view, an editable view like a code editor. In raw view, you can create and edit schemas as described in Create a schema and Edit schemas. Tree view shows the schema as an expandable hierarchy.
To switch views, click the buttons next to the schema-level search box:
In tree view, you can:
Understand the structure of the schema and navigate its elements and sub-elements.
Click the arrow next to an element to expand its sub-elements.
Apply and manage tags. For more information, see Tag entities, data, and schemas.
Create a schema
You can create schemas for keys and values associated with a topic. Value schemas are typically created more frequently than key schemas. A schema enforces and evolves structured data in your Kafka topics, and associates a topic with rules, metadata, and other parameters that further describe and structure the data.
Best practices:
Provide default values for fields to facilitate backward-compatibility if pertinent to your schema.
Document at least the more obscure fields for human-readability of a schema.
Tip
You can also create schemas with the Confluent CLI. For steps, see Create a schema in the Quick Start. For all commands, see the Confluent CLI command reference.
Create a schema associated with a topic value
From the navigation menu in a cluster, click Topics, and then click a topic to select it (or create a new one).
Click the Schema tab.
Click Add a schema. The Schema editor appears.
Select a schema type from the drop-down menu under the schema: JSON, Avro, or Protobuf. Avro is the default.
The basic structure of a schema appears prepopulated in the editor as a starting point. Enter the schema in the editor:
name: Enter a name for the schema if you do not want to accept the default, which is determined by the subject name strategy. The default isschema_type_topic_name. Required.type: Eitherrecord,enum,union,array,map, orfixed. (The typerecordis specified at the schema’s top level and can include multiple fields of different data types.) Required.namespace: Fully-qualified name to prevent schema naming conflicts. String that qualifies the schemaname. Optional but recommended.fields: JSON array listing one or more fields for a record. Required.Each field can have the following attributes:
name: Name of the field. Required.type: Data type for the field. Required.doc: Field metadata. Optional but recommended.default: Default value for a field. Optional but recommended.order: Sorting order for a field. Valid values are ascending, descending, or ignore. Default: Ascending. Optional.aliases: Alternative names for a field. Optional.
For example, add the following schema:
{ "type": "record", "name": "value_my_new_widget", "fields": [ { "name": "name", "type": "string" } ] }
The schema appears in the schema editor in Confluent Cloud.
In edit mode, you have options to:
Validate the schema for syntax and structure before you create it.
Add schema references with a guided wizard.
Click Create.
If the schema is valid, Confluent Cloud saves it and briefly shows a Schema updated message in the banner area. The schema appears in raw view.
To switch to tree view, click Tree view.
If the schema is invalid, the editor highlights parse errors, such as a missing curly bracket. If the editor doesn’t highlight parse errors, click See error messages on the warning banner.
If applicable, repeat the procedure for the topic key schema.
Work with schema references
A schema reference lets one schema use another schema as a type. To add a reference to another schema, use the wizard to locate available schemas and versions.
The Reference name you provide must match the target schema, based on guidelines for the schema format you are using:
In JSON Schema, the name is the value of the
$reffield of the referenced schema.In Avro, the name is the full name of the referenced schema, which is the value of its
namefield.In Protobuf, the name is the value of the
importstatement for the referenced schema.
The reference name combines the record namespace and name. For example, the
reference name for the Employee record in the Example namespace is
Example.Employee.
Note
In JSON Schema, a schema refers to another schema with the $ref
keyword, followed by a URL or address for the referenced schema:
{ "$ref": "<referenced_schema_url>" }
$ref must reference only internally mapped URLs. The URL must match the
name of another schema reference. External references aren’t supported. To
learn more, see Schema references in JSON Schema.
Add a schema reference
To add a reference to the widget-value schema, go to the widget topic,
click the Schema tab, and then follow these steps:
If you haven’t already, click Evolve.
Click Add references.
Enter a Reference name that follows the rules for your schema format.
From the Subject list, select the schema.
From the Version list, select the schema version to use.
Click Validate to check that the reference is valid.
Click Save to save the reference.
For example, to reference the employees-value schema from the widget
schema, configure a reference to Example.Employee. You configure the
reference on the widget topic, and it points to the employees topic.
The reference to employees-value uses these values:
Reference name:
Example.Employee, the fully qualified name of the referenced schema.Subject:
employees-value, the subject of the referenced schema.Version: The version of the referenced schema to use.
To learn more, see Schema references. To list the schemas that reference a schema with the API, see List schemas referencing a schema.
View, edit, or delete schema references
Existing schema references appear on editable versions of the schema where they’re configured.
Go to a topic in a cluster. For example, go to the
widgettopic, which uses thewidget-valueschema from the previous example.Click the Schema tab.
Click References, and then click Evolve.
The Schema references list shows the references that this schema has to other schemas.
To change a schema reference, click the ellipsis icon next to it, and then select Edit or Delete.
To add more schema references, click Add references and follow the steps in Add a schema reference.
Create a schema associated with a topic key
Click the Key option. You’re prompted to set a message key schema.
Click Add a schema.
Choose Avro format, or delete the sample formatting and paste in a string UUID.
Enter the schema into the editor and click Save.
The following schema is an example for a key:
{ "namespace": "io.confluent.examples.clients.basicavro", "name": "key_widget", "type": "string" }
Best practices and pitfalls for key values
Keep key schemas simple. Use one of these key types:
A simple, non-serialized data type, such as a string UUID or long ID.
An Avro
recordthat doesn’t use maps or arrays as fields.
Don’t use Protobuf messages or JSON objects for keys. Avro doesn’t guarantee deterministic serialization for maps or arrays, and the Protobuf and JSON Schema formats don’t guarantee it for any object. Using these formats for keys breaks topic partitioning. To learn more, see Partitioning gotchas in the Confluent Community Forum.
Kafka messages are key-value pairs, and you can serialize the key and value
independently. For example, the value can be an
Avro
record while the key is a primitive, such as string or integer.
Typically, message keys are primitives. How you set the key depends on the
requirements of your implementation.
For detailed examples of key and value schemas, see Formats, Serializers, and Deserializers in the Schema Registry documentation.
Infer a schema from messages
As an alternative to creating a schema by hand, you can infer a schema from a set of messages. Confluent Cloud can infer a schema from JSON messages in a topic or from a single message payload. An inferred schema saves development time and lets you process the data with Flink SQL on Apache Flink® and with Tableflow. Topics that started without a schema can then join a governed data streaming architecture.
The feature supports two workflows:
Generate a new schema: For a new data pipeline or application, create an Avro, Protobuf, or JSON Schema from one representative JSON message.
Infer a schema for an existing topic: For an existing topic that has schemaless JSON data, create an Avro, Protobuf, or JSON Schema from at least one and up to 10 messages in the topic.
The feature is available on all Confluent Cloud deployments. The following table compares the two inference methods:
Method |
Primary use case |
Input |
Supported output formats |
Key considerations |
|---|---|---|---|---|
Infer new schema |
Creating a schema from scratch for a new topic or application. |
A single, representative JSON message. |
Avro, Protobuf, JSON Schema |
Provides a starting point, but its quality depends on the single sample. |
Infer for an existing topic |
Applying a schema to a topic that already contains schemaless JSON data. |
At least one and up to 10 messages in the topic’s value. |
Avro, Protobuf, JSON Schema |
Automates support for features such as Flink. The schema is a union of all structures found and might need refinement. |
Prerequisites
Access permissions: You need role-based access control (RBAC) permissions to create schemas in the Schema Registry for the environment. To infer a schema for an existing topic, you also need permission to view messages in that topic.
Data availability: For the existing topic workflow, the topic must contain valid JSON messages. The inference process reads from the end of the topic log. At least one and up to 10 messages must be in the topic for the sample.
Limitations
Inference source for existing topics: Inference for an existing topic analyzes only the message value and ignores the message key.
Sampling size for existing topics: Inference for an existing topic samples at least one and up to 10 messages and doesn’t scan the entire topic history. The small sample keeps the UI fast, but the inferred schema might miss structural variations in older data.
Data validity: The tool assumes that the sampled messages are well-formed JSON. Malformed, truncated, or non-JSON data in the sample can cause inference to fail or produce an incorrect schema.
Tutorial: Infer a new schema from a sample message
This tutorial shows you how to create a new Avro, Protobuf, or JSON Schema from a single sample JSON message. Use this method to define a schema before a topic is actively used.
From the Cloud Console, go to the environment you want.
From the navigation menu, select Schema Registry.
Go to the Schemas tab and click Add a schema.
In the Create schema view, click Infer schema from a sample JSON message.
In the JSON message panel, paste a single, representative JSON message. For the most accurate and complete schema, include all possible fields in the sample, including optional fields, nested objects, and arrays.
The following sample message includes optional fields, nested objects, and arrays:
{
"orderId": "ord-12345",
"customerId": "cust-67890",
"orderTimestamp": "2023-10-27T10:00:00Z",
"totalAmount": 150.75,
"isExpedited": true,
"shippingAddress": {
"street": "123 Confluent Lane",
"city": "Palo Alto",
"state": "CA",
"zipCode": "94301"
},
"items": [
{
"productId": "prod-a",
"quantity": 2,
"unitPrice": 50.00
},
{
"productId": "prod-b",
"quantity": 1,
"unitPrice": 50.75
}
],
"promoCode": null
}
After you paste the message, select the schema type from Schema Type, and then click Infer schema. Review the result, and then click Import schema to add it to the Create schema view.
Tutorial: Infer a schema for an existing topic
This tutorial describes how to generate a schema for an existing topic that contains schemaless JSON data and register the schema with the topic.
Infer a schema for a topic
From the Cloud Console, go to the environment you want.
From the navigation menu, select Topics.
Click the topic that contains schemaless JSON data.
Click the Schema tab.
If the topic value has no schema, the tab shows a message that says so.
From the Schema format menu, select Avro, Protobuf, or JSON Schema.
Click Infer a schema from messages.
The editor shows the inferred schema.
Review the inferred schema. The schema is a starting point and might need manual edits. For guidance, see Review and edit an inferred schema.
Enter a subject name for the schema, such as
<topic_name>-value.Click Import schema to register the schema with the topic.
To generate sample data and test schema inference, follow these steps.
Generate sample schemaless messages as raw JSON
This example uses an existing schemaless topic named users. If you don’t
have one, create it without a schema.
In the Cloud Console, click Connectors.
Click Add Connector, and then search for
Datagen.Select the Datagen Source connector (Sample Data), and then select Advanced Configuration in the dialog.
In the Topic selection dialog, select the
userstopic and click Continue.In the Kafka credentials dialog, select a credentials option such as My account, and then click Continue. Use My account for testing only, not for production.
In the Configuration dialog, select Provide your own schema. Enter an Avro schema that defines the structure of the JSON messages to generate. For example:
{ "type": "record", "name": "UserEvent", "fields": [ { "name": "user_id", "type": "string" }, { "name": "timestamp", "type": "long" } ] }
Click Show advanced configurations. Verify that
value.converter.schemas.enableisfalse.With this setting, the connector sends raw JSON messages without schema metadata. The topic has no schema for these messages.
Click Continue.
In the Sizing and Review and launch dialogs, accept the defaults. Optional: Rename the connector.
Click Continue to create the connector and start generating sample messages.
View the messages and attempt to query with Flink SQL
Go to the
userstopic to view its messages.The connector produces these messages as raw JSON.
Try to process the messages with Flink. Select Query with Flink, and then click Run.
Flink shows the messages in raw byte format, even though they’re JSON. Flink can’t process data that has no associated schema.
Infer a schema from the messages
On the Messages tab for the topic, find the banner for topics that have messages but no schema. Click Infer schema from messages to derive a schema that matches at least one and up to 10 messages produced to the topic.
Click Import schema.
The fields in the schema match the names and types of the fields in the JSON messages. You can validate and edit the schema before you register it. To learn more, see Review and edit an inferred schema.
When you’re satisfied with the schema, click Create.
Confluent Cloud creates the schema and registers it with the topic by using the TopicNameStrategy.
Click View messages.
The messages now appear in a readable format.
Query the message stream with Flink
Now that the topic has a schema, process the data with Flink again.
Review and edit an inferred schema
Schema inference produces a first draft that captures the structure of the sample data. Review and refine the inferred schema before you use it in production.
Consider the following common refinements after generating a schema:
Improve data type specificity: The inference engine might identify a numeric field as a generic number. Refine the field to a more specific type, such as integer, long, float, or double, based on the data.
Add documentation: The inferred schema has no comments or descriptions. As a best practice, add
docfields in Avro ordescriptionfields in JSON Schema to explain the business purpose of each field.Enforce constraints: To tighten data quality, add validation constraints. For example, use a pattern for strings that must match a specific format, such as a UUID, or set minimum and maximum values for numeric fields.
Define default values: For fields inferred as optional, consider a sensible default value. A default value prevents null pointer exceptions in consuming applications.
Review nullable fields: The inference process marks a field as optional, or nullable, if any sampled message lacks the field. Review these decisions. Should the field be optional, or was its absence in the sample an anomaly? Making a field required when appropriate is a key part of defining a well-specified schema.
How schema inference works
The inference logic explains the output and helps you troubleshoot issues. Schema inference differs slightly between the two workflows.
Single-message inference for a new schema
To generate a schema from a single sample JSON message, the engine performs a recursive traversal of the JSON object tree. It maps the JSON data types to their equivalents in the selected target schema format: Avro, Protobuf, or JSON Schema.
A JSON string becomes a schema string.
A JSON number becomes a schema number, which you can refine.
A JSON boolean becomes a schema boolean.
A JSON object becomes a nested record in Avro or a message in Protobuf.
A JSON array becomes a schema array. The engine sets the element type from the first element of the array in the sample.
Multi-message inference for an existing topic
Inferring a schema from messages in a topic is more complex, because the engine must reconcile potentially different structures into a single, valid schema. The engine uses at least one and up to 10 messages to infer a schema.
Field merging: The engine inspects all sampled messages and constructs a composite schema that includes any field present in at least one of the messages. Fields that appear in only some messages stay in the schema.
Type conflict resolution: If a field has different data types across the sampled messages, such as
{"id": 123}in one and{"id": "id-123"}in another, the engine resolves the conflict by creating a union type. In JSON Schema, the result is{"type": ["number", "string"]}. The union type makes the schema more permissive to accommodate the variations.Optional fields: If a field is present in some sampled messages but absent in others, the engine defines it as an optional field in the final schema. In JSON Schema, the engine typically adds
nullto the type definition of the field, such as{"type": ["string", "null"]}.
Automated inference explains why the resulting schema can be more permissive than a hand-authored schema and why a manual review is a required final step.
Data type mapping used for schema inference
The following table maps each input type to the Avro, JSON Schema, and Protobuf types that schema inference produces:
Actual input |
Avro data type |
JSON Schema data type |
Protobuf data type |
|---|---|---|---|
Long |
|
|
|
Short/integer |
|
|
|
Null |
|
|
|
BigInteger/BigDecimal |
|
|
|
Float/Double |
|
|
|
Boolean |
|
|
|
String |
|
|
|
Troubleshooting
Use these solutions for common schema inference problems.
The inferred schema is missing an expected field
Possible cause: The field wasn’t in the single sample message for the new schema workflow, or wasn’t in any of the messages sampled from the topic for the existing topic workflow.
Solution: For new schemas, make sure the sample JSON is comprehensive and includes all necessary fields. For existing topics, produce a new message that contains the missing field to the topic, and then run the inference process again. You can also edit the generated schema to add the missing field.
The inferred schema has an overly permissive data type
Possible cause: The inference engine detected inconsistent data types for the same field across the sample. For example, if
userIDis a number in some messages and a string in others, the engine infers a union type of["number", "string"].Solution: An inconsistent data type points to a data quality issue in a producer application. As an immediate fix, edit the inferred schema to enforce the single, correct data type. As a long-term fix, update the upstream producer application so that it consistently produces data with the correct type.
Edit schemas
Edit an existing schema for a topic.
From the navigation menu, click Topics, and then click a topic to select it.
Click the Schema tab.
Select the Key or Value option for the schema.
The schema opens in raw view.
Click Evolve.
Make the changes in the schema editor.
To add a
regionfield, edit the schema as follows:{ "fields": [ { "name": "name", "type": "string" }, { "name": "region", "type": "string", "default": "" } ], "name": "value_widgets", "type": "record" }
In edit mode, you have options to:
Validate the schema for syntax and structure before you save it.
Note
When the compatibility mode is Backward Compatibility, give the new field a default value. With a default value, consumer applications can read older messages written with version 1 of the schema, which has only a
namefield, and new messages written with version 2, which hasnameandregionfields. For version 1 messages,regionis empty. To learn more, see Passing compatibility checks in Confluent Cloud Schema Registry Tutorial.Click Save.
If the update is valid and compatible with earlier versions, Confluent Cloud updates the schema and increments the version count. You can compare versions of a schema.
If the update is invalid or incompatible with an earlier version, the editor highlights parse errors. If the editor doesn’t highlight them, click See error messages on the warning banner.
For example, if you add a field without a default value, the update fails with an incompatibility error. To fix the error, add a default value for
region.
Compare schema versions
Compare versions of a schema to view its evolutionary differences.
From the navigation menu, click Topics, and then click a topic to select it.
Click the Schema tab.
Select the Key or Value option for the schema. Value is the default.
Click the ellipsis icon, and then select Compare versions.
The version menu shows the current version number of the schema.
Select the Turn on version diff checkbox.
Select the versions to compare from each version menu.
Confluent Cloud highlights the differences.
Change the compatibility mode for a subject
The default compatibility mode is Backward. The mode can be changed for the schema of any topic if necessary.
Caution
If you change the compatibility mode of an existing schema already in production use, be aware of any possible breaking changes to your applications.
Use these steps to change the compatibility mode for a single subject. To set compatibility for all schemas in an environment, see View and edit global compatibility settings on schemas. Subject-level compatibility settings override environment-level settings.
To manage subject-level compatibility with Terraform, use the confluent_subject_config resource.
Select an environment.
Select a cluster.
From the navigation menu, click Topics, and then click a topic to select it.
Click the Schema tab for the topic.
Select the Key or Value option for the schema.
Click the edit icon (
) next to Compatibility mode.The Compatibility settings pane appears.
Select a mode option:
Descriptions indicate the compatibility behavior for each option. For more information, including the changes allowed for each option, see Schema Evolution and Compatibility.
Click Save.
Search for schemas and fields
Global search finds schemas, fields, and related metadata across environments and clusters. For more information, see Search entities and tags in Stream Catalog.
Tag schemas and fields
Tag schema versions and fields to organize and catalog data with custom and commonly used tag names. For more information, see Tag entities, data, and schemas in Stream Catalog.
Work with schema contexts
A schema context groups subject names and schema IDs. With contexts, you can create any number of separate subregistries in one Schema Registry. Contexts add flexibility to subject naming, schema IDs, and how clients reference schemas.
Specify schema contexts
Schemas live in the default context unless you give them a qualified name. Qualified names group schemas into subregistries with context-specific paths. Schema Linking uses schema contexts extensively, but you can also use them independently.
Why use schema contexts?
You can logically group schemas by specifying schema contexts. By default, schemas live in the default context. When you give schemas qualified names, you group them into subregistries with context-specific paths. Schemas with the same subject names and IDs can then exist as unique entities in their different contexts. One advantage of contexts is that you can provide specific contexts for different clients. Schema contexts are typically used in Schema Linking, where they provide mechanisms and flexibility for sharing schemas across registries.
Default context
Any schema ID or subject name without an explicit context lives in the
default context, which is a single dot ..
Compatibility applies per context, not across all contexts. To learn more, see Schema Evolution and Compatibility for Schema Registry on Confluent Cloud.
All APIs that specify an unqualified subject operate in the default context.
To pass a context, use a qualified subject wherever a subject name is
expected, or use a base context path. A base context path takes the form
/contexts/{context} and can be prepended to any existing Schema Registry path. For
example, to look up a schema ID in a specific context, use the URL
/contexts/.mycontext/schemas/ids/{id}.
A base context path can also operate on the default context. In this case,
the base context path takes the form /contexts/:.:/, as in
/contexts/:.:/schemas/ids/{id}. You can’t use a single dot, because some
URL parsers omit it.
The following curl command registers a schema in the .TestContext
context:
curl -u <api_key>:<api_secret> \
-X POST -H "Content-Type: application/json" \
--url "<schema_registry_endpoint>/contexts/.TestContext/subjects/aContext2-value/versions" \
--data '{"schemaType": "AVRO", "schema":"{\"type\":\"record\",\"name\":\"test\",\"fields\":[{\"name\":\"field1\",\"type\":\"string\"},{\"name\":\"field2\",\"type\":\"int\"}]}"}'
To learn more about schema contexts, see Contexts in Schema Linking. The Schema Linking Quick Start includes examples of subjects in the default context, or unqualified subjects, and in named contexts, or qualified subjects.
Filter schema subjects by context
To filter subjects by context, use the context filter on the subject list page. With contexts, you can also create a subject under an existing or new context and browse messages for a subject under a specific context.
Download a schema from Confluent Cloud
From the navigation menu, click Topics, and then click a topic to select it.
Click the Schema tab.
Select the Key or Value option for the schema.
Click the ellipsis icon, and then select Download.
Confluent Cloud downloads a schema JSON file for the topic into your Downloads directory.
For example, the version 1 schema for the employees topic from the Quick Start downloads as
schema-employees-value-v1.avscwith these contents:{ "fields": [ { "name": "Name", "type": "string" }, { "name": "Age", "type": "int" } ], "name": "Employee", "namespace": "Example", "type": "record" }
Tip
The file extension indicates the schema format:
.avsc for Avro, .proto for Protobuf, and .json for JSON
Schema.
Delete a schema from Confluent Cloud
To delete a schema version or a whole subject, use the Schema tab for the topic in the Confluent Cloud Console.
From the navigation menu, click Topics, and then click a topic to select it.
Click the Schema tab.
Select the Key or Value option for the schema.
Click the ellipsis icon, and then select Delete.
On the dialog, select whether to delete only a particular version of the schema or the entire subject (all versions).
Select Delete to carry out the action.
To learn about hard and soft deletes, schema limits, and how to free up space for more schemas, see Delete Schemas and Manage Storage Space on Confluent Cloud.
Manage schemas for a Confluent Cloud environment
Schema Registry runs at the environment level and serves all clusters in the environment. You manage several schema tasks through the registry at this level.
To view and manage Schema Registry for a Confluent Cloud environment:
From the Home page, select an environment.
Click the Schema Registry tab.
To learn about Stream Governance package options, see Add a cloud environment and Manage Stream Governance Packages in Confluent Cloud.
To learn how to do the following tasks, see Configure and manage schemas for an environment:
Access control (RBAC) for Confluent Cloud Schema Registry
Role-based access control (RBAC) lets administrators set up and manage user access to Schema Registry subjects and topics. With RBAC, multiple users can collaborate with different levels of access to resources. For a comparison of API key, RBAC, and OAuth support, see Secure Confluent Cloud Schema Registry and Stream Catalog.
The following table describes how RBAC roles map to Schema Registry resources. To manage RBAC for these resources, see List the role bindings for a principal, Predefined RBAC Roles in Confluent Cloud, and List the role bindings for a principal. For related RBAC information, see Access control (RBAC) for Stream Lineage and Role-based access control (RBAC) for Schema Linking.
Role |
Scope |
Read subject |
Write subject |
Delete subject |
Read subject compatibility |
Write subject compatibility |
Grant permissions |
|---|---|---|---|---|---|---|---|
Organization |
Yes |
Yes |
Yes |
Yes |
Yes |
Yes |
|
Environment |
Yes |
Yes |
Yes |
Yes |
Yes |
Yes |
|
Cluster |
No |
No |
No |
No |
No |
No |
|
Organization, Environment, Cluster |
No |
No |
No |
No |
No |
No |
|
Organization, Environment, Cluster |
No |
No |
No |
No |
No |
No |
|
Schema Subject |
Yes |
Yes |
Yes |
Yes |
Yes |
Yes |
|
Schema Subject |
No |
No |
No |
Yes |
Yes |
No |
|
Schema Subject |
Yes |
No |
No |
Yes |
No |
No |
|
Schema Subject |
Yes |
Yes |
No |
Yes |
No |
No |
|
Organization, Environment |
Yes |
No |
No |
Yes |
No |
No |
|
Organization, Environment |
Yes |
Yes |
Yes |
Yes |
Yes |
No |
Note
Global compatibility doesn’t apply to roles. To grant permission to
manage global compatibility, grant the DeveloperManage role on a
subject resource named __GLOBAL.
For new user and service accounts, configure access explicitly, as shown in the preceding table.
Supported features and limits for Confluent Cloud Schema Registry
A single Schema Registry is available per environment.
Authenticate to Schema Registry with an API key or OAuth, and authorize access with RBAC. For details, see Secure Confluent Cloud Schema Registry and Stream Catalog.
Your VPC must be able to communicate with the Confluent Cloud Schema Registry public internet endpoint. For more information, see Use Confluent Cloud Schema Registry to Connect to a Public Endpoint in a Private Networking Environment.
Schema Registry is available on Amazon Web Services (AWS), Microsoft Azure, and Google Cloud in the US, Europe, and Asia-Pacific (APAC) geographies. For each cloud provider, geographies map to specific regions, as described in Add a cloud environment.
High availability (HA): Each cluster always runs multiple nodes, and each node runs in a different availability zone (AZ).
Tag and business metadata definition names can have up to 8,192 characters each. To learn more, see Tag entities, data, and schemas.
Each environment allows up to 1,000 tag definitions (
TagDef). To learn more, see Tag entities, data, and schemas.Each schema can be up to 1 MB in Confluent Cloud. To stay under this limit, use schema references to spread fields and data specifications across multiple schemas.
Confluent Cloud Schema Registry limits the number of schema versions in the registry for Basic, Standard, and Dedicated clusters, as described in Kafka Cluster Types in Confluent Cloud. To view per-package schema limits, see Manage Stream Governance Packages in Confluent Cloud. To free up space, identify and delete unused schemas.
Rate limits: Schema Registry allows 75 read requests per second and 25 write requests per second across all API keys for one Schema Registry logical cluster ID (LSRC). Schema Registry identifies each request by its API key, which points to a tenant, or LSRC. Requests from different API keys for the same tenant count toward the same limits, no matter how many API keys you create. To learn more about multi-tenancy on Confluent Cloud, see Multi-Tenancy and Client Quotas on Confluent Cloud. To view the Confluent Cloud metrics for Schema Registry, see the Metrics API documentation.