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.

  1. 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.

  2. 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:

  1. In the Confluent Cloud Console, go to the Environments page and select your Confluent Platform environment.

  2. From the Clusters page, select your cluster.

  3. In the navigation menu, click Topics, and then select a topic.

  4. 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.

Add subject view with the schema context menu used to choose the context for a Confluent Platform Schema Registry

List all schemas from the environment view

  1. Go to the environment you want to work with and select it as the current environment.

  2. Click Schema Registry on the navigation menu, and then click the Schemas tab to list all schemas in the environment.

  3. Browse the list to find the schema you want to view.

  4. 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:

Schema toolbar with labeled buttons that switch between tree view and raw view

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.

Schema tree view with expandable fields and tag controls

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

  1. From the navigation menu in a cluster, click Topics, and then click a topic to select it (or create a new one).

  2. Click the Schema tab.

  3. Click Add a schema. The Schema editor appears.

  4. Select a schema type from the drop-down menu under the schema: JSON, Avro, or Protobuf. Avro is the default.

  5. 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 is schema_type_topic_name. Required.

    • type: Either record, enum, union, array, map, or fixed. (The type record is 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 schema name. 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.

  6. 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.

      Warning banner reporting that the schema has parse errors
      Schema editor with the parse error highlighted where a curly bracket is missing

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.

Add schema reference wizard with fields for reference name, subject, and version

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 $ref field of the referenced schema.

  • In Avro, the name is the full name of the referenced schema, which is the value of its name field.

  • In Protobuf, the name is the value of the import statement 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:

  1. If you haven’t already, click Evolve.

  2. Click Add references.

  3. Enter a Reference name that follows the rules for your schema format.

  4. From the Subject list, select the schema.

  5. From the Version list, select the schema version to use.

  6. Click Validate to check that the reference is valid.

  7. 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.

Schema references list showing the Example.Employee reference to the employees-value subject

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.

  1. Go to a topic in a cluster. For example, go to the widget topic, which uses the widget-value schema from the previous example.

  2. Click the Schema tab.

  3. 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

  1. Click the Key option. You’re prompted to set a message key schema.

  2. Click Add a schema.

  3. Choose Avro format, or delete the sample formatting and paste in a string UUID.

  4. 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 record that 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.

  1. From the Cloud Console, go to the environment you want.

  2. From the navigation menu, select Schema Registry.

  3. Go to the Schemas tab and click Add a schema.

  4. In the Create schema view, click Infer schema from a sample JSON message.

  5. 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

  1. From the Cloud Console, go to the environment you want.

  2. From the navigation menu, select Topics.

  3. Click the topic that contains schemaless JSON data.

  4. Click the Schema tab.

    If the topic value has no schema, the tab shows a message that says so.

  5. From the Schema format menu, select Avro, Protobuf, or JSON Schema.

  6. Click Infer a schema from messages.

    The editor shows the inferred schema.

  7. Review the inferred schema. The schema is a starting point and might need manual edits. For guidance, see Review and edit an inferred schema.

  8. Enter a subject name for the schema, such as <topic_name>-value.

  9. 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.

  1. In the Cloud Console, click Connectors.

  2. Click Add Connector, and then search for Datagen.

  3. Select the Datagen Source connector (Sample Data), and then select Advanced Configuration in the dialog.

  4. In the Topic selection dialog, select the users topic and click Continue.

  5. 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.

  6. 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" }
      ]
    }
    
  7. Click Show advanced configurations. Verify that value.converter.schemas.enable is false.

    With this setting, the connector sends raw JSON messages without schema metadata. The topic has no schema for these messages.

  8. Click Continue.

  9. In the Sizing and Review and launch dialogs, accept the defaults. Optional: Rename the connector.

  10. Click Continue to create the connector and start generating sample messages.

Infer a schema from the messages

  1. 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.

    Messages view banner with the Infer schema from messages button
  2. 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.

    Inferred schema in the editor with the Import schema button
  3. When you’re satisfied with the schema, click Create.

    Confluent Cloud creates the schema and registers it with the topic by using the TopicNameStrategy.

  4. 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.

  1. Click Query with Flink, and then click Run.

    Flink query results showing messages as a readable table of the inferred schema fields

    Flink processes the messages and displays the results in a table.

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 doc fields in Avro or description fields 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 null to 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

long

number

int64

Short/integer

int

number

int32

Null

null

null

google.protobuf.Any

BigInteger/BigDecimal

double

number

double

Float/Double

double

number

double

Boolean

boolean

boolean

boolean

String

string

string

string

Troubleshooting

Use these solutions for common schema inference problems.

The schema inference option is unavailable or missing

  • Possible cause: The inference engine has no data to analyze. The topic might be empty or might not have received messages recently. The records in the topic might also not be valid JSON, for example, if they’re Avro, Protobuf, or malformed.

  • Solution: To inspect the content of the topic, go to its Messages tab. Confirm that valid, well-formed JSON messages exist in the topic’s value. If the topic is empty, produce at least one valid JSON message to it, and then return to the Schema tab.

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 userID is 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.

  1. From the navigation menu, click Topics, and then click a topic to select it.

  2. Click the Schema tab.

  3. Select the Key or Value option for the schema.

    The schema opens in raw view.

  4. Click Evolve.

  5. Make the changes in the schema editor.

    To add a region field, 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:

    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 name field, and new messages written with version 2, which has name and region fields. For version 1 messages, region is empty. To learn more, see Passing compatibility checks in Confluent Cloud Schema Registry Tutorial.

  6. 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.

      Schema editor reporting an incompatibility error because the new field has no default value

Compare schema versions

Compare versions of a schema to view its evolutionary differences.

  1. From the navigation menu, click Topics, and then click a topic to select it.

  2. Click the Schema tab.

  3. Select the Key or Value option for the schema. Value is the default.

  4. Click the ellipsis icon, and then select Compare versions.

    The version menu shows the current version number of the schema.

  5. Select the Turn on version diff checkbox.

  6. Select the versions to compare from each version menu.

    Confluent Cloud highlights the differences.

    Compare versions view with two schema versions side by side and the differences highlighted

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.

  1. Select an environment.

  2. Select a cluster.

  3. From the navigation menu, click Topics, and then click a topic to select it.

  4. Click the Schema tab for the topic.

  5. Select the Key or Value option for the schema.

  6. Click the edit icon (Edit) next to Compatibility mode.

    The Compatibility settings pane appears.

  7. 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.

  8. 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

  1. From the navigation menu, click Topics, and then click a topic to select it.

  2. Click the Schema tab.

  3. Select the Key or Value option for the schema.

  4. 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.avsc with 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.

  1. From the navigation menu, click Topics, and then click a topic to select it.

  2. Click the Schema tab.

  3. Select the Key or Value option for the schema.

  4. Click the ellipsis icon, and then select Delete.

  5. On the dialog, select whether to delete only a particular version of the schema or the entire subject (all versions).

    Delete dialog with options to delete one schema version or the entire subject
  6. 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:

  1. From the Home page, select an environment.

  2. 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

OrganizationAdmin

Organization

Yes

Yes

Yes

Yes

Yes

Yes

EnvironmentAdmin

Environment

Yes

Yes

Yes

Yes

Yes

Yes

CloudClusterAdmin

Cluster

No

No

No

No

No

No

Operator

Organization, Environment, Cluster

No

No

No

No

No

No

MetricsViewer

Organization, Environment, Cluster

No

No

No

No

No

No

ResourceOwner

Schema Subject

Yes

Yes

Yes

Yes

Yes

Yes

DeveloperManage

Schema Subject

No

No

No

Yes

Yes

No

DeveloperRead

Schema Subject

Yes

No

No

Yes

No

No

DeveloperWrite

Schema Subject

Yes

Yes

No

Yes

No

No

DataDiscovery

Organization, Environment

Yes

No

No

Yes

No

No

DataSteward

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