This page answers "does this combination work, and what do I need for it?" in a few tables: which ways of logging in go with which Security type, what each SASL mechanism needs, which certificate and key formats go where, what the Schema Registry, Kafka Connect and ksqlDB connections support next to the brokers, and which methods each managed service offers. It's a map, not a manual: every cell links to the page that explains the setting, mostly Security & Authentication and Provider Recipes.
In the tables, Yes means it works, a half circle means it works with a catch (read the cell), and a dash means it doesn't apply or isn't available.
Security types and authentication
The security type decides whether the connection is encrypted (TLS) and whether you log in with SASL. It has to match the broker listener behind your bootstrap port. Read down a column to see what a listener of that type lets you use:
| How you prove who you are | Plaintext (no TLS) |
SSL (TLS) |
SASL plaintext (no TLS) |
SASL SSL (TLS) |
|---|---|---|---|---|
| Nobody: no login | Yes, unencrypted: local and development clusters | Yes, one-way TLS | No: SASL needs a login | No: SASL needs a login |
| Client certificate | No | Yes: Two-way SSL/TLS? | No | Yes, as well as SASL, if the listener asks for one |
| PLAIN | No | No | Yes, but the password crosses the network as it is: development only | Yes |
| SCRAM-SHA-256 / -512 | No | No | Yes: the password isn't sent, but your data is unencrypted | Yes |
| GSSAPI (Kerberos) | No | No | Yes, data unencrypted | Yes |
| OAUTHBEARER | No | No | Yes, but the token crosses the network unencrypted | Yes |
| AWS_MSK_IAM | No | No | No: MSK's IAM listener uses TLS | Yes |
A security type that doesn't match the listener rarely says so: it usually ends in
Timed out waiting for a node assignment (see
Testing and common errors). Settings in a
section the type hides are kept, but not sent.
SASL mechanisms
What each SASL type needs on the Kafka Security tab,
and whether its secret stays out of your clusters.json file, which KafkIO keeps in plain text (see
How passwords are stored). Start from the
example named in the second column; it fills in the type and the
callback handler for you.
| SASL type | Start from example | Callback handler | Secret kept out of clusters.json? |
Also needed |
|---|---|---|---|---|
PLAIN |
PLAIN, or Azure Event Hubs (SAS) | Default | No: the password (or connection string) is saved in the JAAS config | Nothing |
SCRAM-SHA-256, SCRAM-SHA-512 |
SCRAM (picks SHA-256: change it for SHA-512) | Default | No: the password is saved in the JAAS config | Nothing |
GSSAPI |
GSSAPI (Kerberos) | Default | Yes: a keytab file (its path is saved) or your ticket cache | The service name, and the realm and
KDC from krb5.conf or Preferences ▸ Kerberos |
OAUTHBEARER, any OAuth 2.0 provider |
OAUTHBEARER | Login: OAuthBearerLoginCallbackHandler |
No: the client secret is saved in the JAAS config | The token endpoint URL in SASL other config; network access to your identity provider |
OAUTHBEARER, Strimzi OAuth |
Strimzi | Login: JaasClientOauthLoginCallbackHandler |
No: the client secret (and any token-endpoint truststore password) is saved | Network access to the token endpoint |
OAUTHBEARER, Azure Event Hubs with Entra ID |
Azure Event Hubs (Entra/OAuth) | Client: AzureEntraClientCallbackHandler (KafkIO's own) |
Yes: it uses your Azure sign-in (az login, environment variables) |
Exactly one bootstrap server; an Event Hubs data role |
AWS_MSK_IAM |
AWS IAM | Client: IAMClientCallbackHandler |
Yes: it uses your AWS credentials files or environment (only a profile name is saved) | An IAM policy allowing the kafka-cluster:* actions you use (see
MSK IAM) |
- Any other mechanism name can be typed into SASL type; left blank, Kafka's
default,
GSSAPI, applies. See SASL mechanisms. - Amazon MSK's IAM library also has an
OAUTHBEARERvariant (login handlerIAMOAuthBearerLoginCallbackHandler), with no example of its own: see IAM. - The OAuth and cloud sign-ins fetch tokens over HTTP themselves, without KafkIO's proxy. Behind a proxy, see JDK proxy system properties.
Key and certificate formats
Where each format can be used. The same three choices appear in every Truststore type and Keystore type list; details in Supported certificate and key formats.
| Format (on screen) | Truststore | Keystore (client certificate) | Password field | Schema Registry, Connect, ksqlDB tabs | Add certificate in Preferences |
|---|---|---|---|---|---|
Java KeyStore (JKS).jks |
Yes (the default type) | Yes | Yes | Yes | No |
P12 / PFX / PKCS12.p12, .pfx |
Yes | Yes | Yes | Yes, but Edit Cluster shows JKS again: re-select the type each time you save | No |
CRT / PEM / X.509.pem, .crt,
.cer |
Yes, one or more certificates | Yes: key (PKCS#8) and certificate in one file; for the brokers, use a key without a password (see the note in Mutual TLS) | Hidden | Yes, with the same re-select catch as P12 | Yes, one certificate per file (PEM or DER) |
KafkIO reads PKCS12 and PEM directly, so there's rarely a reason to convert; when you do want a Java keystore, see Need a JKS?. A Kerberos keytab isn't any of these: its path goes in the JAAS config.
Brokers and REST services
Schema Registry, Kafka Connect and ksqlDB are HTTP services with their own security settings, on their own tabs of the Cluster Properties dialog. Nothing is shared with the brokers' settings, or between tabs: if two connections need the same truststore, choose it on both.
| Setting | Kafka brokers | Schema Registry | Kafka Connect | ksqlDB |
|---|---|---|---|---|
| TLS | Yes: SSL or SASL SSL | Yes: an https:// URL |
||
| Own truststore | Yes (Truststores) | Yes (TLS for Schema Registry) | Yes, per Connect cluster (TLS) | Yes, per ksqlDB cluster (TLS) |
| Trusted certificates and Accept non-trusted certificates automatically (Preferences ▸ Network) | No: never applied to brokers | Yes, when the tab's truststore is blank | The accept box only, and it overrides the truststore | |
| Client certificate (mTLS) | Yes: Two-way SSL/TLS? and a keystore | |||
| SSL validation (host name check) | Yes, but off for a new cluster: tick it (see Hostname validation) | |||
| User name and password | Yes: SASL PLAIN or SCRAM |
Yes: User:password | Yes: User:password | Yes: User:password |
| OAuth tokens | Yes: OAUTHBEARER |
Yes: the Oauth switch (client credentials or a fixed token) | A fixed token, as an Authorization header |
A fixed token, as a header |
| Kerberos, AWS IAM, Azure Entra ID | Yes: SASL | No | ||
| Additional HTTP headers | Not applicable | Saved but not sent in the current version (why) | Yes | Yes |
| HTTP proxy | Never (Proxy) | Yes: Use proxy (if configured) | ||
By provider
Which ways of logging in each service offers, and which work with KafkIO. For the settings to choose (ports, security type, truststore) see Provider Recipes' At a glance table; each cell here links to the recipe. A local broker in Docker usually has no security at all (Local Kafka in Docker).
| Service | Client certificate | PLAIN |
SCRAM | OAUTHBEARER |
AWS IAM | Schema Registry login |
|---|---|---|---|---|---|---|
| Confluent Cloud | No | Yes: API key and secret | No | Not covered | No | Yes: its own API key, or OAuth |
| Confluent Platform | Yes, whichever your administrators enabled (Kerberos too) | No | Yes, as configured | |||
| Amazon MSK | Yes: port 9094, AWS Private CA certificate | No | Yes: SHA-512, port 9096 | The IAM variant only | Yes: port 9098 (Serverless: IAM only) | No: AWS Glue Schema Registry isn't compatible |
| Azure Event Hubs | No | Yes: connection string | No | Yes: Entra ID | No | No: Azure Schema Registry isn't compatible |
| Aiven | Yes: the default | No | Yes: SHA-256, once SASL is enabled | No | No | Yes: Karapace, User:password |
| Strimzi | Yes: tls users |
No | Yes: scram-sha-512 users |
Yes: Strimzi OAuth | No | Not part of Strimzi |
| WarpStream | No | Yes, usually, if the agents require SASL | No | No | No | Yes: User:password, if required |
"No" and "Not covered" mean the recipe doesn't use that method: either the service doesn't offer it to Kafka clients, or it hasn't been described for KafkIO yet. The Confluent Platform row is ordinary Apache Kafka security, so every method in the first table works if the listener has it. If a method you need isn't here, the fields on the Kafka Security tab are standard Kafka client settings: your provider's settings for Java clients go into the matching fields.