<a id="connect-w-confluent"></a>

# Connect with Confluent for Confluent Cloud

This topic provides information for Confluent partners participating in the
Connect with Confluent (CwC) program. If you would like to be a
Confluent partner, get started by visiting the [Confluent Partner Portal](https://partners.confluent.io/) and signing up.

The CwC program gives your application direct access to Confluent Cloud,
the cloud-native and complete data streaming platform that processes more than
an exabyte of data per year. When you join and integrate with Confluent, you
become a part of the largest data streaming network—making it easier for your
customers to access and use real-time data streams to drive more consumption for
your business. Together with guidance from Confluent’s Apache Kafka® experts, you’ll
build your data streams integration and verify it for scaled use across your
entire customer base.

Confluent partners can build and manage a
[verified integration](#cwc-verified-integration-standards) to Confluent.
Verified integrations are listed in our Connect with Confluent directory, and can be added to
Confluent Marketplace if they provide a direct download or link to the Confluent-branded
integration.

You can submit several types of integration into the program:

- Client API integrations
- Connectors which can be deployed across all relevant Confluent product
  options: Confluent Platform, Self Host and Custom Connect (but where Custom Connect is
  not applicable, this requirement will be waived).

If you have other questions, contact us at [integrationonboarding@confluent.io](mailto:integrationonboarding@confluent.io)

<a id="cwc-client-integrations"></a>

## Client API integrations

Client API integrations (also known as native integrations) can customize the end-user experience using multiple
configuration options, including any of the client configurations available to
Confluent clients and applications. This allows partners to further tailor a
data streaming experience to their specific requirements.

For a list of partner integrations, see [Partner integration directory](#connect-w-confluent-native-integrations).

Native integrations simplify connecting to Confluent Cloud from a partner’s native
platform. You can implement this in a couple of ways:

* **New Organization**: Develop an integration that creates a new Confluent Cloud
  organization and adds your customer.
* **Existing Organization:** Launch the customer into an existing Confluent Cloud
  organization.

These types of integrations must include the following specifics:

* The native partner platform UI provides the end-user experience
* Integrates Confluent Cloud authentication
* Unlocks Schema Registry and Stream Governance capabilities in Confluent Cloud
* Includes Confluent Cloud APIs to manage topics, configurations, and other details
* Integrates producer and consumer clients
* Integrates Confluent Cloud topics

## What great integrations look like

The most effective CwC integrations collect the necessary information from
users as simply as possible. The integration should guide the user through how
to obtain that information in Confluent Cloud.

The following information is typically collected though the UI:

* Confluent Cloud cluster bootstrap server address
* Confluent Cloud authentication details
* Confluent Cloud topics to produce to or consume from
* Schema Registry connection details

The following sample app mockup captures the typical user experience.

1. Click the Confluent tile.
   ![Connect with Confluent](images/ccloud-cwc-sample-tile.png)
2. Provide the Kafka connection details.
   ![Provide connection details](images/ccloud-cwc-sample-tile-details.png)
3. Select a Kafka topic.
   ![Provide a topic](images/ccloud-cwc-sample-tile-topic.png)
4. Integrate the Schema Registry service.
   ![Provide connection details](images/ccloud-cwc-sample-tile-schema-registry.png)

## Native integration basics

Refer to the following information to understand what development tasks are
required to configure an integration.

### Integration authentication

Security and authentication are critical aspects of a CwC integration. To
connect to a customer’s Confluent Cloud environment, the integration must prompt the
end-user (customer) to provide authentication credentials. It is important that
the integration’s authentication to Confluent Cloud is thoughtfully designed to require
the least permissions necessary to enable all features and ensure the customer’s
environment remains secure at all times. Typically, there are two options for an
integration to authenticate to Confluent Cloud:

* [API keys](#connect-w-confluent-api-keys)
* [OAuth](#connect-w-confluent-oauth) (recommended)

<a id="connect-w-confluent-api-keys"></a>

#### API keys

Confluent Cloud API keys can be used to control access to Confluent Cloud components and
resources. Each API key consists of a key and a secret. Confluent recommends
users set [Use API Keys to Authenticate to Confluent Cloud](../security/authenticate/workload-identities/service-accounts/api-keys/overview.md#cloud-api-key-resource).

How keys and secrets are stored is important. Do not store keys and secrets in
plain text. A recommended practice is to dynamically inject secrets when
connecting to Confluent Cloud using a secrets vault. For
additional information, see [Best Practices for Using API Keys on Confluent Cloud](../security/authenticate/workload-identities/service-accounts/api-keys/best-practices-api-keys.md#api-keys-best-practices).

<a id="connect-w-confluent-oauth"></a>

#### OAuth

[Use OAuth/OIDC to Authenticate to Confluent Cloud](../security/authenticate/workload-identities/identity-providers/oauth/overview.md#oauth-overview) supports short-lived credentials for an integration to
authenticate with Confluent Cloud resources. OAuth 2.0 is an open-standard protocol
that grants access to supported clients using a temporary access token.
Supported clients use delegated authorization to attach and use Confluent Cloud
resources and data on behalf of a user or application. It is important to be
aware of OAuth limitations, notably usage limitations for cluster types and
clients. For more information, see [Limitations](../security/authenticate/workload-identities/identity-providers/oauth/overview.md#oauth-limitations). For more
information about authenticating to Confluent Cloud, see
[Security Protections for Authentication on Confluent Cloud](../security/authenticate/user-identities/user-accounts/authentication-protections.md#authentication-protections).

### End-user service account authentication

Confluent customers (end-users) in a production environment should use a
dedicated service account. While a user account can be used for authentication,
your integration should encourage authentication using a service account. Users
can leave or change roles within a company (or user access may be revoked or
changed) which results in an integration failure and loss of production time.

A partner integration does not know what RBAC roles and permissions are assigned
for an authenticated service account. If the service account used for
authentication has insufficient permissions, the partner integration should
provide actionable error information so the Confluent customer knows what to do.
Ideally, your integration should recommend proper roles or permissions that must
be granted to the associated account.

At a *minimum*, the service account should have at least one of the following
roles assigned to read, consume, write, and produce to Confluent Cloud. For a complete
list of roles, see [Predefined RBAC Roles in Confluent Cloud](../security/access-control/rbac/predefined-rbac-roles.md#cloud-rbac-roles).

| Role           | Scope                    | Description                                                                                                                                                |
|----------------|--------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------|
| DeveloperRead  | Topic and Consumer Group | To read and consume data from a Confluent Cloud topic, the service account must have at least the `DeveloperRead` role for the topic and a consumer group. |
| DeveloperWrite | Topic                    | To write and produce data to a Confluent Cloud topic, the service account must have at least the `DeveloperWrite` role for the topic.                      |

If the integration has advanced features, additional roles may need to be
assigned. For example, if an integration needs to create a topic to support a
dead letter queue or for a new data stream, the integration may require the
ability to create a new topic. In this case, the service account must have the
`DeveloperManage` assigned role. For a complete list of roles, see
[Predefined RBAC Roles in Confluent Cloud](../security/access-control/rbac/predefined-rbac-roles.md#cloud-rbac-roles).

### Schema Registry and Stream Governance

[Stream Governance on Confluent Cloud](../stream-governance/index.md#cloud-dg) establishes trust in the data streams moving throughout your
cloud environments and delivers an easy, self-service experience for more teams
to put streaming data pipelines to work. CwC integrations are expected to
connect to and use [Schema Registry](../sr/overview.md#schemas-overview) in order to fully
unlock the capabilities of Stream Governance in Confluent Cloud.

At a minimum, this includes support for using Schema Registry with at least Avro
schemas, preferably any schema supported by Confluent Cloud. Integrations are
encouraged to provide support for the [Confluent Stream Catalog](../stream-governance/stream-catalog.md#cloud-stream-catalog), including tags and business metadata.

### Confluent Cloud APIs

Basic integrations may simply connect to an existing topic and leverage existing
schemas, but more feature-rich integrations may need to create and manage topics
and schemas within Confluent Cloud.

For example, if an integration is connecting to Confluent Cloud to send data, it may be
best for the integration to create and customize the target topic without
requiring the user to do it separately. This creates a more seamless experience
for the user and reduces the application switching to set up the integration.

For [CRUD](../_glossary.md#term-CRUD) actions like this, you can leverage the Admin APIs within the
Confluent Cloud Cluster or the REST API. For additional information, see
[Confluent Cloud APIs](https://docs.confluent.io/cloud/current/api.html).

In a CwC integration, the integrated partner application is sending
(producing) data to Confluent Cloud or reading (consuming) data from Confluent Cloud. To
create this type of integration, the application uses Produce or Consume APIs
with Confluent Cloud. For more information about setting up Producers and
Consumers and other Kafka basics, see the [related content](#connect-w-confluent-related-content).

### Custom identifier

As part of your Confluent Cloud integration, additional custom configuration
options are used help identify the integration. These custom configurations will
be shared with you by your Partner Success Manager as part of the verification
process. Typically, this involves a `client.id` prefix. Note that these additional
configurations are unique identifiers to your CwC integration and are solely
used to measure the adoption of the integration.

## Verify an integration

When your integration with Confluent Cloud is built, the next step is to have it
verified by Confluent. This verification ensures that your integration meets the
security and governance expectations of any Confluent verified integration. To
verify your integration, contact your Partner Success Manager or [verification@confluent.io](mailto:verification@confluent.io)
or apply as a new
partner today using the [Confluent Partner Portal](https://partners.confluent.io/).

<a id="cwc-verified-integration-standards"></a>

### Verified integration standards

The term *verified integration* is only currently available to approved Confluent Partners, and aims to give
end-users confidence in the build quality, and the ease of deployment across Confluent product
options (where applicable). The Confluent Marketplace terms of use still apply.

The checks made for verified integration are carried out at the time of testing and include:

- The integration comes from a registered Confluent Partner.
- The integration functioned from a user-perspective, at the time of testing, across applicable Confluent product options.
- The integration provided suitable documentation for users.
- The integration provided an appropriate license (open source, or non-conflicting third party proprietary).
- The integration demonstrated adherence to essential best- practice standards, where relevant to the integration type.

Some key sample standards for connector-type integrations are shown below:

| Best practice standards                                                                                                                                                                                        | Confluent documentation reference                                                                                                                                                               |
|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| With regard to secrets management, credentials are stored securely and in line with best operational practices. Such management should employ a dedicated solution such as Vault, Secret Manager or Key Vault. | [Kafka Connect Security Basics | Confluent Documentation](https://docs.confluent.io/platform/current/connect/security.html#externalize-secrets)                                                 |
| The client configuration can be set up using resource scoped API Keys and Secrets from Confluent Cloud to ensure “principle of least privilege”                                                                | [Use API Keys to Control Access in Confluent Cloud](https://docs.confluent.io/cloud/current/access-management/authenticate/api-keys/api-keys.html#use-api-keys-to-control-access-in-ccloud)     |
| If source integration (using producer API) there is a record key.                                                                                                                                              | [Kafka Producer | Confluent Documentation](https://docs.confluent.io/platform/current/clients/producer.html)                                                                                    |
| Data discovery is simple (the user is presented with a list of topics or entities)                                                                                                                             | [Confluent Cloud API Reference Documentation](https://docs.confluent.io/cloud/current/ccloud/list-kafka-topics/)                                                                                |
| Public Endpoint Support exists                                                                                                                                                                                 | [Networking on Confluent Cloud](https://docs.confluent.io/cloud/current/networking/overview.html#public-networking-solutions)                                                                   |
| Where applicable, schema registry is supported                                                                                                                                                                 | [Schema Registry Overview | Confluent Documentation](https://docs.confluent.io/platform/current/schema-registry/index.html)                                                                     |
| Documentation provides information on the Kafka Client Library version used                                                                                                                                    | [Custom Connectors Limitations and Support](https://docs.confluent.io/cloud/current/connectors/bring-your-connector/custom-connector-fands.html)                                                |
| Documentation is clear on the supported data types (JSON, AVRO, Protobuf)                                                                                                                                      | [Kafka Streams Data Types and Serialization | Confluent Documentation](https://docs.confluent.io/platform/current/streams/developer-guide/datatypes.html#kstreams-data-types-and-serialization) |
| Custom Connect deployment effectively manages any required sensitive properties and secrets                                                                                                                    | [Manage Custom Connectors for Confluent Cloud](https://docs.confluent.io/cloud/current/connectors/bring-your-connector/custom-connector-manage.html#modify-a-custom-connector-configuration)    |
| The connector supports logging practices and ability to set logging levels                                                                                                                                     | [Kafka Connect Logging | Confluent Documentation](https://docs.confluent.io/platform/current/connect/logging.html)                                                                              |
| Documentation provides information on the Confluent platform supported versions\*                                                                                                                              | [Supported Versions and Interoperability for Confluent Platform](https://docs.confluent.io/platform/current/installation/versions-interoperability.html)                                        |
| Provides sample connector configuration for use by Kafka Connect                                                                                                                                               | [Connect REST Interface | Confluent Documentation](https://docs.confluent.io/platform/current/connect/references/restapi.html#kconnect-rest-interface)                                          |
| Connect configuration can be submitted through an API call                                                                                                                                                     | [Connect REST Interface | Confluent Documentation](https://docs.confluent.io/platform/current/connect/references/restapi.html#kconnect-rest-interface)                                          |
| Documentation provides information on the Java version required                                                                                                                                                | [Supported Versions and Interoperability for Confluent Platform](https://docs.confluent.io/platform/current/installation/versions-interoperability.html#java)                                   |
| Documentation provides information about whether the connector supports single worker or multiple worker nodes                                                                                                 | [Kafka Connect | Confluent Documentation](https://docs.confluent.io/platform/current/connect/concepts.html#workers)                                                                             |
| Works with CP Standalone and CP multiple nodes                                                                                                                                                                 | [How to Use Kafka Connect - Get Started | Confluent Documentation](https://docs.confluent.io/kafka-connectors/self-managed/userguide.html#standalone-vs-distributed-mode)                       |
| Supports SSL/SASL communication and ACL (Secure communication between worker nodes and the application)                                                                                                        | [Encrypt and authenticate Confluent Platform and resources with TLS](https://docs.confluent.io/platform/current/kafka/authentication_ssl.html)                                                  |
| Documentation provides a sample (connector) configuration for use by Custom Connect API                                                                                                                        | [Custom Connector API and CLI for Confluent Cloud](https://docs.confluent.io/cloud/current/connectors/bring-your-connector/custom-connector-cli.html#custom-connector-api)                      |
| Provides a list of sensitive properties to set on connector setup                                                                                                                                              | [Custom Connector for Confluent Cloud Quick Start](https://docs.confluent.io/cloud/current/connectors/bring-your-connector/custom-connector-qs.html#upload-the-connector-archive)               |
| Provides a list of required endpoints to an allowlist so that Custom Connector will function correctly                                                                                                         | [Manage Custom Connectors for Confluent Cloud](https://docs.confluent.io/cloud/current/connectors/bring-your-connector/custom-connector-manage.html#update-networking-endpoints)                |
| The connector has a “Fail Fast & Abort” strategy                                                                                                                                                               | [Kafka Connect Deep Dive – Error Handling and Dead Letter Queues | Confluent](https://www.confluent.io/en-gb/blog/kafka-connect-deep-dive-error-handling-dead-letter-queues/)                   |

## Publish an integration

After your native CwC integration is verified by Confluent, work with your
Partner Success Manager to promote the integration and increase its visibility.
Your Partner Success Manager will guide you through the options that both you
and Confluent can do to support amplifying the integration.

<a id="connect-w-confluent-native-integrations"></a>

## Partner integration directory

The following table lists available native partner integrations available for CwC.

| Partner                                                                                                                                          | Category                            | Documentation                                                                                                                                                                              |
|--------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| [Advantco](https://www.advantco.com/sap-integration-adapters/confluent-cloud-integration)                                                        | SAP and Oracle integrator           | [SAP Kafka Integration: Real-time Data Flow for Business Agility](https://www.advantco.com/sap-integration-adapters/sap-kafka-integration)                                                 |
| [Aklivity](https://www.aklivity.io/partners/confluent)                                                                                           | Streaming-native API infrastructure | [Confluent Cloud Secure Public Access Proxy](https://docs.aklivity.io/zilla/latest/solutions/how-tos/confluent-cloud/secure-public-access.html)                                            |
| [Amazon Athena](https://aws.amazon.com/athena/)                                                                                                  | Analytics                           | [Amazon Athena Apache Kafka connector](https://docs.aws.amazon.com/athena/latest/ug/connectors-kafka.html)                                                                                 |
| [Amazon EventBridge](https://aws.amazon.com/eventbridge/)                                                                                        | Analytics                           | [Amazon Athena Apache Kafka connector](https://docs.aws.amazon.com/athena/latest/ug/connectors-kafka.html)                                                                                 |
| [AWS Lambda](https://aws.amazon.com/lambda/)                                                                                                     | Serverless compute                  | [Using Lambda with self-managed Apache Kafka](https://docs.aws.amazon.com/lambda/latest/dg/with-kafka.html)                                                                                |
| [Arcion](https://www.arcion.io/)                                                                                                                 | CDC                                 | [Destination Confluent](https://docs.arcion.io/docs/target-setup/confluent/)                                                                                                               |
| [Arroyo](https://www.arroyo.dev/integrations/confluent)                                                                                          | Stream processing                   | [Confluent - Arroyo Documentation](https://doc.arroyo.dev/connectors/confluent)                                                                                                            |
| [Asapio](https://asapio.com/confluent/)                                                                                                          | SAP integrator                      | [Confluent Integration](https://asapio.com/confluent/)                                                                                                                                     |
| [Bicycle](https://bicycle.io/partners/confluent)                                                                                                 | Analytics                           | -                                                                                                                                                                                          |
| [Census  Reverse](https://www.getcensus.com/integrations/confluent-cloud)                                                                        | ETL                                 | [Confluent Cloud | Census Docs](https://docs.getcensus.com/sources/available-sources/confluent-cloud)                                                                                      |
| [Clickhouse](https://clickhouse.com/)                                                                                                            | Analytics                           | [Integrating Kafka with ClickHouse](https://clickhouse.com/docs/en/integrations/kafka)                                                                                                     |
| [Couchbase](https://www.couchbase.com/partners/confluent/)                                                                                       | Operational database                | -                                                                                                                                                                                          |
| [Cockroach Labs](https://www.cockroachlabs.com/blog/232-confluent-integration/)                                                                  | Operational database                | -                                                                                                                                                                                          |
| [Datorios](https://datorios.com/data-processing-for-confluent/)                                                                                  | Data pipelines                      | [Confluent Cloud](https://public.docs.datorios.com/docs/connectors/sources/confluent-cloud/)                                                                                               |
| [Decodable](https://www.decodable.co/connectors/confluent-cloud)                                                                                 | Stream processing                   | [Confluent Cloud](https://docs.decodable.co/docs/confluent-cloud)                                                                                                                          |
| [Deltastream](https://www.deltastream.io/partners/confluent/)                                                                                    | Stream processing                   | -                                                                                                                                                                                          |
| [EMQ](https://www.emqx.com/en/solutions/technology/mqtt-to-confluent)                                                                            | MQTT                                | [Stream MQTT Data into Confluent | EMQX Docs](https://www.emqx.io/docs/en/latest/data-integration/confluent-sink.html#stream-mqtt-data-into-confluent)                                     |
| [Gathr](https://www.gathr.one/partners/confluent/)                                                                                               | Analytics                           | [Confluent Cloud Connection](https://docs.gathr.one/gathr-saas/docs/components/confluent_kafka/confluent_kafka_connection/)                                                                |
| [HiveMQ](https://www.hivemq.com/)                                                                                                                | IOT                                 | [Confluent Cloud Integration](https://docs.hivemq.com/hivemq-cloud/cloud-console.html#confluent)                                                                                           |
| [Imply](https://imply.io/)                                                                                                                       | Real-time analytics                 | [Ingest from Confluent Cloud](https://docs.imply.io/polaris/ingest-from-confluent-cloud/)                                                                                                  |
| [Kinetica](https://www.kinetica.com/integrations/confluent/)                                                                                     | Real-time analytics platform        | [Loading Data | Kinetica Docs](https://docs.kinetica.com/7.1/sql/load/?search-highlight=confluent#id-f0b071e8-6df5-5204-9511-40929bf01b80)                                                 |
| [Materialize](https://materialize.com/)                                                                                                          | Real-time analytics                 | [Confluent Cloud](https://materialize.com/docs/ingest-data/confluent-cloud/)                                                                                                               |
| [Neo4j](https://neo4j.com/partners/confluent/)                                                                                                   | Operational / Graph database        | -                                                                                                                                                                                          |
| [Nexla](https://nexla.com/partners/nexla-confluent/)                                                                                             | Data integration                    | -                                                                                                                                                                                          |
| [Nstream](https://www.nstream.io/confluent/)                                                                                                     | Real-time analytics                 | [Confluent Cloud Tutorial](https://www.nstream.io/docs/backend/confluent-vehicle-tutorial/)                                                                                                |
| [Onehouse](https://www.onehouse.ai/)                                                                                                             | Lakehouse                           | [The Ultimate Data Lakehouse for Streaming Data Using Onehouse + Confluent](https://www.onehouse.ai/blog/the-ultimate-data-lakehouse-for-streaming-data-using-onehouse-confluent)          |
| [Onibex](https://connect.onibex.com/)                                                                                                            | SAP integrator                      | [SAP ERP & Confluent Cloud](https://www.onibex.com/blog/post/21-real-time-data-integration-between-sap-and-confluent-cloud-through-onibex-one-connect-certified-by-connect-with-confluent) |
| [Pinecone](https://www.pinecone.io/)                                                                                                             | Vector database                     | [Building real-time AI applications with Pinecone and Confluent Cloud](https://www.pinecone.io/confluent-integration/)                                                                     |
| [Precisely](https://www.precisely.com/)                                                                                                          | CDC                                 | -                                                                                                                                                                                          |
| [Qlik](https://www.qlik.com/us/)                                                                                                                 | CDC                                 | [Using Confluent Cloud as a target](https://betahelp.qlik.com/en-US/replicate/May2023/Content/Replicate/Main/Confluent%20Cloud/confluent-cloud.htm)                                        |
| [Quix](https://quix.io/)                                                                                                                         | App development                     | [Confluent Kafka](https://quix.io/docs/connectors/confluentkafka-destination.html)                                                                                                         |
| [Redis](https://redis.com/comparisons/redis-enterprise-and-kafka/?utm_source=partner&utm_medium=referral&utm_campaign=2024-01-confluentreferral) | In-memory database                  | -                                                                                                                                                                                          |
| [RisingWave](https://risingwave.com/partners/confluent/)                                                                                         | Real-time analytics                 | [Ingest data from Confluent Cloud](https://docs.risingwave.com/docs/current/confluent-kafka-source/)                                                                                       |
| [Rockset](https://rockset.com/)                                                                                                                  | Real-time analytics                 | [Confluent Cloud](https://rockset.com/docs/confluent-cloud/)                                                                                                                               |
| [SAP](https://store.sap.com/dcp/en/product/display-2001016557_live_v1/confluent-cloud)                                                           | ERP data integration                | [Digital commerce platform](https://store.sap.com/dcp/en/product/display-2001016557_live_v1)                                                                                               |
| [Singlestore](https://www.singlestore.com/)                                                                                                      | Real-time analytics                 | [Ingest data from Confluent Cloud (Kafka) - SingleStore Spaces](https://www.singlestore.com/spaces/ingest-data-from-confluent-cloud-kafka/)                                                |
| [StarTree](https://startree.ai/)                                                                                                                 | Real-time analytics                 | [Confluent Cloud connector](https://dev.startree.ai/docs/procedures/ingest-data/use-data-manager/confluent)                                                                                |
| [Squid](https://squid.cloud/partners/confluent)                                                                                                  | Middle-tier platform                | [Confluent integration | Squid Cloud docs](https://docs.squid.cloud/docs/integrations/queue/confluent)                                                                                     |
| [Superblocks](https://www.superblocks.com/partners/confluent)                                                                                    | Low-code development                | [Confluent | Superblocks Docs](https://docs.superblocks.com/integrations/integrations-library/confluent)                                                                                   |
| [Timeplus](https://www.timeplus.com/confluent-cloud)                                                                                             | Real-time analytics                 | [Load streaming data from Confluent Cloud](https://docs.timeplus.com/confluent-cloud-source)                                                                                               |
| [Tinybird](https://www.tinybird.co/)                                                                                                             | Real-time analytics                 | [Confluent Connector](https://www.tinybird.co/docs/ingest/confluent.html)                                                                                                                  |
| [Upsolver](https://www.upsolver.com/partner-confluent)                                                                                           | Data pipelines                      | [Confluent Kafka](https://docs.upsolver.com/sqlake/sql-command-reference/sql-jobs/create-job/copy-from/confluent-options)                                                                  |
| [Waterstream](https://waterstream.io/)                                                                                                           | IOT                                 | [Integration with Confluent Cloud](https://docs.waterstream.cloud/confluentcloud.html?highlight=confluent)                                                                                 |
| [Weaviate](https://weaviate.io/)                                                                                                                 | Vector database                     | -                                                                                                                                                                                          |
| [Zilliz](https://zilliz.com/product/integrations/confluent)                                                                                      | Vector database                     | -                                                                                                                                                                                          |

<a id="connect-w-confluent-related-content"></a>

## Related content

Use the following Confluent resources to learn more.

* [Kafka Producer](https://docs.confluent.io/platform/current/clients/producer.html#ak-producer) docs
* [Kafka 101: Producers](https://developer.confluent.io/learn-kafka/apache-kafka/producers/) tutorial
* [Kafka Consumer](https://docs.confluent.io/platform/current/clients/consumer.html#ak-consumer) docs
* [Kafka 101: Consumers](https://developer.confluent.io/learn-kafka/apache-kafka/consumers/) tutorial
* [How to build your first Apache Kafka Consumer application](https://developer.confluent.io/tutorials/creating-first-apache-kafka-consumer-application/confluent.html) tutorial
* [How to build your first Apache Kafka Producer application](https://developer.confluent.io/tutorials/creating-first-apache-kafka-producer-application/confluent.html) tutorial
* [Getting Started with Apache Kafka and Java](https://developer.confluent.io/get-started/java/) contains information about building a [Producer](https://developer.confluent.io/get-started/java/#build-producer) and [Consumer](https://developer.confluent.io/get-started/java/#build-consumer)
* [Kafka Java Client](https://docs.confluent.io/kafka-clients/java/current/overview.html#ak-java) docs
