Confluent Confluent
Documentation Use CSFLE with Azure Key Vault over Azure Private Link
Confluent Developer Marketplace Get started
Home Confluent Cloud Confluent Platform Connectors Clients
  1. Home
  2. Cloud
  3. Manage Security
  4. Encrypt and Protect Data
  5. Protect Sensitive Data using CSFLE

Use CSFLE with Azure Key Vault over Azure Private Link

By default, when Schema Registry uses an Azure Key Vault key for Client-Side Field Level Encryption (CSFLE), it reaches your vault over the public internet. This guide shows you how to configure Schema Registry to access your Azure Key Vault over a private network connection instead, by registering the key with Confluent Cloud as a self-managed encryption key.

Note

CSFLE with Azure Key Vault over Azure Private Link is a Limited Availability feature in Confluent Cloud.

Your Confluent account team must enable Private Link CSFLE for your Confluent Cloud organization before you can use this feature. If you want to participate in the Limited Availability Program, contact your Confluent account team and provide your Confluent Cloud organization ID.

To set up CSFLE with a private Azure Key Vault, complete these steps:

  1. Create your Azure Key Vault and key. Create a vault with purge protection and RBAC authorization enabled, and then create an RSA key.

  2. Register your key with Confluent and grant access. You tell Confluent Cloud which Azure Key Vault key to use, and Confluent Cloud returns a BYOK key ID as cck-... and an Azure application ID. Then you grant that application the required roles on your vault. Confluent Cloud is authorized to use your key only after both sides approve. For more about BYOK on Azure, see Use Self-Managed Encryption Keys in Confluent Cloud on Azure.

  3. Set up a private connection to your Azure Key Vault. This connection routes Schema Registry traffic to your vault through your private network instead of the public internet. Without this connection, Confluent Cloud still reaches your vault over the public internet instead of the private network.

  4. Create the Schema Registry encryption key and encrypt a field. Create a CSFLE key encryption key (KEK) that references your BYOK key so that Schema Registry encryption calls for that KEK go through your private connection.

  5. Lock your vault to private-only access and verify. Disable public network access to your vault and confirm that Schema Registry still reaches your key.

Prerequisites

Before setting up your private link, ensure you have met these prerequisites:

  • Ensure your account team has enabled the CSFLE Private Link feature for your Confluent Cloud organization.

  • Ensure you have permission to create an Egress Private Link gateway and endpoint in the Confluent Cloud environment that contains your Schema Registry cluster, in the same Azure region as your Schema Registry cluster. You don’t need a Dedicated or Enterprise cluster.

  • Authenticate the Confluent CLI and Azure CLI.

  • Set these environment variables, ensuring your Azure Key Vault and Schema Registry region match:

    # --- Azure ---
    export AZ_SUB="<your-azure-subscription-id>"
    export AZ_TENANT="<your-azure-tenant-id>"
    export RG="<your-resource-group>"
    export VAULT="<your-vault-name>"
    export KEY="csfle-key"
    export LOCATION="<your-region>"
    
    # --- Confluent ---
    export CC_ENV="<env-xxxxx>"       # your Confluent environment
    

Create your Azure Key Vault and key

Schema Registry uses an RSA key stored in your Azure Key Vault to protect the data encryption keys for your encrypted fields. If you already have an Azure Key Vault with purge protection and RSA key with RBAC authorization enabled, skip these steps.

  1. Log in and select your subscription:

    az login --tenant "$AZ_TENANT"
    az account set --subscription "$AZ_SUB"
    
  2. Create a vault with purge protection and RBAC authorization enabled:

    az keyvault create --name "$VAULT" -g "$RG" -l "$LOCATION" \
      --enable-purge-protection true \
      --enable-rbac-authorization true
    
  3. Grant yourself permission to create keys:

    VAULT_ID="$(az keyvault show --name "$VAULT" --query id -o tsv)"
    az role assignment create --role "Key Vault Crypto Officer" \
      --assignee-object-id "$(az ad signed-in-user show --query id -o tsv)" \
      --assignee-principal-type User --scope "$VAULT_ID"
    # Wait approximately 1–2 minutes for the role to take effect.
    
  4. Create an RSA key:

    az keyvault key create --vault-name "$VAULT" --name "$KEY" --kty RSA --size 2048
    

Register your key with Confluent and grant access

Register your Azure Key Vault key with Confluent as a self-managed encryption key, and then grant the Confluent identity permission to use it.

  1. In the Confluent Cloud Console, click the Administration menu icon in the upper-right corner, and then click Encryption keys.

  2. Click Add key.

  3. On the Cloud provider step, select Microsoft Azure, and then click Continue.

  4. On the Key details step, enter these details:

    • Name (alias): Optional. A name that helps you identify the key, such as csfle-key.

    • Key vault tenant ID: Your Azure tenant ID.

    • Key vault resource ID: The resource ID of your vault, as /subscriptions/<subscription-id>/resourceGroups/<resource-group>/providers/Microsoft.KeyVault/vaults/<vault-name>.

    • Key ID without version: The key identifier without the version suffix, as https://<vault-name>.vault.azure.net/keys/<key-name>.

  5. Click Register key.

  6. On the Key configuration step, copy the Azure CLI commands that grant the Confluent application the Key Vault Crypto Service Encryption User and Key Vault Reader roles on your vault. Run these commands in your terminal.

  7. Click Finish.

    The key shows a status of Initializing while Confluent Cloud validates access, which can take up to five minutes.

  8. On the Encryption keys page, confirm that the key is valid, and save its key ID, which is cck-.... Use this ID to create the Schema Registry KEK:

    export CCK_ID="<cck-... from the Encryption keys page>"
    
  1. Register the key as a self-managed encryption key:

    confluent byok create "https://$VAULT.vault.azure.net/keys/$KEY" \
      --tenant "$AZ_TENANT" \
      --key-vault "/subscriptions/$AZ_SUB/resourceGroups/$RG/providers/Microsoft.KeyVault/vaults/$VAULT"
    
  2. From the output, save the ID value of your key, which is cck-..., and the application ID from the Roles field. The application ID is the Confluent identity that accesses your key:

    export CCK_ID="<cck-... from output>"
    export APP_ID="<application id from Roles>"
    
  3. Grant your Confluent identity access to your vault. To see the exact commands for your key, run confluent byok describe "$CCK_ID". The commands look similar to the following:

    VAULT_ID="$(az keyvault show --name "$VAULT" --query id -o tsv)"
    SP_ID="$(az ad sp show --id "$APP_ID" --query id -o tsv 2>/dev/null || \
             az ad sp create --id "$APP_ID" --query id -o tsv)"
    
    # Key Vault Crypto Service Encryption User
    az role assignment create --role "e147488a-f6f5-4113-8e2d-b22465e65bf6" \
      --scope "$VAULT_ID" \
      --assignee-object-id "$SP_ID" \
      --assignee-principal-type ServicePrincipal
    
    # Key Vault Reader
    az role assignment create --role "21090545-7ca7-4776-b22c-e363652d74d2" \
      --scope "$VAULT_ID" \
      --assignee-object-id "$SP_ID" \
      --assignee-principal-type ServicePrincipal
    
  4. Confirm that the key is valid:

    confluent byok describe "$CCK_ID"
    

    In the output, confirm that Validation Phase is VALID.

Set up a private connection to your Azure Key Vault

Create an Egress Private Link Endpoint in Confluent Cloud that connects to your Azure Key Vault. This connection routes Schema Registry traffic to your vault through your private network instead of the public internet.

Schema Registry doesn’t run on a Kafka cluster, so you don’t need a Dedicated or Enterprise cluster for this connection. Instead, create the endpoint on an Egress Private Link gateway in the Confluent Cloud environment that contains your Schema Registry cluster, in the same Azure region as your Schema Registry cluster. Each environment supports one gateway per region. If a gateway already exists in that region, use it.

To create the connection, complete these steps:

  1. Create an Egress Private Link gateway in your Schema Registry environment and region, if one doesn’t already exist. For details, see Create a gateway for outbound connectivity in Confluent Cloud.

  2. Create an Egress Private Link Endpoint on the gateway. Use your vault’s resource ID as the target service resource ID. For details, see Create an Egress Private Link Endpoint in Confluent Cloud.

    Note

    When creating your access point in Cloud Console, select Other as the service.

  3. In the Azure portal, approve the private endpoint connection on your vault.

Create the Schema Registry encryption key and encrypt a field

Create a Schema Registry KEK that uses your self-managed encryption key, and then add an encryption rule to your schema to encrypt the fields you want to protect. KEKs that reference a BYOK key must be shared with Confluent Cloud.

  1. In the Confluent Cloud Console, select your environment, and then click Stream Governance > Schema Registry > Encryption keys.

  2. Click Add encryption key.

  3. In the Name field, enter csfle-kek.

  4. In the Key management system provider field, select Azure, and then enter the key ID of your Azure Key Vault key, as https://<vault-name>.vault.azure.net/keys/<key-name>.

  5. Enable Share key access with Confluent Cloud, and then select the self-managed encryption key that you registered in Register your key with Confluent and grant access.

  6. Click Add.

  7. Click Schemas, and then select the schema that contains the fields you want to protect.

  8. Click Evolve > Rules > Add rules.

  9. In the Add rules panel, enter the following information:

    • Category: Select Data encryption rule.

    • Rule name: Enter a name that’s unique within the subject, such as encryptPII.

    • Encrypt fields with: Select the tags for the fields to encrypt, such as PII, and then select csfle-kek as the Encryption key.

  10. Click Add. Save the schema.

For details about the rule options, see Add an encryption rule.

  1. Create a KEK that references your encryption key. The cckId property links the KEK to your registered key:

    confluent schema-registry kek create csfle-kek \
      --kms-type azure-kms \
      --kms-key "https://$VAULT.vault.azure.net/keys/$KEY" \
      --kms-properties "cckId=$CCK_ID" \
      --shared \
      --environment "$CC_ENV"
    
  2. Reference csfle-kek in the encryption rule when you register the schema by using the Schema Registry API. Because you already created the KEK, the rule needs only the encrypt.kek.name parameter. For example, this rule encrypts every field tagged PII:

    {
      "schema": "...",
      "metadata": {...},
      "ruleSet": {
        "domainRules": [
          {
            "name": "encryptPII",
            "kind": "TRANSFORM",
            "type": "ENCRYPT",
            "mode": "WRITEREAD",
            "tags": ["PII"],
            "params": {
              "encrypt.kek.name": "csfle-kek"
            },
            "onFailure": "ERROR,NONE"
          }
        ]
      }
    }
    

    For the full rule format and client configuration, see Configure client-side field level encryption.

Lock your vault to private-only and verify

Before you restrict public access to your vault, confirm that the private connection between Confluent Cloud and your Azure Key Vault works. For setup steps, see Set up a private connection to your Azure Key Vault.

Important

If you also use keys in this vault for self-managed encryption of Kafka clusters, disabling public network access can stop those clusters from reaching their keys. For Dedicated clusters with network restrictions, set your Azure Firewall and virtual networks settings to Allow trusted Microsoft services to bypass this firewall. For Enterprise clusters, set your Azure Firewall and virtual networks settings to Allow public access from all networks.

To avoid this, use a separate vault for CSFLE keys that Schema Registry accesses over Private Link. For details, see Use Self-Managed Encryption Keys in Confluent Cloud on Azure.

Warning

Confluent Cloud doesn’t block deletion of BYOK keys that are used for CSFLE over Private Link. If you delete a BYOK key, every KEK that references it immediately and permanently loses the ability to encrypt or decrypt data.

  1. After you confirm the private connection, disable public network access to your vault:

    az keyvault update --name "$VAULT" -g "$RG" --public-network-access Disabled
    
  2. To verify that Schema Registry still reaches your key over the private connection, produce and consume a record that uses the encryption rule from Create the Schema Registry encryption key and encrypt a field.

Ask the community Confluent Support Portal Last updated: Nov 17, 2026
Terms & Conditions | Privacy Policy | Do Not Sell My Information | Modern Slavery Policy | Cookie Settings | Feedback

Copyright © Confluent, Inc. 2014- Apache®, Apache Kafka®, Kafka®, Apache Flink®, Flink®, Apache Iceberg®, Iceberg® and associated open source project names are trademarks of the Apache Software Foundation

Confluent Cloud

CLOUD

  • Overview
  • Get Started
    • Overview
    • Free Trial
    • Create and Manage Your Account
    • Regions and Availability
    • Quick Start: Confluent Cloud
    • Quick Start: REST API
    • Manage Schemas
    • Tutorials and Examples
      • Overview
      • Tutorial: Use Replicator to Copy Kafka Data to Cloud
      • Example: Create Fully Managed Services
    • Use Docs with AI Tools
  • Build a Streamhouse
    • Overview
    • Quick start
    • Build with a Blueprint
    • Capture and maintain your business
    • Run your business
    • Query current state
  • Query Data with Lightning Tables
    • Overview
    • Get Started
    • Manage Lightning Tables
    • Query a Lightning Table
      • Overview
      • Query with the API
      • Query with MCP
      • Query with the Confluent CLI
      • Query with JDBC
      • SQL Reference
    • Schema Evolution
    • Manage Access
    • Private Networking
    • Monitor
    • Support and Limitations
  • Use Kafka Clusters
    • Overview
    • Resilience
    • Cluster Deletion Protection
    • Multi-Tenancy and Client Quotas
      • Overview
      • Quick Start
    • Manage Clusters
      • Create a Cluster
      • View Clusters
      • Update a Cluster
      • Delete a Cluster
      • Resize a Dedicated Cluster
      • Manage Configuration Settings
    • Migrate Clusters
      • Migrate to Confluent Cloud
      • Migrate with kcp
    • Copy and Share Data
      • Cluster Linking
        • Overview
        • Quick Start
        • Configure, Manage, and Monitor
          • Configure and Manage Cluster Links
          • Manage Mirror Topics
          • Manage Private Networking
          • Manage Security
          • Monitor Metrics
        • Use Cases and Tutorials
          • Share Data Across Clusters, Regions, and Clouds
          • Disaster Recovery and Failover
            • Disaster Recovery Overview
            • Automatic Failover (Active-Passive)
            • Manual Switchover (Active-Active)
            • Manual Switchover (Active-Passive)
          • Create Hybrid Cloud and Bridge-to-Cloud Deployments
          • Use Tiered Separation of Critical Workloads
          • Migrate Data
          • Manage Audit Logs
        • Troubleshooting
      • Replicator
        • Quick Start
        • Use Replicator to Migrate Topics
    • Connect Confluent Platform and Cloud Environments
      • Overview
      • Connect Self-Managed Gateway to Cloud
        • Confluent Cloud Gateway Overview
        • Configure and Deploy
          • Overview
          • Docker Deployment
            • Deploy using Docker
            • Secure Docker Deployments
            • Troubleshoot Docker Deployments
          • CFK Deployment
            • Deploy using CFK
            • Secure CFK Deployments
        • Enforce Centralized Governance
          • Overview
          • Configure Centralized Governance
        • Migrate Kafka Clusters
        • Migrate Topics with Topic-Based Routing
        • Set up Network Isolation and Custom Domains
        • Monitor Gateway Metrics
      • Connect Self-Managed Control Center to Cloud
      • Connect Self-Managed Clients to Cloud
      • Connect Self-Managed Connect to Cloud
      • Connect Self-Managed REST Proxy to Cloud
      • Connect Self-Managed ksqlDB to Cloud
      • Connect Self-Managed MQTT to Cloud
      • Connect Self-Managed Schema Registry to Cloud
      • Connect Self-Managed Streams to Cloud
      • Example: Autogenerate Self-Managed Component Configs for Cloud
    • Automate with Infrastructure as Code
      • Create Clusters with Terraform
      • Terraform Security Best Practices
      • Create Clusters with Pulumi
    • FAQ
  • Build Client Applications
    • Overview
    • Architectural Considerations
    • Client Quick Start
    • Configure Clients
      • Consumer
      • Share Consumers
      • Producer
      • Configuration Properties
    • Test and Monitor a Client
      • Test
      • Monitor
        • Overview
        • Monitoring with JMX
        • Configure JMX
        • Producer Metrics
        • Consumer Metrics
        • Share Consumer Metrics
      • Reset Offsets
    • Optimize and Tune
      • Overview
      • Throughput
      • Latency
      • Durability
      • Availability
      • Freight
    • Client Guides
      • Python
      • .NET Client
      • JavaScript Client
      • Go Client
      • C++ Client
      • Java Client
    • Kafka Client APIs for Confluent Cloud
      • Python Client API
      • .NET Client API
      • JavaScript Client API
      • Go Client API
      • C++ Client API
      • Java Client API
    • Deprecated Client APIs
    • Client Examples
      • Overview
      • Rust Client
      • Python Client
      • .NET Client
      • JavaScript Client
      • Go Client
      • C++ Client
      • Java
      • Spring Boot
      • KafkaProducer
      • REST
      • Clojure
      • Groovy
      • Kafka Connect Datagen
      • kafkacat
      • Kotlin
      • Ruby
      • Scala
    • Confluent Plugin for JetBrains IDEs
    • VS Code Extension
    • Connect to a Kafka Cluster with VS Code
    • Browse Messages with VS Code
    • Work with Schemas in VS Code
    • Clients FAQ
  • Build Kafka Streams Applications
    • Overview
    • Quick Start
    • Metrics
    • Monitor Applications
    • FAQ
    • Upgrade Guide
    • ksqlDB
      • Create Stream Processing Apps with ksqlDB
      • Quick Start
      • Enable ksqlDB Integration with Schema Registry
      • ksqlDB Cluster API Quick Start
      • Monitor ksqlDB
      • Manage ksqlDB by using the CLI
      • Manage Connectors With ksqlDB
      • Develop ksqlDB Applications
      • SQL Reference (Confluent Platform)
      • Pull Queries
      • Grant Role-Based Access
      • Migrate ksqlDB Applications on Confluent Cloud
  • AI and ML
    • Overview
    • Build AI with Confluent Intelligence
      • Overview
      • Streaming Agents
        • Overview
        • Agent Runtime Guide
        • Call Tools
        • Create and Run Streaming Agents
        • Manage Agents in the Console
        • Reflection Workflows
        • Monitor Streaming Agents
        • Debug Streaming Agents
        • Examples
      • Real-Time Context Engine
      • Built-in AI/ML Functions
        • Overview
        • Analyze Sentiment
        • Detect Anomalies
        • Detect PII
        • Forecast Trends
        • Invoke a Tool in an AI Workflow
        • ML Preprocessing Functions
        • Model Inference Functions
      • Create Embeddings
        • Overview
        • Create Embeddings
      • Run Managed Model Inference
      • Run External Model Inference
      • Search External Tables
        • Overview
        • Key Search with External Sources
        • Text Search with External Sources
        • Vector Search with External Sources
      • FAQ
    • Use AI Tools with Confluent
      • Overview
      • Access Confluent Cloud with the Managed MCP Servers
      • Build with the Open-Source MCP Server
      • Build with Agent Skills
      • Confluent Assistant overview
      • Troubleshoot connectors with Confluent Assistant
  • Manage Topics
    • Overview
    • Configuration Reference
    • Message Browser
    • Share Streams
      • Overview
      • Provide Stream Shares
      • Consume Stream Shares
    • Tableflow
      • Overview
      • Concepts
        • Overview
        • Storage
        • Schemas
        • Materialize Change Data Capture Streams
        • Write Modes
      • Get Started
        • Overview
        • Quick Start with Managed Storage
        • Quick Start Using Your Storage and AWS Glue
        • Quick Start Using Your Storage on Google Cloud
        • Quick Start with Delta Lake Tables
      • How-to Guides
        • Overview
        • Configure Storage
        • Encrypt Sensitive Fields
        • Integrate Catalogs
          • Overview
          • Integrate with AWS Glue Catalog
          • Integrate with Lakehouse Runtime Catalog
          • Integrate with Snowflake Horizon Catalog
          • Integrate with Snowflake Open Catalog
          • Integrate with Unity Catalog
          • User-defined namespaces
        • Query Data
          • Overview
          • Query with AWS
          • Query with DuckDB
          • Query with Flink
          • Query with Snowflake
          • Query with Trino
      • Operate
        • Overview
        • Configure
        • Grant Role-Based Access
        • Monitor
        • Use Private Networking
        • Access the Tableflow Iceberg REST Catalog over AWS PrivateLink
        • Use Private Networking with Azure
    • Lightning Tables
    • FAQ
  • Manage and Monitor Resources with USM
    • Overview
    • Register Confluent Platform with USM
      • Overview
      • Set Up Payment Method
      • Configure Private Networking
        • Overview
        • AWS
        • Azure
      • Configure a Service Account
      • Deploy the USM Agent
      • Complete the Cluster Registration
    • Register Connect Cluster with USM
      • Overview
      • Confluent Platform Kafka as the Metadata Cluster
      • Confluent Cloud Kafka as the Metadata Cluster
      • Deregister a Connect Cluster
    • Monitor Confluent Platform Resources
      • Overview
      • Clusters
      • Tiered Storage
      • Topics
      • Connectors on Confluent Platform Kafka
      • Connectors on Confluent Cloud Kafka
      • Consumer Lag
      • Clients
      • Kafka Streams
      • Alerts
    • Data Governance for Confluent Platform
    • Role-Based Access Control
    • Remove the USM Agent
    • Troubleshoot
  • Govern Data Streams
    • Overview
    • Stream Governance
      • Manage Governance Packages
      • Data Portal
      • Track Data with Stream Lineage
      • Manage Stream Catalog
        • Stream Catalog User Guide
        • REST API Catalog Usage and Examples Guide
        • GraphQL API Catalog Usage and Examples Guide
    • Manage Schemas
      • Overview
      • Why |sr| is Required
      • Manage Schemas
      • Delete Schemas and Manage Storage
      • Use Broker-Side Schema ID Validation
      • Schema Linking
      • Schema Registry Tutorial
    • Fundamentals
      • Key Concepts
      • Schema Evolution and Compatibility
      • Schema Formats
        • Serializers and Deserializers Overview
        • Avro
        • Protobuf
        • JSON Schema
      • Data Contracts
      • Explicit Topic-Subject Associations
      • Security Considerations
      • Enable Private Networking
        • Enable Private Networking with Schema Registry PrivateLink
        • Enable Private Networking for Schema Registry with a Public Endpoint
    • Reference
      • Overview
      • Configure Clients
      • Schema Registry C++ Client (libschemaregistry)
      • Schema Registry Maven Plugin for Confluent Cloud
      • Example usage
      • Example usage
      • REST API Usage Examples
      • Use AsyncAPI to Describe Topics and Schemas
    • FAQ
  • Connect to External Services
    • Overview
    • Install Connectors
      • ActiveMQ Source
      • AlloyDB Sink
      • Amazon CloudWatch Logs Source
      • Amazon CloudWatch Metrics Sink
      • Amazon DocumentDB Sink
        • Configure and Launch
        • Configure with AWS Egress PrivateLink Endpoints
      • Amazon DynamoDB CDC Source
        • Configure and Launch
        • Configure with AWS Egress PrivateLink Endpoints
      • Amazon DynamoDB Sink
      • Amazon Kinesis Source
      • Amazon Redshift Sink
      • Amazon S3 Sink
        • Configure and Launch
        • Configure with AWS Egress PrivateLink Endpoints
      • Amazon S3 Source
      • Amazon SQS Source
      • AWS Lambda Sink
      • Azure Blob Storage Sink
        • Configure and Launch
        • Configure with Azure Egress Private Link Endpoints
      • Azure Blob Storage Source
      • Azure Cognitive Search Sink
      • Azure Cosmos DB Sink [Deprecated]
      • Azure Cosmos DB Sink V2
      • Azure Cosmos DB Source [Deprecated]
      • Azure Cosmos DB Source V2
      • Azure Data Explorer (Kusto) Database Sink
      • Azure Data Lake Storage Gen2 Sink
      • Azure Event Hubs Source
      • Azure Functions Sink
      • Azure Log Analytics Sink
      • Azure Log Analytics Sink V2
      • Azure Service Bus Source
      • Azure Synapse Analytics Sink
      • ChromaDB Sink
      • ClickHouse Sink
        • Configure and Launch
        • Configure with AWS Egress PrivateLink Endpoints
        • Configure with Azure Egress Private Link Endpoints
        • Configure with Google Cloud Private Service Connect Endpoints
      • Couchbase Source
        • Configure and Launch
        • Configure with AWS Egress PrivateLink Endpoints
        • Configure with Azure Egress Private Link Endpoints
        • Configure with GCP Egress Private Service Connect Endpoints
      • Couchbase Sink
        • Configure and Launch
        • Configure with AWS Egress PrivateLink Endpoints
        • Configure with Azure Egress Private Link Endpoints
        • Configure with GCP Egress Private Service Connect Endpoints
      • Databricks Delta Lake Sink
        • Set up Databricks Delta Lake (AWS) Sink Connector for Confluent Cloud
        • Configure and launch the connector
      • Datadog Metrics Sink
      • Datagen Source (development and testing)
      • DataStax Sink
      • Elasticsearch Service Sink [Deprecated]
      • Elasticsearch Service Sink V2
        • Configure and Launch
        • Configure with AWS Egress PrivateLink Endpoints
        • Configure with Google Cloud Private Service Connect Endpoints
        • Configure with Azure Egress Private Link Endpoints
      • GitHub Source
      • Google BigQuery Source (JDBC)
      • Google BigQuery Sink [End of Life]
      • Google BigQuery Sink V2
      • Google Cloud BigTable Sink
      • Google Cloud Dataproc Sink [End of Life]
      • Google Cloud Firestore Sink
      • Google Cloud Functions Gen 2 Sink
      • Google Cloud Functions Sink [End of Life]
      • Google Cloud Pub/Sub Source
      • Google Cloud Spanner CDC Source (Debezium)
      • Google Cloud Spanner Sink
      • Google Cloud Storage Sink
      • Google Cloud Storage Source
      • HTTP Sink
      • HTTP Sink V2
      • HTTP Source
      • HTTP Source V2
      • IBM Db2 Source (JDBC)
      • IBM MQ Sink
      • IBM MQ Source
      • InfluxDB 2 Sink
      • InfluxDB 2 Source
      • InfluxDB 3 Sink
      • Jira Source
      • MariaDB CDC Source (Debezium)
      • Marketo Sink
      • Microsoft Dynamics 365 CRM Source
      • Microsoft SQL Server CDC Source (Debezium) [End of Life]
      • Microsoft SQL Server CDC Source V2 (Debezium)
        • Configure and launch the connector
        • Backward incompatibility considerations
      • Microsoft SQL Server Sink (JDBC)
      • Microsoft SQL Server Source (JDBC)
      • MongoDB Atlas Sink
        • Configure and Launch
        • Configure with AWS Egress PrivateLink Endpoints
        • Configure with Azure Egress Private Link Endpoints
        • Configure with Google Cloud Egress Private Service Connect Endpoints
      • MongoDB Atlas Source
      • MongoDB CDC Source (Debezium)
        • Configure and Launch
        • Configure with AWS Egress PrivateLink Endpoints
        • Configure with Azure Egress Private Link Endpoints
        • Configure with Google Cloud Egress Private Service Connect Endpoints
        • Monitoring
      • MQTT Sink
      • MQTT Source
      • MySQL CDC Source (Debezium) [End of Life]
      • MySQL CDC Source V2 (Debezium)
        • Configure and Launch the connector
        • Backward Incompatible Changes
      • MySQL Sink (JDBC)
      • MySQL Source (JDBC)
      • Neo4j Sink
        • Configure and Launch
        • Configure with AWS Egress PrivateLink Endpoints
        • Configure with Google Cloud Private Service Connect Endpoints
      • New Relic Metrics Sink
      • OpenSearch Sink
      • Oracle XStream CDC Source
        • Overview
        • Configure and Launch the connector
        • Oracle Database Prerequisites
        • Downstream Capture
        • Cascading Downstream Capture
        • Change Events
        • Signals and Actions
        • Examples
        • Troubleshooting
        • Monitoring
      • Oracle CDC Source
        • Overview
        • Configure and Launch the connector
        • Horizontal Scaling
        • Oracle Database Prerequisites
        • SMT Examples
        • DDL Changes
        • Troubleshooting
      • Oracle Database Sink (JDBC)
      • Oracle Database Source (JDBC)
      • PagerDuty Sink [End of Life]
      • Pinecone Sink
      • PostgreSQL CDC Source (Debezium) [End of Life]
      • PostgreSQL CDC Source V2 (Debezium)
        • Configure and Launch the connector
        • Backward Incompatible Changes
      • PostgreSQL Sink (JDBC)
      • PostgreSQL Source (JDBC)
      • RabbitMQ Sink
      • RabbitMQ Source
      • Redis Sink [Deprecated]
      • Redis Kafka Sink
      • Redis Kafka Source
      • Salesforce Bulk API 2.0 Sink
      • Salesforce Bulk API 2.0 Source
      • Salesforce Bulk API Source
      • Salesforce CDC Source
      • Salesforce Platform Event Sink
      • Salesforce Platform Event Source
      • Salesforce PushTopic Source
      • Salesforce SObject Sink
      • Salesforce Source V2
      • ServiceNow Sink
      • ServiceNow Source (Legacy) [Deprecated]
      • ServiceNow Source V2
      • SFTP Sink
      • SFTP Source
      • Snowflake Sink
        • Configure and Launch
        • Configure with AWS Egress PrivateLink Endpoints
        • Configure with Azure Egress Private Link Endpoints
        • Configure with Google Cloud Private Service Connect Endpoints
      • Snowflake Source
        • Configure and Launch
        • Configure with AWS Egress PrivateLink Endpoints
        • Configure with Azure Egress Private Link Endpoints
        • Configure with Google Cloud Private Service Connect Endpoints
      • Solace Sink
      • Solace Source
      • Splunk Sink
      • Stripe Source
        • Configure and Launch
        • Record Schemas
      • Webhook Source
      • Zendesk Source
    • Self-Managed Connectors on Confluent Cloud
      • Overview
    • Confluent Marketplace
      • Overview
      • Component Archive Specification
      • Contribute
    • Install Custom Plugins and Custom Connectors
      • Overview
      • Quick Start
      • Manage Custom Connectors
      • Limitations and Support
      • API and CLI
    • Manage Client-Side Encryption
    • Manage Provider Integration
    • Secret Manager Integration
      • Overview
      • Azure Key Vault Integration
      • AWS Secrets Manager Integration
      • Google Cloud Secret Manager Integration
    • Back Up and Restore Data with Object Storage Connectors
    • Networking and DNS
      • Overview
      • AWS Egress PrivateLink Endpoints for First-Party Services
      • AWS Egress PrivateLink Endpoints for Self-Managed Services
      • AWS Egress PrivateLink Endpoints for Amazon RDS
      • AWS Egress PrivateLink Endpoints for Amazon DocumentDB
      • Azure Egress Private Link Endpoints for First-Party Services
      • Azure Egress Private Link Endpoints for Self-Managed Services
      • Google Cloud Private Service Connect Endpoints for First-Party Services
      • Google Cloud Private Service Connect Endpoints for Self-Managed Services
    • Connect API Usage
    • Manage Public Egress IP Addresses
    • Sample Connector Output
    • Configure Single Message Transformations
    • Configure Custom SMTs
      • Quick Start
      • Manage Custom SMT APIs
      • Enable External Network Calls
      • Limitations and Support
    • View Connector Events
    • Interpret Connector Statuses
    • Manage Service Accounts
    • Configure RBAC
    • View Errors in the Dead Letter Queue
    • Connector Limits
    • Manage Offsets
    • Migrate Self-Managed Connectors
    • Transforms List
      • Overview
      • AdjustPrecisionAndScale
      • BytesToString
      • Cast
      • ChangeTopicCase
      • Drop
      • DropHeaders
      • EventRouter
      • ExtractChangedRecordState
      • ExtractField
      • ExtractNestedField
      • ExtractNewRecordState
      • ExtractTimeStamp
      • ExtractTopic
      • Filter (Kafka)
      • Filter (Confluent)
      • Flatten (Kafka)
      • Flatten (Confluent)
      • HeaderFrom
      • HeaderToValue
      • HoistField
      • InsertField
      • InsertHeader
      • KeyToValue
      • MaskField
      • MessageTimestampRouter
      • ReplaceField (Kafka)
      • ReplaceField (Confluent)
      • SetMaximumPrecision
      • SetSchemaMetadata
      • TimestampConverter
      • TimestampNow
      • TimestampNowField
      • TimestampRouter
      • TimescaleDB
      • TimezoneConverter
      • ToLogicalTopicRouter
      • TombstoneHandler
      • TopicRegexRouter
      • ValueToKey
    • Reference
      • Additional Connector Configuration
      • Confluent AI-Assisted Troubleshooting
  • Integrate with Confluent Cloud
    • Overview
    • Connect with Confluent Program
    • Reuse Connections with External Services
      • Overview
      • Supported External Services
      • Manage Connections
    • Integrate with Cloud Service Providers
      • Overview
      • Create an AWS Provider Integration
      • Create an Azure Provider Integration
      • Create a Google Cloud Provider Integration
      • Manage a Provider Integration
  • Process Data with Flink
    • Overview
    • Get Started
      • Overview
      • Quick Start with Cloud Console
      • Quick Start with SQL Shell in Confluent CLI
      • Quick Start with Java Table API
      • Quick Start with Python Table API
    • Concepts
      • Overview
      • Autopilot
      • Batch and Stream Processing
      • Comparison with Apache Flink
      • Compute Pools
      • Delivery Guarantees and Latency
      • Determinism
      • External Tables
      • Materialized Tables
      • Private Networking
      • Process Table Functions
      • Schema and Statement Evolution
      • Security Controls
      • Snapshot Queries
      • Statements
      • Statement CFU Metrics
      • Tables and Topics
      • Time and Watermarks
      • User-defined Functions
    • How-To Guides
      • Overview
      • Aggregate a Stream in a Tumbling Window
      • Combine Streams and Track Most Recent Records
      • Compare Current and Previous Values in a Stream
      • Configure a Dead Letter Queue
      • Convert the Serialization Format of a Topic
      • Create a Process Table Function
      • Create a UDF
      • Deduplicate Rows in a Table
      • Deploy a Statement with CI/CD
      • Enrich a Stream with Reference Data
      • Evolve a Streaming Pipeline
      • Generate Custom Sample Data
      • Handle Late-Arriving Data
      • Handle Multiple Event Types
      • Log Debug Messages in UDFs
      • Mask Fields in a Table
      • Move a Statement to a Different Compute Pool
      • Read and Write Custom Changelog Formats
      • Read Records without a Schema ID Prefix
      • Profile a Query
      • Resolve Statement Issues
      • Scan and Summarize Tables
      • Run a Snapshot Query
      • Set a Baseline CFU for a Statement
      • Transform a Topic
      • Use Client-Side Field Level Encryption
      • View Schema Metadata in the Catalog Browser
      • View Time Series Data
    • Operate and Deploy
      • Overview
      • Carry-over Offsets
      • Connect with JDBC
      • Deploy with dbt
      • dbt Adapter Reference
      • Deploy Table API Programs
      • Development Lifecycle
      • Enable Private Networking
      • Generate a Flink API Key
      • Grant Role-Based Access
      • Manage Compute Pools
      • Manage Connections
      • Manage with Terraform
      • Monitor and Manage Statements
      • Move SQL Statements to Production
      • Use the Query Profiler
      • REST API
    • Flink Reference
      • Overview
      • SQL Syntax
      • DDL Statements
        • Statements Overview
        • ALTER AGENT
        • ALTER CONNECTION
        • ALTER MODEL
        • ALTER MATERIALIZED TABLE
        • ALTER TABLE
        • ALTER TOOL
        • ALTER VIEW
        • CREATE AGENT
        • CREATE CONNECTION
        • CREATE FUNCTION
        • CREATE MATERIALIZED TABLE
        • CREATE MODEL
        • CREATE OR ALTER MATERIALIZED TABLE
        • CREATE TABLE
        • CREATE TOOL
        • CREATE VIEW
        • DESCRIBE
        • DROP AGENT
        • DROP CONNECTION
        • DROP FUNCTION
        • DROP MATERIALIZED TABLE
        • DROP MODEL
        • DROP TABLE
        • DROP TOOL
        • DROP VIEW
        • EXPLAIN
        • RESET
        • SET
        • SHOW
        • USE CATALOG
        • USE database_name
      • Queries
        • Queries Overview
        • Deduplication
        • Group Aggregation
        • HINTS
        • INSERT INTO FROM SELECT
        • INSERT VALUES
        • Joins
        • LIMIT
        • Pattern Recognition
        • ORDER BY
        • OVER Aggregation
        • SELECT
        • Set Logic
        • EXECUTE STATEMENT SET
        • Top-N
        • Window Aggregation
        • Window Deduplication
        • Window Join
        • Window Top-N
        • Window Table-Valued Function
        • WITH
      • Functions
        • AI Model Inference
        • Aggregate
        • Changelog Conversion
        • Collections
        • Comparison
        • Conditional
        • Datetime
        • Flink SQL Functions
        • Hashing
        • JSON
        • ML Preprocessing
        • Numeric
        • Search
        • String
        • Table API
      • Data Types
      • Data Type Mappings
      • Time Zone
      • Keywords
      • Information Schema
      • Example Streams
      • SQL Examples
      • Table API
      • CLI Reference
    • Get Help
    • FAQ
  • Manage Networking
    • Confluent Cloud Networking Overview
    • Networking on AWS
      • AWS Networking Overview
      • Public Networking on AWS
      • Confluent Cloud Network on AWS
      • PrivateLink on AWS
        • PrivateLink Overview
        • Inbound PrivateLink for Dedicated Clusters
        • Inbound PrivateLink for Serverless Products
        • Outbound PrivateLink for Dedicated Clusters
        • Outbound PrivateLink for Serverless Products
      • VPC Peering on AWS
      • Transit Gateway on AWS
      • Private Network Interface on AWS
      • DNS Forwarding on AWS
    • Networking on Azure
      • Azure Networking Overview
      • Public Networking on Azure
      • Confluent Cloud Network on Azure
      • Private Link on Azure
        • Private Link Overview
        • Inbound Private Link for Dedicated Clusters
        • Inbound Private Link for Serverless Products
        • Outbound Private Link for Dedicated Clusters
        • Outbound Private Link for Serverless Products
      • VNet Peering on Azure
    • Networking on Google Cloud
      • Google Cloud Networking Overview
      • Public Networking on Google Cloud
      • Confluent Cloud Network on Google Cloud
      • Private Service Connect on Google Cloud
        • Private Service Connect Overview
        • Inbound Private Service Connect for Dedicated Clusters
        • Inbound Private Service Connect for Serverless Products
        • Outbound Private Service Connect for Dedicated Clusters
      • VPC Peering on Google Cloud
    • Connectivity for Confluent Resources
      • Overview
      • Public Egress IP Address for Connectors and Cluster Linking
      • Cluster Linking using AWS PrivateLink
      • Follower Fetching using AWS VPC Peering
    • Use the Confluent Cloud Console with Private Networking
    • Test Connectivity
    • Networking FAQ
  • Log and Monitor
    • Overview
    • Metrics
    • Integrate Third-Party Monitoring Tools
    • Manage Notifications
    • Monitor Consumer Lag
    • Monitor Dedicated Clusters
      • Manage Performance and Expansion
      • Track Usage by Team
    • Export Logs to Third-Party Tools
    • Tutorials and Examples
      • Run Example Queries
      • Observability for Kafka Clients
    • FAQ
  • Manage Security
    • Overview
    • Manage Authentication
      • Overview
      • Manage User Identities
        • Overview
        • Manage User Accounts
          • Overview
          • Authentication Security Protections
          • Manage Local User Accounts
          • Multi-factor Authentication
          • Manage SSO User Accounts
        • Manage User Identity Providers
          • Overview
          • Use Single Sign-On (SSO)
          • Manage SAML Single Sign-On (SSO)
          • Manage Azure Marketplace SSO
          • Just-in-time User Provisioning
          • SCIM User Provisioning
          • Group Mapping
            • Overview
            • Enable Group Mapping
            • Manage Group Mappings
            • Troubleshooting
            • Best Practices
          • Manage Trusted Domains
          • Manage SSO provider
          • Troubleshoot SSO
      • Manage Workload Identities
        • Overview
        • Manage Workload Identities
        • Manage Service Accounts and API Keys
          • Overview
          • Create Service Accounts
          • Manage Service Accounts
          • Manage API Keys
            • Overview
            • Manage API keys
            • Best Practices
            • Troubleshoot
        • Manage OAuth/OIDC Identity Providers
          • Overview
          • Add an OIDC Identity Provider
          • Use OAuth Identity Pools and Filters
          • Manage Identity Provider Configurations
          • Manage the JWKS URI
          • Configure OAuth Clients
            • Overview
            • Go Clients
            • Java Clients
            • JavaScript Clients
            • .NET Clients
            • Python Clients
            • Configuration Reference
            • Configure UAMI
            • Configure AWS IAM Java Client Plugin
            • Configure AWS IAM Python Client Plugin
            • Configure AWS IAM .NET Client Plugin
          • Access Kafka REST APIs
          • Use Confluent STS Tokens with REST APIs
          • Best Practices
          • Troubleshoot OAuth Issues
        • Manage mTLS Identity Providers
          • Overview
          • Configure mTLS
          • Manage Certificate Authorities
          • Manage Certificate Identity Pools
          • Create CEL Filters for mTLS
          • Create JSON payloads for mTLS
          • Manage Certificate Revocation
          • Troubleshoot mTLS Issues
      • Identity FAQ
    • Control Access
      • Overview
      • Resource Hierarchy
        • Overview
        • Organizations
          • Overview
          • Manage Multiple Organizations
        • Environments
        • Confluent Resource Names (CRNs)
      • Manage Role-Based Access Control
        • Overview
        • Predefined RBAC Roles
        • Manage Role Bindings
        • Use ACLs with RBAC
      • Manage IP Filtering
        • Overview
        • Manage IP Groups
        • Manage IP Filters
        • Best Practices
      • Manage Access Control Lists
        • Overview
        • Operations
        • Examples
        • Troubleshoot
        • Reference
      • Use the Confluent CLI with multiple credentials on Confluent Cloud
    • Encrypt and Protect Data
      • Overview
      • Manage Data in Transit With TLS
      • Use Self-Managed Encryption Keys
        • Overview
        • Use Self-Managed Encryption Keys on AWS
        • Use Self-Managed Encryption Keys on Azure
        • Use Self-Managed Encryption Keys on Google Cloud
        • Use Self-Managed Encryption Keys with Tableflow
        • Use Confluent CLI for Self-Managed Encryption Keys
        • Use BYOK API for Self-Managed Encryption Keys
        • Revoke Access to Data at Rest
        • Best Practices
        • Troubleshoot Key Policy Issues
      • Use Client-Side Field Level Encryption
        • Overview
        • Manage CSFLE using Confluent Cloud Console
        • Use Client-side Field Level Encryption
        • Configuration Settings
        • Manage Encryption Keys
        • Use CSFLE with Azure Key Vault over Azure Private Link
        • Manage Multiple Encryption Rules
        • Quick Start
        • Implement a Custom KMS Driver
        • Process Encrypted Data with Apache Flink
        • Code examples
        • Troubleshoot
        • FAQ
      • Use Client-Side Payload Encryption
    • Advanced Security Add-on
    • Monitor Activity
      • Concepts
      • Audit Log Event Categories
      • Audit Log Event Records
      • Audit Log Event Schema
      • Auditable Event Methods
        • Access Transparency
        • Connector
        • Custom Connector Plugin
        • Endpoints
        • Flink Management and Operations
        • Flink Authentication and Authorization
        • IP Filter Authorization
        • IP Filter and IP Group Management
        • Kafka Cluster Management and Operations
        • Kafka Cluster Authentication and Authorization
        • ksqlDB Cluster Authentication and Authorization
        • Networking
        • Notifications Service
        • OAuth-OIDC Identity Provider and Identity Pool
        • Organization
        • Role-Based Access Control
        • Real-Time Context Engine
        • Schema Registry Management and Operations
        • Schema Registry Authentication and Authorization
        • SCIM
        • Tableflow Control Plane
        • Tableflow Data Plane
        • Unified Stream Manager Control Plane
      • Access and Consume Audit Logs
      • Access Transparency
      • Retain Audit Logs
      • Best Practices
      • Troubleshoot
    • Access Management Tutorial
    • Security FAQ
  • Manage Billing
    • Overview
    • Billing Dimensions
      • Overview
      • Cluster Linking
      • Connectors
      • ksqlDB
      • Flink SQL
      • Tableflow
      • Audit Logs
      • Stream Governance
      • Advanced Security Add-on
      • Real-Time Context Engine
      • Unified Stream Manager
      • Kafka Streams
    • Invoices and Costs
    • Cost Allocation
    • Multi-Org Billing
    • Marketplace Billing
      • Amazon Web Services
      • Google Cloud
      • Microsoft Azure
      • Marketplace Organization Suspension and Deactivation
    • Billing Examples
    • Troubleshoot Billing
    • FAQ
    • Legacy Billing Reference
  • Manage Service Quotas
    • Overview
    • Service Quotas
    • View Service Quotas Using Confluent CLI
    • Service Quotas API
  • APIs
    • Overview
    • Confluent Cloud API Usage and Reference
      • Overview
      • Confluent Cloud API Reference
      • Metrics API Reference
      • Admin and Produce REST API Usage
      • Connect API Usage
      • Provider Integration API Usage
      • Stream Catalog REST API Usage
      • Service Quotas API Usage
    • Kafka Client API Reference
      • Overview
      • .NET Client API Reference
      • C++ Client API Reference
      • Go Client API Reference
      • Java Client API Reference
      • JavaScript Client API Reference
      • Python Client API Reference
    • Flink Client API Usage and Reference
    • GraphQL API Usage and Reference
  • Confluent CLI
  • Release Notes & FAQ
    • Release Notes
    • FAQ
    • Upgrade Policy
    • Compliance
    • Generate a HAR file for Troubleshooting
    • AI Assistant
  • Support
  • Glossary
Give feedback about this page
On this page:
  • Prerequisites
  • Create your Azure Key Vault and key
  • Register your key with Confluent and grant access
  • Set up a private connection to your Azure Key Vault
  • Create the Schema Registry encryption key and encrypt a field
  • Lock your vault to private-only and verify
Use CSFLE with Azure Key Vault over Azure Private Link
Get started
    Home Confluent Cloud Confluent Platform Connectors Clients

    CLOUD

    • Overview
    • Get Started
      • Overview
      • Free Trial
      • Create and Manage Your Account
      • Regions and Availability
      • Quick Start: Confluent Cloud
      • Quick Start: REST API
      • Manage Schemas
      • Tutorials and Examples
        • Overview
        • Tutorial: Use Replicator to Copy Kafka Data to Cloud
        • Example: Create Fully Managed Services
      • Use Docs with AI Tools
    • Build a Streamhouse
      • Overview
      • Quick start
      • Build with a Blueprint
      • Capture and maintain your business
      • Run your business
      • Query current state
    • Query Data with Lightning Tables
      • Overview
      • Get Started
      • Manage Lightning Tables
      • Query a Lightning Table
        • Overview
        • Query with the API
        • Query with MCP
        • Query with the Confluent CLI
        • Query with JDBC
        • SQL Reference
      • Schema Evolution
      • Manage Access
      • Private Networking
      • Monitor
      • Support and Limitations
    • Use Kafka Clusters
      • Overview
      • Resilience
      • Cluster Deletion Protection
      • Multi-Tenancy and Client Quotas
        • Overview
        • Quick Start
      • Manage Clusters
        • Create a Cluster
        • View Clusters
        • Update a Cluster
        • Delete a Cluster
        • Resize a Dedicated Cluster
        • Manage Configuration Settings
      • Migrate Clusters
        • Migrate to Confluent Cloud
        • Migrate with kcp
      • Copy and Share Data
        • Cluster Linking
          • Overview
          • Quick Start
          • Configure, Manage, and Monitor
            • Configure and Manage Cluster Links
            • Manage Mirror Topics
            • Manage Private Networking
            • Manage Security
            • Monitor Metrics
          • Use Cases and Tutorials
            • Share Data Across Clusters, Regions, and Clouds
            • Disaster Recovery and Failover
              • Disaster Recovery Overview
              • Automatic Failover (Active-Passive)
              • Manual Switchover (Active-Active)
              • Manual Switchover (Active-Passive)
            • Create Hybrid Cloud and Bridge-to-Cloud Deployments
            • Use Tiered Separation of Critical Workloads
            • Migrate Data
            • Manage Audit Logs
          • Troubleshooting
        • Replicator
          • Quick Start
          • Use Replicator to Migrate Topics
      • Connect Confluent Platform and Cloud Environments
        • Overview
        • Connect Self-Managed Gateway to Cloud
          • Confluent Cloud Gateway Overview
          • Configure and Deploy
            • Overview
            • Docker Deployment
              • Deploy using Docker
              • Secure Docker Deployments
              • Troubleshoot Docker Deployments
            • CFK Deployment
              • Deploy using CFK
              • Secure CFK Deployments
          • Enforce Centralized Governance
            • Overview
            • Configure Centralized Governance
          • Migrate Kafka Clusters
          • Migrate Topics with Topic-Based Routing
          • Set up Network Isolation and Custom Domains
          • Monitor Gateway Metrics
        • Connect Self-Managed Control Center to Cloud
        • Connect Self-Managed Clients to Cloud
        • Connect Self-Managed Connect to Cloud
        • Connect Self-Managed REST Proxy to Cloud
        • Connect Self-Managed ksqlDB to Cloud
        • Connect Self-Managed MQTT to Cloud
        • Connect Self-Managed Schema Registry to Cloud
        • Connect Self-Managed Streams to Cloud
        • Example: Autogenerate Self-Managed Component Configs for Cloud
      • Automate with Infrastructure as Code
        • Create Clusters with Terraform
        • Terraform Security Best Practices
        • Create Clusters with Pulumi
      • FAQ
    • Build Client Applications
      • Overview
      • Architectural Considerations
      • Client Quick Start
      • Configure Clients
        • Consumer
        • Share Consumers
        • Producer
        • Configuration Properties
      • Test and Monitor a Client
        • Test
        • Monitor
          • Overview
          • Monitoring with JMX
          • Configure JMX
          • Producer Metrics
          • Consumer Metrics
          • Share Consumer Metrics
        • Reset Offsets
      • Optimize and Tune
        • Overview
        • Throughput
        • Latency
        • Durability
        • Availability
        • Freight
      • Client Guides
        • Python
        • .NET Client
        • JavaScript Client
        • Go Client
        • C++ Client
        • Java Client
      • Kafka Client APIs for Confluent Cloud
        • Python Client API
        • .NET Client API
        • JavaScript Client API
        • Go Client API
        • C++ Client API
        • Java Client API
      • Deprecated Client APIs
      • Client Examples
        • Overview
        • Rust Client
        • Python Client
        • .NET Client
        • JavaScript Client
        • Go Client
        • C++ Client
        • Java
        • Spring Boot
        • KafkaProducer
        • REST
        • Clojure
        • Groovy
        • Kafka Connect Datagen
        • kafkacat
        • Kotlin
        • Ruby
        • Scala
      • Confluent Plugin for JetBrains IDEs
      • VS Code Extension
      • Connect to a Kafka Cluster with VS Code
      • Browse Messages with VS Code
      • Work with Schemas in VS Code
      • Clients FAQ
    • Build Kafka Streams Applications
      • Overview
      • Quick Start
      • Metrics
      • Monitor Applications
      • FAQ
      • Upgrade Guide
      • ksqlDB
        • Create Stream Processing Apps with ksqlDB
        • Quick Start
        • Enable ksqlDB Integration with Schema Registry
        • ksqlDB Cluster API Quick Start
        • Monitor ksqlDB
        • Manage ksqlDB by using the CLI
        • Manage Connectors With ksqlDB
        • Develop ksqlDB Applications
        • SQL Reference (Confluent Platform)
        • Pull Queries
        • Grant Role-Based Access
        • Migrate ksqlDB Applications on Confluent Cloud
    • AI and ML
      • Overview
      • Build AI with Confluent Intelligence
        • Overview
        • Streaming Agents
          • Overview
          • Agent Runtime Guide
          • Call Tools
          • Create and Run Streaming Agents
          • Manage Agents in the Console
          • Reflection Workflows
          • Monitor Streaming Agents
          • Debug Streaming Agents
          • Examples
        • Real-Time Context Engine
        • Built-in AI/ML Functions
          • Overview
          • Analyze Sentiment
          • Detect Anomalies
          • Detect PII
          • Forecast Trends
          • Invoke a Tool in an AI Workflow
          • ML Preprocessing Functions
          • Model Inference Functions
        • Create Embeddings
          • Overview
          • Create Embeddings
        • Run Managed Model Inference
        • Run External Model Inference
        • Search External Tables
          • Overview
          • Key Search with External Sources
          • Text Search with External Sources
          • Vector Search with External Sources
        • FAQ
      • Use AI Tools with Confluent
        • Overview
        • Access Confluent Cloud with the Managed MCP Servers
        • Build with the Open-Source MCP Server
        • Build with Agent Skills
        • Confluent Assistant overview
        • Troubleshoot connectors with Confluent Assistant
    • Manage Topics
      • Overview
      • Configuration Reference
      • Message Browser
      • Share Streams
        • Overview
        • Provide Stream Shares
        • Consume Stream Shares
      • Tableflow
        • Overview
        • Concepts
          • Overview
          • Storage
          • Schemas
          • Materialize Change Data Capture Streams
          • Write Modes
        • Get Started
          • Overview
          • Quick Start with Managed Storage
          • Quick Start Using Your Storage and AWS Glue
          • Quick Start Using Your Storage on Google Cloud
          • Quick Start with Delta Lake Tables
        • How-to Guides
          • Overview
          • Configure Storage
          • Encrypt Sensitive Fields
          • Integrate Catalogs
            • Overview
            • Integrate with AWS Glue Catalog
            • Integrate with Lakehouse Runtime Catalog
            • Integrate with Snowflake Horizon Catalog
            • Integrate with Snowflake Open Catalog
            • Integrate with Unity Catalog
            • User-defined namespaces
          • Query Data
            • Overview
            • Query with AWS
            • Query with DuckDB
            • Query with Flink
            • Query with Snowflake
            • Query with Trino
        • Operate
          • Overview
          • Configure
          • Grant Role-Based Access
          • Monitor
          • Use Private Networking
          • Access the Tableflow Iceberg REST Catalog over AWS PrivateLink
          • Use Private Networking with Azure
      • Lightning Tables
      • FAQ
    • Manage and Monitor Resources with USM
      • Overview
      • Register Confluent Platform with USM
        • Overview
        • Set Up Payment Method
        • Configure Private Networking
          • Overview
          • AWS
          • Azure
        • Configure a Service Account
        • Deploy the USM Agent
        • Complete the Cluster Registration
      • Register Connect Cluster with USM
        • Overview
        • Confluent Platform Kafka as the Metadata Cluster
        • Confluent Cloud Kafka as the Metadata Cluster
        • Deregister a Connect Cluster
      • Monitor Confluent Platform Resources
        • Overview
        • Clusters
        • Tiered Storage
        • Topics
        • Connectors on Confluent Platform Kafka
        • Connectors on Confluent Cloud Kafka
        • Consumer Lag
        • Clients
        • Kafka Streams
        • Alerts
      • Data Governance for Confluent Platform
      • Role-Based Access Control
      • Remove the USM Agent
      • Troubleshoot
    • Govern Data Streams
      • Overview
      • Stream Governance
        • Manage Governance Packages
        • Data Portal
        • Track Data with Stream Lineage
        • Manage Stream Catalog
          • Stream Catalog User Guide
          • REST API Catalog Usage and Examples Guide
          • GraphQL API Catalog Usage and Examples Guide
      • Manage Schemas
        • Overview
        • Why |sr| is Required
        • Manage Schemas
        • Delete Schemas and Manage Storage
        • Use Broker-Side Schema ID Validation
        • Schema Linking
        • Schema Registry Tutorial
      • Fundamentals
        • Key Concepts
        • Schema Evolution and Compatibility
        • Schema Formats
          • Serializers and Deserializers Overview
          • Avro
          • Protobuf
          • JSON Schema
        • Data Contracts
        • Explicit Topic-Subject Associations
        • Security Considerations
        • Enable Private Networking
          • Enable Private Networking with Schema Registry PrivateLink
          • Enable Private Networking for Schema Registry with a Public Endpoint
      • Reference
        • Overview
        • Configure Clients
        • Schema Registry C++ Client (libschemaregistry)
        • Schema Registry Maven Plugin for Confluent Cloud
        • Example usage
        • Example usage
        • REST API Usage Examples
        • Use AsyncAPI to Describe Topics and Schemas
      • FAQ
    • Connect to External Services
      • Overview
      • Install Connectors
        • ActiveMQ Source
        • AlloyDB Sink
        • Amazon CloudWatch Logs Source
        • Amazon CloudWatch Metrics Sink
        • Amazon DocumentDB Sink
          • Configure and Launch
          • Configure with AWS Egress PrivateLink Endpoints
        • Amazon DynamoDB CDC Source
          • Configure and Launch
          • Configure with AWS Egress PrivateLink Endpoints
        • Amazon DynamoDB Sink
        • Amazon Kinesis Source
        • Amazon Redshift Sink
        • Amazon S3 Sink
          • Configure and Launch
          • Configure with AWS Egress PrivateLink Endpoints
        • Amazon S3 Source
        • Amazon SQS Source
        • AWS Lambda Sink
        • Azure Blob Storage Sink
          • Configure and Launch
          • Configure with Azure Egress Private Link Endpoints
        • Azure Blob Storage Source
        • Azure Cognitive Search Sink
        • Azure Cosmos DB Sink [Deprecated]
        • Azure Cosmos DB Sink V2
        • Azure Cosmos DB Source [Deprecated]
        • Azure Cosmos DB Source V2
        • Azure Data Explorer (Kusto) Database Sink
        • Azure Data Lake Storage Gen2 Sink
        • Azure Event Hubs Source
        • Azure Functions Sink
        • Azure Log Analytics Sink
        • Azure Log Analytics Sink V2
        • Azure Service Bus Source
        • Azure Synapse Analytics Sink
        • ChromaDB Sink
        • ClickHouse Sink
          • Configure and Launch
          • Configure with AWS Egress PrivateLink Endpoints
          • Configure with Azure Egress Private Link Endpoints
          • Configure with Google Cloud Private Service Connect Endpoints
        • Couchbase Source
          • Configure and Launch
          • Configure with AWS Egress PrivateLink Endpoints
          • Configure with Azure Egress Private Link Endpoints
          • Configure with GCP Egress Private Service Connect Endpoints
        • Couchbase Sink
          • Configure and Launch
          • Configure with AWS Egress PrivateLink Endpoints
          • Configure with Azure Egress Private Link Endpoints
          • Configure with GCP Egress Private Service Connect Endpoints
        • Databricks Delta Lake Sink
          • Set up Databricks Delta Lake (AWS) Sink Connector for Confluent Cloud
          • Configure and launch the connector
        • Datadog Metrics Sink
        • Datagen Source (development and testing)
        • DataStax Sink
        • Elasticsearch Service Sink [Deprecated]
        • Elasticsearch Service Sink V2
          • Configure and Launch
          • Configure with AWS Egress PrivateLink Endpoints
          • Configure with Google Cloud Private Service Connect Endpoints
          • Configure with Azure Egress Private Link Endpoints
        • GitHub Source
        • Google BigQuery Source (JDBC)
        • Google BigQuery Sink [End of Life]
        • Google BigQuery Sink V2
        • Google Cloud BigTable Sink
        • Google Cloud Dataproc Sink [End of Life]
        • Google Cloud Firestore Sink
        • Google Cloud Functions Gen 2 Sink
        • Google Cloud Functions Sink [End of Life]
        • Google Cloud Pub/Sub Source
        • Google Cloud Spanner CDC Source (Debezium)
        • Google Cloud Spanner Sink
        • Google Cloud Storage Sink
        • Google Cloud Storage Source
        • HTTP Sink
        • HTTP Sink V2
        • HTTP Source
        • HTTP Source V2
        • IBM Db2 Source (JDBC)
        • IBM MQ Sink
        • IBM MQ Source
        • InfluxDB 2 Sink
        • InfluxDB 2 Source
        • InfluxDB 3 Sink
        • Jira Source
        • MariaDB CDC Source (Debezium)
        • Marketo Sink
        • Microsoft Dynamics 365 CRM Source
        • Microsoft SQL Server CDC Source (Debezium) [End of Life]
        • Microsoft SQL Server CDC Source V2 (Debezium)
          • Configure and launch the connector
          • Backward incompatibility considerations
        • Microsoft SQL Server Sink (JDBC)
        • Microsoft SQL Server Source (JDBC)
        • MongoDB Atlas Sink
          • Configure and Launch
          • Configure with AWS Egress PrivateLink Endpoints
          • Configure with Azure Egress Private Link Endpoints
          • Configure with Google Cloud Egress Private Service Connect Endpoints
        • MongoDB Atlas Source
        • MongoDB CDC Source (Debezium)
          • Configure and Launch
          • Configure with AWS Egress PrivateLink Endpoints
          • Configure with Azure Egress Private Link Endpoints
          • Configure with Google Cloud Egress Private Service Connect Endpoints
          • Monitoring
        • MQTT Sink
        • MQTT Source
        • MySQL CDC Source (Debezium) [End of Life]
        • MySQL CDC Source V2 (Debezium)
          • Configure and Launch the connector
          • Backward Incompatible Changes
        • MySQL Sink (JDBC)
        • MySQL Source (JDBC)
        • Neo4j Sink
          • Configure and Launch
          • Configure with AWS Egress PrivateLink Endpoints
          • Configure with Google Cloud Private Service Connect Endpoints
        • New Relic Metrics Sink
        • OpenSearch Sink
        • Oracle XStream CDC Source
          • Overview
          • Configure and Launch the connector
          • Oracle Database Prerequisites
          • Downstream Capture
          • Cascading Downstream Capture
          • Change Events
          • Signals and Actions
          • Examples
          • Troubleshooting
          • Monitoring
        • Oracle CDC Source
          • Overview
          • Configure and Launch the connector
          • Horizontal Scaling
          • Oracle Database Prerequisites
          • SMT Examples
          • DDL Changes
          • Troubleshooting
        • Oracle Database Sink (JDBC)
        • Oracle Database Source (JDBC)
        • PagerDuty Sink [End of Life]
        • Pinecone Sink
        • PostgreSQL CDC Source (Debezium) [End of Life]
        • PostgreSQL CDC Source V2 (Debezium)
          • Configure and Launch the connector
          • Backward Incompatible Changes
        • PostgreSQL Sink (JDBC)
        • PostgreSQL Source (JDBC)
        • RabbitMQ Sink
        • RabbitMQ Source
        • Redis Sink [Deprecated]
        • Redis Kafka Sink
        • Redis Kafka Source
        • Salesforce Bulk API 2.0 Sink
        • Salesforce Bulk API 2.0 Source
        • Salesforce Bulk API Source
        • Salesforce CDC Source
        • Salesforce Platform Event Sink
        • Salesforce Platform Event Source
        • Salesforce PushTopic Source
        • Salesforce SObject Sink
        • Salesforce Source V2
        • ServiceNow Sink
        • ServiceNow Source (Legacy) [Deprecated]
        • ServiceNow Source V2
        • SFTP Sink
        • SFTP Source
        • Snowflake Sink
          • Configure and Launch
          • Configure with AWS Egress PrivateLink Endpoints
          • Configure with Azure Egress Private Link Endpoints
          • Configure with Google Cloud Private Service Connect Endpoints
        • Snowflake Source
          • Configure and Launch
          • Configure with AWS Egress PrivateLink Endpoints
          • Configure with Azure Egress Private Link Endpoints
          • Configure with Google Cloud Private Service Connect Endpoints
        • Solace Sink
        • Solace Source
        • Splunk Sink
        • Stripe Source
          • Configure and Launch
          • Record Schemas
        • Webhook Source
        • Zendesk Source
      • Self-Managed Connectors on Confluent Cloud
        • Overview
      • Confluent Marketplace
        • Overview
        • Component Archive Specification
        • Contribute
      • Install Custom Plugins and Custom Connectors
        • Overview
        • Quick Start
        • Manage Custom Connectors
        • Limitations and Support
        • API and CLI
      • Manage Client-Side Encryption
      • Manage Provider Integration
      • Secret Manager Integration
        • Overview
        • Azure Key Vault Integration
        • AWS Secrets Manager Integration
        • Google Cloud Secret Manager Integration
      • Back Up and Restore Data with Object Storage Connectors
      • Networking and DNS
        • Overview
        • AWS Egress PrivateLink Endpoints for First-Party Services
        • AWS Egress PrivateLink Endpoints for Self-Managed Services
        • AWS Egress PrivateLink Endpoints for Amazon RDS
        • AWS Egress PrivateLink Endpoints for Amazon DocumentDB
        • Azure Egress Private Link Endpoints for First-Party Services
        • Azure Egress Private Link Endpoints for Self-Managed Services
        • Google Cloud Private Service Connect Endpoints for First-Party Services
        • Google Cloud Private Service Connect Endpoints for Self-Managed Services
      • Connect API Usage
      • Manage Public Egress IP Addresses
      • Sample Connector Output
      • Configure Single Message Transformations
      • Configure Custom SMTs
        • Quick Start
        • Manage Custom SMT APIs
        • Enable External Network Calls
        • Limitations and Support
      • View Connector Events
      • Interpret Connector Statuses
      • Manage Service Accounts
      • Configure RBAC
      • View Errors in the Dead Letter Queue
      • Connector Limits
      • Manage Offsets
      • Migrate Self-Managed Connectors
      • Transforms List
        • Overview
        • AdjustPrecisionAndScale
        • BytesToString
        • Cast
        • ChangeTopicCase
        • Drop
        • DropHeaders
        • EventRouter
        • ExtractChangedRecordState
        • ExtractField
        • ExtractNestedField
        • ExtractNewRecordState
        • ExtractTimeStamp
        • ExtractTopic
        • Filter (Kafka)
        • Filter (Confluent)
        • Flatten (Kafka)
        • Flatten (Confluent)
        • HeaderFrom
        • HeaderToValue
        • HoistField
        • InsertField
        • InsertHeader
        • KeyToValue
        • MaskField
        • MessageTimestampRouter
        • ReplaceField (Kafka)
        • ReplaceField (Confluent)
        • SetMaximumPrecision
        • SetSchemaMetadata
        • TimestampConverter
        • TimestampNow
        • TimestampNowField
        • TimestampRouter
        • TimescaleDB
        • TimezoneConverter
        • ToLogicalTopicRouter
        • TombstoneHandler
        • TopicRegexRouter
        • ValueToKey
      • Reference
        • Additional Connector Configuration
        • Confluent AI-Assisted Troubleshooting
    • Integrate with Confluent Cloud
      • Overview
      • Connect with Confluent Program
      • Reuse Connections with External Services
        • Overview
        • Supported External Services
        • Manage Connections
      • Integrate with Cloud Service Providers
        • Overview
        • Create an AWS Provider Integration
        • Create an Azure Provider Integration
        • Create a Google Cloud Provider Integration
        • Manage a Provider Integration
    • Process Data with Flink
      • Overview
      • Get Started
        • Overview
        • Quick Start with Cloud Console
        • Quick Start with SQL Shell in Confluent CLI
        • Quick Start with Java Table API
        • Quick Start with Python Table API
      • Concepts
        • Overview
        • Autopilot
        • Batch and Stream Processing
        • Comparison with Apache Flink
        • Compute Pools
        • Delivery Guarantees and Latency
        • Determinism
        • External Tables
        • Materialized Tables
        • Private Networking
        • Process Table Functions
        • Schema and Statement Evolution
        • Security Controls
        • Snapshot Queries
        • Statements
        • Statement CFU Metrics
        • Tables and Topics
        • Time and Watermarks
        • User-defined Functions
      • How-To Guides
        • Overview
        • Aggregate a Stream in a Tumbling Window
        • Combine Streams and Track Most Recent Records
        • Compare Current and Previous Values in a Stream
        • Configure a Dead Letter Queue
        • Convert the Serialization Format of a Topic
        • Create a Process Table Function
        • Create a UDF
        • Deduplicate Rows in a Table
        • Deploy a Statement with CI/CD
        • Enrich a Stream with Reference Data
        • Evolve a Streaming Pipeline
        • Generate Custom Sample Data
        • Handle Late-Arriving Data
        • Handle Multiple Event Types
        • Log Debug Messages in UDFs
        • Mask Fields in a Table
        • Move a Statement to a Different Compute Pool
        • Read and Write Custom Changelog Formats
        • Read Records without a Schema ID Prefix
        • Profile a Query
        • Resolve Statement Issues
        • Scan and Summarize Tables
        • Run a Snapshot Query
        • Set a Baseline CFU for a Statement
        • Transform a Topic
        • Use Client-Side Field Level Encryption
        • View Schema Metadata in the Catalog Browser
        • View Time Series Data
      • Operate and Deploy
        • Overview
        • Carry-over Offsets
        • Connect with JDBC
        • Deploy with dbt
        • dbt Adapter Reference
        • Deploy Table API Programs
        • Development Lifecycle
        • Enable Private Networking
        • Generate a Flink API Key
        • Grant Role-Based Access
        • Manage Compute Pools
        • Manage Connections
        • Manage with Terraform
        • Monitor and Manage Statements
        • Move SQL Statements to Production
        • Use the Query Profiler
        • REST API
      • Flink Reference
        • Overview
        • SQL Syntax
        • DDL Statements
          • Statements Overview
          • ALTER AGENT
          • ALTER CONNECTION
          • ALTER MODEL
          • ALTER MATERIALIZED TABLE
          • ALTER TABLE
          • ALTER TOOL
          • ALTER VIEW
          • CREATE AGENT
          • CREATE CONNECTION
          • CREATE FUNCTION
          • CREATE MATERIALIZED TABLE
          • CREATE MODEL
          • CREATE OR ALTER MATERIALIZED TABLE
          • CREATE TABLE
          • CREATE TOOL
          • CREATE VIEW
          • DESCRIBE
          • DROP AGENT
          • DROP CONNECTION
          • DROP FUNCTION
          • DROP MATERIALIZED TABLE
          • DROP MODEL
          • DROP TABLE
          • DROP TOOL
          • DROP VIEW
          • EXPLAIN
          • RESET
          • SET
          • SHOW
          • USE CATALOG
          • USE database_name
        • Queries
          • Queries Overview
          • Deduplication
          • Group Aggregation
          • HINTS
          • INSERT INTO FROM SELECT
          • INSERT VALUES
          • Joins
          • LIMIT
          • Pattern Recognition
          • ORDER BY
          • OVER Aggregation
          • SELECT
          • Set Logic
          • EXECUTE STATEMENT SET
          • Top-N
          • Window Aggregation
          • Window Deduplication
          • Window Join
          • Window Top-N
          • Window Table-Valued Function
          • WITH
        • Functions
          • AI Model Inference
          • Aggregate
          • Changelog Conversion
          • Collections
          • Comparison
          • Conditional
          • Datetime
          • Flink SQL Functions
          • Hashing
          • JSON
          • ML Preprocessing
          • Numeric
          • Search
          • String
          • Table API
        • Data Types
        • Data Type Mappings
        • Time Zone
        • Keywords
        • Information Schema
        • Example Streams
        • SQL Examples
        • Table API
        • CLI Reference
      • Get Help
      • FAQ
    • Manage Networking
      • Confluent Cloud Networking Overview
      • Networking on AWS
        • AWS Networking Overview
        • Public Networking on AWS
        • Confluent Cloud Network on AWS
        • PrivateLink on AWS
          • PrivateLink Overview
          • Inbound PrivateLink for Dedicated Clusters
          • Inbound PrivateLink for Serverless Products
          • Outbound PrivateLink for Dedicated Clusters
          • Outbound PrivateLink for Serverless Products
        • VPC Peering on AWS
        • Transit Gateway on AWS
        • Private Network Interface on AWS
        • DNS Forwarding on AWS
      • Networking on Azure
        • Azure Networking Overview
        • Public Networking on Azure
        • Confluent Cloud Network on Azure
        • Private Link on Azure
          • Private Link Overview
          • Inbound Private Link for Dedicated Clusters
          • Inbound Private Link for Serverless Products
          • Outbound Private Link for Dedicated Clusters
          • Outbound Private Link for Serverless Products
        • VNet Peering on Azure
      • Networking on Google Cloud
        • Google Cloud Networking Overview
        • Public Networking on Google Cloud
        • Confluent Cloud Network on Google Cloud
        • Private Service Connect on Google Cloud
          • Private Service Connect Overview
          • Inbound Private Service Connect for Dedicated Clusters
          • Inbound Private Service Connect for Serverless Products
          • Outbound Private Service Connect for Dedicated Clusters
        • VPC Peering on Google Cloud
      • Connectivity for Confluent Resources
        • Overview
        • Public Egress IP Address for Connectors and Cluster Linking
        • Cluster Linking using AWS PrivateLink
        • Follower Fetching using AWS VPC Peering
      • Use the Confluent Cloud Console with Private Networking
      • Test Connectivity
      • Networking FAQ
    • Log and Monitor
      • Overview
      • Metrics
      • Integrate Third-Party Monitoring Tools
      • Manage Notifications
      • Monitor Consumer Lag
      • Monitor Dedicated Clusters
        • Manage Performance and Expansion
        • Track Usage by Team
      • Export Logs to Third-Party Tools
      • Tutorials and Examples
        • Run Example Queries
        • Observability for Kafka Clients
      • FAQ
    • Manage Security
      • Overview
      • Manage Authentication
        • Overview
        • Manage User Identities
          • Overview
          • Manage User Accounts
            • Overview
            • Authentication Security Protections
            • Manage Local User Accounts
            • Multi-factor Authentication
            • Manage SSO User Accounts
          • Manage User Identity Providers
            • Overview
            • Use Single Sign-On (SSO)
            • Manage SAML Single Sign-On (SSO)
            • Manage Azure Marketplace SSO
            • Just-in-time User Provisioning
            • SCIM User Provisioning
            • Group Mapping
              • Overview
              • Enable Group Mapping
              • Manage Group Mappings
              • Troubleshooting
              • Best Practices
            • Manage Trusted Domains
            • Manage SSO provider
            • Troubleshoot SSO
        • Manage Workload Identities
          • Overview
          • Manage Workload Identities
          • Manage Service Accounts and API Keys
            • Overview
            • Create Service Accounts
            • Manage Service Accounts
            • Manage API Keys
              • Overview
              • Manage API keys
              • Best Practices
              • Troubleshoot
          • Manage OAuth/OIDC Identity Providers
            • Overview
            • Add an OIDC Identity Provider
            • Use OAuth Identity Pools and Filters
            • Manage Identity Provider Configurations
            • Manage the JWKS URI
            • Configure OAuth Clients
              • Overview
              • Go Clients
              • Java Clients
              • JavaScript Clients
              • .NET Clients
              • Python Clients
              • Configuration Reference
              • Configure UAMI
              • Configure AWS IAM Java Client Plugin
              • Configure AWS IAM Python Client Plugin
              • Configure AWS IAM .NET Client Plugin
            • Access Kafka REST APIs
            • Use Confluent STS Tokens with REST APIs
            • Best Practices
            • Troubleshoot OAuth Issues
          • Manage mTLS Identity Providers
            • Overview
            • Configure mTLS
            • Manage Certificate Authorities
            • Manage Certificate Identity Pools
            • Create CEL Filters for mTLS
            • Create JSON payloads for mTLS
            • Manage Certificate Revocation
            • Troubleshoot mTLS Issues
        • Identity FAQ
      • Control Access
        • Overview
        • Resource Hierarchy
          • Overview
          • Organizations
            • Overview
            • Manage Multiple Organizations
          • Environments
          • Confluent Resource Names (CRNs)
        • Manage Role-Based Access Control
          • Overview
          • Predefined RBAC Roles
          • Manage Role Bindings
          • Use ACLs with RBAC
        • Manage IP Filtering
          • Overview
          • Manage IP Groups
          • Manage IP Filters
          • Best Practices
        • Manage Access Control Lists
          • Overview
          • Operations
          • Examples
          • Troubleshoot
          • Reference
        • Use the Confluent CLI with multiple credentials on Confluent Cloud
      • Encrypt and Protect Data
        • Overview
        • Manage Data in Transit With TLS
        • Use Self-Managed Encryption Keys
          • Overview
          • Use Self-Managed Encryption Keys on AWS
          • Use Self-Managed Encryption Keys on Azure
          • Use Self-Managed Encryption Keys on Google Cloud
          • Use Self-Managed Encryption Keys with Tableflow
          • Use Confluent CLI for Self-Managed Encryption Keys
          • Use BYOK API for Self-Managed Encryption Keys
          • Revoke Access to Data at Rest
          • Best Practices
          • Troubleshoot Key Policy Issues
        • Use Client-Side Field Level Encryption
          • Overview
          • Manage CSFLE using Confluent Cloud Console
          • Use Client-side Field Level Encryption
          • Configuration Settings
          • Manage Encryption Keys
          • Use CSFLE with Azure Key Vault over Azure Private Link
          • Manage Multiple Encryption Rules
          • Quick Start
          • Implement a Custom KMS Driver
          • Process Encrypted Data with Apache Flink
          • Code examples
          • Troubleshoot
          • FAQ
        • Use Client-Side Payload Encryption
      • Advanced Security Add-on
      • Monitor Activity
        • Concepts
        • Audit Log Event Categories
        • Audit Log Event Records
        • Audit Log Event Schema
        • Auditable Event Methods
          • Access Transparency
          • Connector
          • Custom Connector Plugin
          • Endpoints
          • Flink Management and Operations
          • Flink Authentication and Authorization
          • IP Filter Authorization
          • IP Filter and IP Group Management
          • Kafka Cluster Management and Operations
          • Kafka Cluster Authentication and Authorization
          • ksqlDB Cluster Authentication and Authorization
          • Networking
          • Notifications Service
          • OAuth-OIDC Identity Provider and Identity Pool
          • Organization
          • Role-Based Access Control
          • Real-Time Context Engine
          • Schema Registry Management and Operations
          • Schema Registry Authentication and Authorization
          • SCIM
          • Tableflow Control Plane
          • Tableflow Data Plane
          • Unified Stream Manager Control Plane
        • Access and Consume Audit Logs
        • Access Transparency
        • Retain Audit Logs
        • Best Practices
        • Troubleshoot
      • Access Management Tutorial
      • Security FAQ
    • Manage Billing
      • Overview
      • Billing Dimensions
        • Overview
        • Cluster Linking
        • Connectors
        • ksqlDB
        • Flink SQL
        • Tableflow
        • Audit Logs
        • Stream Governance
        • Advanced Security Add-on
        • Real-Time Context Engine
        • Unified Stream Manager
        • Kafka Streams
      • Invoices and Costs
      • Cost Allocation
      • Multi-Org Billing
      • Marketplace Billing
        • Amazon Web Services
        • Google Cloud
        • Microsoft Azure
        • Marketplace Organization Suspension and Deactivation
      • Billing Examples
      • Troubleshoot Billing
      • FAQ
      • Legacy Billing Reference
    • Manage Service Quotas
      • Overview
      • Service Quotas
      • View Service Quotas Using Confluent CLI
      • Service Quotas API
    • APIs
      • Overview
      • Confluent Cloud API Usage and Reference
        • Overview
        • Confluent Cloud API Reference
        • Metrics API Reference
        • Admin and Produce REST API Usage
        • Connect API Usage
        • Provider Integration API Usage
        • Stream Catalog REST API Usage
        • Service Quotas API Usage
      • Kafka Client API Reference
        • Overview
        • .NET Client API Reference
        • C++ Client API Reference
        • Go Client API Reference
        • Java Client API Reference
        • JavaScript Client API Reference
        • Python Client API Reference
      • Flink Client API Usage and Reference
      • GraphQL API Usage and Reference
    • Confluent CLI
    • Release Notes & FAQ
      • Release Notes
      • FAQ
      • Upgrade Policy
      • Compliance
      • Generate a HAR file for Troubleshooting
      • AI Assistant
    • Support
    • Glossary