{"slug":"queue-kafka","title":"Managed Kafka","description":"DanubeData runs Apache Kafka for you. A cluster is a Kafka 4.3 broker in KRaft mode (no ZooKeeper), reachable over TLS with a publicly trusted certificate and authenticated with SASL/SCRAM-SHA-512. An...","section":"Features","url":"https://docs.danubedata.ro/queue-kafka","markdown_url":"https://docs.danubedata.ro/queue-kafka.md","breadcrumbs":[{"title":"Features","slug":null},{"title":"Queues","slug":"queue-mqtt-stomp"},{"title":"Managed Kafka","slug":"queue-kafka"}],"headings":[{"level":1,"title":"Managed Kafka","id":"managed-kafka"},{"level":2,"title":"What you get in this version","id":"what-you-get-in-this-version"},{"level":2,"title":"Plans","id":"plans"},{"level":2,"title":"Create a cluster","id":"create-a-cluster"},{"level":3,"title":"In the console","id":"in-the-console"},{"level":3,"title":"With the API","id":"with-the-api"},{"level":3,"title":"With the CLI","id":"with-the-cli"},{"level":2,"title":"Connection details","id":"connection-details"},{"level":2,"title":"Connect","id":"connect"},{"level":3,"title":"kcat","id":"kcat"},{"level":3,"title":"Java","id":"java"},{"level":3,"title":"Python (confluent-kafka)","id":"python-confluent-kafka"},{"level":3,"title":"Node.js (KafkaJS)","id":"nodejs-kafkajs"},{"level":3,"title":"GUI tools (Kafkio, Offset Explorer, Conduktor)","id":"gui-tools-kafkio-offset-explorer-conduktor"},{"level":4,"title":"Schema Registry in GUI tools","id":"schema-registry-in-gui-tools"},{"level":2,"title":"Create topics","id":"create-topics"},{"level":2,"title":"Users and ACLs","id":"users-and-acls"},{"level":3,"title":"Names and passwords","id":"names-and-passwords"},{"level":3,"title":"Rules","id":"rules"},{"level":3,"title":"Example: a producer and a consumer","id":"example-a-producer-and-a-consumer"},{"level":3,"title":"Manage users with the API","id":"manage-users-with-the-api"},{"level":2,"title":"Schema Registry","id":"schema-registry"},{"level":3,"title":"Enable it","id":"enable-it"},{"level":3,"title":"Python (confluent-kafka)","id":"python-confluent-kafka"},{"level":3,"title":"Java","id":"java"},{"level":3,"title":"Good to know","id":"good-to-know"},{"level":2,"title":"Metrics","id":"metrics"},{"level":2,"title":"Firewall","id":"firewall"},{"level":2,"title":"Delete a cluster","id":"delete-a-cluster"},{"level":2,"title":"Related","id":"related"}],"format":"markdown","word_count":3334,"content":"# Managed Kafka\n\nDanubeData runs Apache Kafka for you. A cluster is a Kafka 4.3 broker in KRaft mode (no ZooKeeper), reachable over TLS with a publicly trusted certificate and authenticated with SASL/SCRAM-SHA-512. Any standard Kafka client works.\n\nKafka is a queue provider next to RabbitMQ: you create it from the same **Queues** area, API (`/api/v1/queue`) and CLI (`danube queue`). Everything in the RabbitMQ pages about MQTT, STOMP and AMQP does not apply to Kafka clusters.\n\n## What you get in this version\n\n- **One broker per cluster.** There is no high availability yet. If the broker restarts, clients are disconnected until it is back.\n- **TLS with a publicly trusted certificate.** Clients verify the server against the system trust store. You do not need a CA file.\n- **SASL/SCRAM-SHA-512** with an admin user, `kafka-<name>-admin`, which has full access to the cluster, and up to 20 more users limited by ACLs. See [Users and ACLs](#users-and-acls).\n- **A public endpoint** `kafka-<name>-<project>.queues.danubedata.ro:<port>`. The cluster's default firewall allows only that port.\n- **Persistent storage** sized by the plan.\n\nNot available yet:\n\n- Stop and start\n- Snapshots and backups\n- Plan changes (resizing a cluster) and changes to settings\n- Deny rules and rules limited to a client address (every ACL rule allows, from any host)\n- Multiple brokers and replication across brokers\n- A topic browser in the console (create and manage topics with Kafka's own tools, below)\n\nMetrics, logs, events and diagnose work. See [Metrics](#metrics) below.\n\nThe API gives the same \"not available for Kafka yet\" answer to stop, start, snapshot, plan and settings changes.\n\n## Plans\n\n| Plan | Console name | vCPU | RAM | Storage |\n|------|--------------|------|-----|---------|\n| `kafka-small` | DD Isac | 1 | 2 GB | 25 GB |\n| `kafka-medium` | DD Golovita | 2 | 4 GB | 75 GB |\n| `kafka-large` | DD Merhei | 4 | 8 GB | 200 GB |\n\nSee [Pricing](https://danubedata.ro/pricing) for what each plan costs. Billing is hourly, like every other resource, and a cluster is billed until you delete it.\n\n## Create a cluster\n\n### In the console\n\n1. In the sidebar, open **Messaging > Apache Kafka** and click **Create Kafka cluster** (or **Create your first Kafka cluster** when the list is empty). The page opens with Apache Kafka already chosen. Alternatively, click **Create queue** on the RabbitMQ list and choose the Apache Kafka broker card.\n2. Under **Broker**, check that **Apache Kafka** is selected.\n3. Under **Plan**, pick a plan. Each shows its vCPU, RAM, disk and monthly price. A plan above your account limit says **Upgrade required**, with a **Request a limit increase** link. A **Kafka version** selector appears only when more than one version is offered; today that is 4.3 alone, so it is hidden.\n4. **Location** is Falkenstein, Germany. The cluster gets a public TLS endpoint and a firewall, which you can restrict from its **Security** tab.\n5. Enter a **Name** and click **Create queue**. If your project has no payment method yet, you are asked to add one first.\n\nThe name cannot be changed later. It uses lowercase letters, numbers and hyphens, from 2 to at most 24 characters (fewer when your project's name is long), and becomes part of the cluster's hostname.\n\nProvisioning takes a few minutes while the public endpoint and its certificate are set up. The Kafka list shows **Kafka cluster created. Provisioning will begin shortly.**, and the cluster's row says the endpoint and its certificate are being set up until it is ready. When the cluster is ready, we email you (subject \"Your Kafka cluster '<name>' is ready\") with the bootstrap server, the SASL settings and the username. The email never contains the password.\n\n### With the API\n\n```bash\ncurl -X POST https://danubedata.ro/api/v1/queue \\\n  -H \"Authorization: Bearer $DANUBE_TOKEN\" \\\n  -H \"Content-Type: application/json\" \\\n  -d '{\"name\": \"events\", \"provider\": \"kafka\", \"resource_profile\": \"kafka-small\", \"version\": \"4.3\"}'\n```\n\n`provider` is `rabbitmq` (the default) or `kafka`. `GET /api/v1/queue?provider=kafka` lists only Kafka clusters, and every instance reports its `provider`.\n\nProvisioning is asynchronous: poll `GET /api/v1/queue/{id}` until `status_details.operation.terminal` is `true`, as for every other resource (see [Platform Automation](https://docs.danubedata.ro/platform-automation)).\n\n### With the CLI\n\n```bash\ndanube queue create --name events --provider kafka --profile kafka-small --version=4.3\ndanube queue ls --provider kafka\n```\n\nWrite the version as `--version=4.3`. `danube queue connection-info events` prints the connection details once the cluster is ready.\n\n## Connection details\n\nIn the console, open the cluster (**Open cluster** in the list's drawer) and use the **Connectivity** tab. The **Connect to your cluster** card shows the bootstrap server, security protocol, SASL mechanism and username, and keeps the password hidden until you choose **Reveal the password**. Below it, **Client settings** has ready-to-copy snippets for Java (`client.properties`), kcat and Node.js (KafkaJS), and **Download client.properties** saves the same settings as a file (shown to members who may see the cluster's credentials). When the cluster has a [Schema Registry](#schema-registry), the card also has a **Schema Registry** section with its URL, username and password (separate from the cluster's admin password), and the snippets include its settings.\n\nFrom the CLI:\n\n```bash\ndanube queue connection-info events\n```\n\nor `GET /api/v1/queue/{id}/connection-info`, which returns:\n\n| Field | Value |\n|-------|-------|\n| `status` | `provisioning` or `ready` |\n| `bootstrap_servers` | `kafka-<name>-<project>.queues.danubedata.ro:<port>` |\n| `security_protocol` | `SASL_SSL` |\n| `sasl_mechanism` | `SCRAM-SHA-512` |\n| `username` | `kafka-<name>-admin` |\n| `password` | The admin password |\n| `host`, `port` | The two halves of `bootstrap_servers` |\n| `certificate` | A note that the certificate is publicly trusted |\n\nThe password is only returned to members whose role may read credentials, and to API tokens with the `queue:credentials` ability; for everyone else it is `null`. While the endpoint is still being set up, `status` is `provisioning` and `bootstrap_servers`, `host` and `port` are `null`. The CLI also prints ready-to-use kcat and Java properties snippets.\n\nTreat the admin user like a root credential: it can read, write and delete every topic. Keep it out of source control and out of client-side code, and give your applications their own [users](#users-and-acls).\n\n## Connect\n\nThe examples read the address and credentials from environment variables:\n\n```bash\nexport KAFKA_BOOTSTRAP='kafka-events-myproject.queues.danubedata.ro:29092'\nexport KAFKA_USER='kafka-events-admin'\nexport KAFKA_PASSWORD='<password>'\n```\n\nThe address and port above are examples. Your real bootstrap address, with its port, is shown in the console and in `connection-info`.\n\n### kcat\n\n```bash\nkcat -L -b \"$KAFKA_BOOTSTRAP\" \\\n  -X security.protocol=SASL_SSL \\\n  -X sasl.mechanisms=SCRAM-SHA-512 \\\n  -X sasl.username=\"$KAFKA_USER\" \\\n  -X sasl.password=\"$KAFKA_PASSWORD\"\n```\n\n`-L` lists the cluster metadata. Use the same `-X` options with `-P` to produce and `-C` to consume. No CA option is needed.\n\n### Java\n\nPut the settings in a properties file and pass it to your client, or to Kafka's command-line tools with `--command-config`:\n\n```properties\nbootstrap.servers=<bootstrap address>\nsecurity.protocol=SASL_SSL\nsasl.mechanism=SCRAM-SHA-512\nsasl.jaas.config=org.apache.kafka.common.security.scram.ScramLoginModule required username=\"kafka-events-admin\" password=\"<password>\";\n```\n\nNo truststore is needed: the JVM's default trust store already trusts the certificate.\n\nReplace `<password>` with the admin password. If it contains a backslash or a double quote, escape it for the JAAS line and then again for the properties file, because `java.util.Properties` removes one level of backslashes before JAAS reads the value.\n\n### Python (confluent-kafka)\n\n```python\nimport os\nfrom confluent_kafka import Producer\n\nproducer = Producer({\n    \"bootstrap.servers\": os.environ[\"KAFKA_BOOTSTRAP\"],\n    \"security.protocol\": \"SASL_SSL\",\n    \"sasl.mechanisms\": \"SCRAM-SHA-512\",\n    \"sasl.username\": os.environ[\"KAFKA_USER\"],\n    \"sasl.password\": os.environ[\"KAFKA_PASSWORD\"],\n})\n\nproducer.produce(\"orders\", b\"hello\")\nproducer.flush()\n```\n\n### Node.js (KafkaJS)\n\n```javascript\nconst { Kafka } = require('kafkajs');\n\nconst kafka = new Kafka({\n  brokers: [process.env.KAFKA_BOOTSTRAP],\n  ssl: true,\n  sasl: {\n    mechanism: 'scram-sha-512',\n    username: process.env.KAFKA_USER,\n    password: process.env.KAFKA_PASSWORD,\n  },\n});\n\nconst producer = kafka.producer();\nawait producer.connect();\nawait producer.send({ topic: 'orders', messages: [{ value: 'hello' }] });\nawait producer.disconnect();\n```\n\n### GUI tools (Kafkio, Offset Explorer, Conduktor)\n\nDesktop tools connect with the same settings. In the tool's cluster or connection settings, enter the bootstrap address, then set:\n\n- **Security protocol**: `SASL_SSL`\n- **SASL mechanism**: `SCRAM-SHA-512`\n- **Username** and **Password**: the admin user and its password\n\nLeave the truststore or CA settings empty. Most of these tools default to SASL plaintext (`SASL_PLAINTEXT`) with the `PLAIN` mechanism, and the cluster refuses that combination, so change both fields before you connect.\n\n#### Schema Registry in GUI tools\n\nKafka does not tell its clients where a schema registry is, so a tool cannot find your cluster's [Schema Registry](#schema-registry) by itself: set it in the tool's cluster connection, next to the Kafka settings above.\n\n- **URL**: the registry's address, `https://schema-<name>-<project>.queues.danubedata.ro`, shown on the cluster's **Connectivity** tab.\n- **Authentication**: HTTP Basic (a username and a password), with the username `registry`.\n- **Password**: the registry has its own password, separate from the Kafka admin password. Reveal it in the **Schema Registry** section of the Connectivity tab.\n\nIn Kafkio, open the cluster's connection settings and fill in the **Schema Registry** section: the URL, Basic authentication, and the username and password above. Offset Explorer and Conduktor have a Schema Registry setting in the cluster's connection or configuration; enter the same URL and choose Basic authentication there. The names of the fields differ between tools and versions.\n\nIf your tool reads a Java properties file, choose **Download client.properties** on the Connectivity tab (shown to members who may see the cluster's credentials) to get the connection settings in one file. The file signs in as the cluster's admin user, a super user that can read, write and manage every topic: use it for your own tools, and give each application its own user with ACLs (see [Users and ACLs](#users-and-acls)) instead of sharing it.\n\n## Create topics\n\nTopic management is done with Kafka's own tools, authenticated as the admin user. Save the Java properties above as `client.properties`, then, with the Kafka 4.x command-line tools:\n\n```bash\nkafka-topics.sh --bootstrap-server \"$KAFKA_BOOTSTRAP\" \\\n  --command-config client.properties \\\n  --create --topic orders --partitions 3 --replication-factor 1\n\nkafka-topics.sh --bootstrap-server \"$KAFKA_BOOTSTRAP\" \\\n  --command-config client.properties --list\n```\n\nUse `--replication-factor 1`. The cluster has a single broker, so a higher replication factor is rejected.\n\n## Users and ACLs\n\nEvery cluster checks each request against ACLs. The admin user, `kafka-<name>-admin`, is a super user and is never limited. Give each application its own user with only the access it needs, so a leaked password cannot reach everything.\n\nA cluster can have up to 20 users besides its admin. Users can be added, changed and deleted only while the cluster is running.\n\n### Names and passwords\n\nYou give a user a short name: 1 to 32 lowercase letters, digits and hyphens, unique in the cluster (`admin` is taken). Clients sign in with the username `kafka-<cluster>.<name>`, for example `kafka-events.billing`, using SASL/SCRAM-SHA-512 as for the admin. The whole username is at most 55 characters, so a cluster with a long name allows shorter user names; the user list's `meta.max_name_length` gives the limit.\n\nThe password is generated for you and shown once, in the answer that creates the user. It is never listed again; if it is lost, rotate it. Creating, rotating and deleting users need a role that may read credentials (the owner, Administrators and Editors). An API token needs `queue:write` and `queue:credentials` to create or rotate, and `queue:delete` to delete. Changing a user's rules needs `queue:write`.\n\nChanges reach the cluster in the background. A user's `status` is `pending` until the cluster has applied the latest change, usually within a few minutes, then `active`. `error` means the cluster refused it, and `status_message` says why.\n\nWhen you rotate a password or delete a user, the change applies to new connections as soon as the user is `active` again (or gone). Connections that are already open keep working until they next re-authenticate, which every connection does within an hour. Until the rotation is applied, the old password still signs in.\n\nThe cluster asks every connection, the admin's included, to re-authenticate within an hour. Clients that support re-authentication (KIP-368: the Java client 2.2 and later, librdkafka 2.2 and later, and the clients built on it) do so without dropping the connection. Older clients, including older kcat and distribution builds of librdkafka, are disconnected once an hour and must reconnect; most do that on their own.\n\n### Rules\n\nA user may do only what its rules allow; everything else is denied. Each rule has:\n\n| Field | Value |\n|-------|-------|\n| `resource_type` | `topic`, `group` (a consumer group), `transactional_id` or `cluster` |\n| `name` | The topic, group or transactional id. `*` with the `literal` pattern means all of them. Not used for `cluster`. |\n| `pattern` | `literal` (exactly this name) or `prefix` (every name that starts with it). Not used for `cluster`. |\n| `operations` | What is allowed, from the list below |\n\n| Resource | Operations |\n|----------|------------|\n| `topic` | `read`, `write`, `create`, `delete`, `alter`, `describe`, `describe_configs`, `alter_configs`, `all` |\n| `group` | `read`, `describe`, `delete`, `describe_configs`, `alter_configs`, `all` |\n| `transactional_id` | `describe`, `write`, `all` |\n| `cluster` | `create`, `describe`, `describe_configs`, `idempotent_write` |\n\nChanging ACLs or the broker's configuration (`alter`, `alter_configs` and `all` on the cluster) is left to the admin user.\n\nA user can have up to 50 rules. A producer needs `write` and `describe` on its topics, which also covers idempotent producing (the default in current clients). A transactional producer also needs `write` and `describe` on its transactional id. A consumer needs `read` and `describe` on its topics and `read` on its consumer group.\n\n### Example: a producer and a consumer\n\nA producer that writes to every topic starting with `orders.`:\n\n```bash\ncurl -X POST https://danubedata.ro/api/v1/queue/$QUEUE_ID/kafka-users \\\n  -H \"Authorization: Bearer $DANUBE_TOKEN\" \\\n  -H \"Content-Type: application/json\" \\\n  -d '{\n    \"name\": \"orders-producer\",\n    \"acls\": [\n      {\"resource_type\": \"topic\", \"name\": \"orders.\", \"pattern\": \"prefix\", \"operations\": [\"write\", \"describe\"]}\n    ]\n  }'\n```\n\nA consumer in the group `billing` that reads the same topics:\n\n```bash\ncurl -X POST https://danubedata.ro/api/v1/queue/$QUEUE_ID/kafka-users \\\n  -H \"Authorization: Bearer $DANUBE_TOKEN\" \\\n  -H \"Content-Type: application/json\" \\\n  -d '{\n    \"name\": \"billing\",\n    \"acls\": [\n      {\"resource_type\": \"topic\", \"name\": \"orders.\", \"pattern\": \"prefix\", \"operations\": [\"read\", \"describe\"]},\n      {\"resource_type\": \"group\", \"name\": \"billing\", \"pattern\": \"literal\", \"operations\": [\"read\"]}\n    ]\n  }'\n```\n\nEach answer holds the user, with `username` (`kafka-events.orders-producer` and `kafka-events.billing` for a cluster named `events`) and `password`. Use them in place of the admin's in the client settings above; nothing else changes.\n\n### Manage users with the API\n\n| Request | Does |\n|---------|------|\n| `GET /api/v1/queue/{id}/kafka-users` | Lists the users and their rules, never the passwords |\n| `POST /api/v1/queue/{id}/kafka-users` | Creates a user from `name` and `acls`, and returns its password |\n| `PUT /api/v1/queue/{id}/kafka-users/{userId}` | Replaces the user's rules with `acls` (send every rule it should keep) |\n| `POST /api/v1/queue/{id}/kafka-users/{userId}/rotate-password` | Returns a new password |\n| `DELETE /api/v1/queue/{id}/kafka-users/{userId}` | Deletes the user. It shows `deleting`, then leaves the list |\n\nEvery change is recorded in the project's audit log, without the password.\n\n## Schema Registry\n\nA cluster can have a Schema Registry: a Confluent-compatible schema registry (Karapace) for Avro, JSON Schema and Protobuf schemas, which Confluent's serializers and most Kafka tools speak to. It is an add-on at €4.99 a month, billed by the hour while it is enabled. It is available on request: ask support to turn it on for your account.\n\n### Enable it\n\nIn the console, open the cluster and turn on **Schema Registry**. From the API, `POST /api/v1/queue/{id}/schema-registry`. The cluster must be running. The registry is set up in the background and its status reads `provisioning` until it answers on its public address, usually within a few minutes, then `ready`.\n\nEach registry has its own HTTPS endpoint, `https://schema-<name>-<project>.queues.danubedata.ro`, with a publicly trusted certificate. Clients sign in with HTTP Basic authentication: the username is `registry`, and the password is shown on the cluster page to anyone who may read the cluster's credentials (`GET /api/v1/queue/{id}/schema-registry` with `queue:credentials`).\n\nThe cluster's firewall does not cover the registry endpoint: it is reachable from anywhere, and TLS and the password protect it. Keep the password secret, and rotate it if it leaks.\n\n### Python (confluent-kafka)\n\n```python\nimport os\nfrom confluent_kafka import Producer\nfrom confluent_kafka.schema_registry import SchemaRegistryClient\nfrom confluent_kafka.schema_registry.avro import AvroSerializer\nfrom confluent_kafka.serialization import MessageField, SerializationContext\n\nregistry = SchemaRegistryClient({\n    \"url\": \"https://schema-events-<project>.queues.danubedata.ro\",\n    \"basic.auth.user.info\": \"registry:\" + os.environ[\"SCHEMA_REGISTRY_PASSWORD\"],\n})\nschema = '{\"type\": \"record\", \"name\": \"Order\", \"fields\": [{\"name\": \"id\", \"type\": \"string\"}]}'\nserialize = AvroSerializer(registry, schema)\n\nproducer = Producer({\n    \"bootstrap.servers\": os.environ[\"KAFKA_BOOTSTRAP\"],\n    \"security.protocol\": \"SASL_SSL\",\n    \"sasl.mechanisms\": \"SCRAM-SHA-512\",\n    \"sasl.username\": os.environ[\"KAFKA_USER\"],\n    \"sasl.password\": os.environ[\"KAFKA_PASSWORD\"],\n})\nproducer.produce(\"orders\", value=serialize({\"id\": \"42\"}, SerializationContext(\"orders\", MessageField.VALUE)))\nproducer.flush()\n```\n\n### Java\n\nAdd these to the producer or consumer properties of the [Java client](#java) to use Confluent's serializers, for example `io.confluent.kafka.serializers.KafkaAvroSerializer`:\n\n```properties\nschema.registry.url=https://schema-events-<project>.queues.danubedata.ro\nbasic.auth.credentials.source=USER_INFO\nbasic.auth.user.info=registry:<password>\n```\n\n### Good to know\n\n- The registry keeps its schemas in the cluster's `_schemas` topic. Do not write to it or delete it: that topic is the registry's data.\n- **Rotate the password** in the console or with `POST /api/v1/queue/{id}/schema-registry/rotate-password`, which answers the new one. The registry picks it up within a few minutes, without restarting; until then the old password still works.\n- **Disable it** in the console or with `DELETE /api/v1/queue/{id}/schema-registry`. Billing stops at once and the endpoint goes away, but the `_schemas` topic stays: enable the registry again and your subjects and schemas are back, with the same password.\n- Deleting the cluster deletes its registry and its schemas with it.\n\n## Metrics\n\nIn the console, open the cluster and use the **Metrics** tab. It shows the cluster's health with the reason for a warning, then its current figures:\n\n- CPU, as a share of the plan's vCPUs\n- Memory used, out of the broker's limit\n- Disk used, out of the plan's storage, with the percentage used\n- Messages in per second, and bytes in and out per second\n- Partitions, with the number that are under-replicated (highlighted when there are any)\n- Consumer lag: messages produced but not yet consumed, over every consumer group\n\nCharts cover CPU, memory, disk (used against capacity), messages in, bytes in and out, and consumer lag over the window you pick (1 hour to 1 week). A **Consumer groups** table lists the 50 groups with the most lag, the largest first. A figure shows a dash while it is unknown, for example in the first minutes after the cluster starts. The Kafka list also shows each cluster's CPU, memory and total consumer lag.\n\nFrom the API, `GET /api/v1/queue/{id}/metrics` returns the current values, as for RabbitMQ, with no time series:\n\n| Field | Value |\n|-------|-------|\n| `provider` | `kafka` |\n| `summary` | `cpu_percent`, `memory_used_bytes`, `memory_limit_bytes`, `disk_used_bytes`, `disk_capacity_bytes`, `messages_in_per_sec`, `bytes_in_per_sec`, `bytes_out_per_sec`, `partitions`, `under_replicated_partitions`, `consumer_lag_total` |\n| `summary.consumer_groups` | A list of `{group, lag}`, the largest lag first, at most 50 |\n| `health` | `status` (`healthy`, `warning`, `critical` or `unknown`) and `issues`, which say why |\n\nA value is `null` while it is unknown, which is not the same as zero.\n\n## Firewall\n\nThe cluster's default firewall opens only the Kafka port, to any address. Restrict it like any other firewall: edit its rules on the cluster's **Security** tab, for example to allow only your VPS instances or your office address. See [Firewalls](https://docs.danubedata.ro/networking-firewalls).\n\nAuthentication is required on every connection, but the endpoint is on the public internet until you narrow the firewall.\n\n## Delete a cluster\n\nDeleting a Kafka cluster deletes its topics and all of its data. There are no snapshots to recover from. Export what you need first, for example by consuming the topics into your own storage.\n\nIn the console, open the cluster's **Settings** tab and choose **Delete cluster** (it is also in the **More** menu). From the CLI:\n\n```bash\ndanube queue rm events\n```\n\n## Related\n\n- [Connecting to RabbitMQ via MQTT & STOMP](https://docs.danubedata.ro/queue-mqtt-stomp)\n- [Firewalls](https://docs.danubedata.ro/networking-firewalls)\n- [Pricing](https://danubedata.ro/pricing)\n- [API reference](https://danubedata.ro/docs/api.json)\n","prev":{"title":"Connecting via MQTT & STOMP","slug":"queue-mqtt-stomp","url":"https://docs.danubedata.ro/queue-mqtt-stomp","markdown_url":"https://docs.danubedata.ro/queue-mqtt-stomp.md","json_url":"https://docs.danubedata.ro/queue-mqtt-stomp.json"},"next":{"title":"Account Settings","slug":"account-settings","url":"https://docs.danubedata.ro/account-settings","markdown_url":"https://docs.danubedata.ro/account-settings.md","json_url":"https://docs.danubedata.ro/account-settings.json"},"index_url":"https://docs.danubedata.ro/index.json"}