How to Configure ScyllaDB SSL Connection

Published
Length
3 min read

Luis Felipe Dias

All posts

You set up a scylladb ssl connection by turning on transport encryption in the node settings. You then give your client drivers the right trust certificates to check the server identity. Most teams start by making a root certificate authority for their database cluster. They sign a unique certificate for each node and put those files on the servers. When teams share one broad database role across many users, encryption alone will not protect data. How a scylladb ssl connection works in practic

Your coding agents run with your access.

Claude Code reaches prod with a developer's credentials, and approval prompts get clicked through. hoop.dev checks every query, masks sensitive data, and holds risky changes for a human.

You set up a scylladb ssl connection by turning on transport encryption in the node settings. You then give your client drivers the right trust certificates to check the server identity. Most teams start by making a root certificate authority for their database cluster. They sign a unique certificate for each node and put those files on the servers. When teams share one broad database role across many users, encryption alone will not protect data.

How a scylladb ssl connection works in practice

ScyllaDB splits network encryption into two main paths for your cluster. The first path encrypts traffic between your client apps and the database nodes. The second path encrypts internal data moving from one database node to another. Both paths rely on standard TLS certificates to prove identity and hide data on the wire. You must generate a private key and a public certificate for every single node. A trusted certificate authority signs these files so clients know the nodes are real. You then point the node settings file to the key and certificate paths on disk. You can also turn on mutual TLS if you want nodes to check client certificates. In that mode, the server asks the client app for a valid certificate before login. Once the node restarts, it listens for encrypted traffic on the secure port. Your client drivers must load the root certificate file to trust the database server. During the initial handshake, the client checks that the server name matches the certificate. If the check passes, the driver opens an encrypted session and sends your queries.

Why transport encryption leaves a security gap

Setting up TLS protects your data as it moves across the network. It stops outside attackers from reading packets or faking a server on the wire. It also helps your team meet basic security rules for data in transit. Still, transport encryption only checks who can open a network link to the cluster. Once the TLS handshake finishes, the database relies on standard roles and passwords. Most teams give developers and apps broad roles to avoid permission errors during incidents. A user with a valid certificate and a shared password can run any query. Native encryption does not inspect what individual statements or commands do in flight. It will not stop a user from dropping a keyspace or reading all rows by default. It also fails to rewrite sensitive fields like emails, phone numbers, or card numbers. Also, rotating client certificates across dozens of engineer laptops creates heavy manual work. When someone leaves the team, revoking files and updating trust stores takes hours. Transport setup secures the pipe, but it does not govern the queries inside it.

Managing certificates and client sessions at scale

Running encrypted database clusters over time requires strict file tracking and updates. Every certificate has an expiration date that will break app sessions if ignored. Teams must track these dates and push new files to every node before they expire. You must reload the database or restart services to pick up the fresh keys. On the client side, every app container and developer laptop needs the current trust store. If you use mutual TLS, you also have to hand out client keys safely. Putting these private keys on user laptops creates a new risk if a device gets lost. Teams also struggle to tie shared certificates back to a single person in the logs. When five engineers share one client key, the audit log shows the same identity for all. You need a clean way to link every query to a real user identity. You also need controls that filter sensitive results like national IDs before they reach the screen.

End-to-End Encryption + Connection Pooling Security: architecture patterns and best practices

Continue reading? Get the full guide.

Free. No spam. Unsubscribe anytime.

Govern statements and responses across databases and APIs

Good config and scoped roles are needed setup. They do not check single queries in flight or mask sensitive fields in returned rows. Across Postgres, MySQL, SQL Server, MongoDB, ClickHouse, Kubernetes APIs, SSH, and internal HTTP endpoints, hoop.dev sits inline in the protocol beside each supported service as an open-source proxy, a sidecar for your database or API. For every query or command an AI agent or engineer runs against production, hoop.dev decides to pass, mask, block, or hold it for human approval.

First, hoop.dev guardrails block banned queries before they run or hold risky ones for review, and hoop.dev data masking rewrites matched sensitive values in responses in memory. Furthermore, hoop.dev holds SOC 2 Type II and is open source on GitHub.

Frequently asked questions

What is the difference between client-to-node and node-to-node encryption?

Client-to-node encryption secures traffic between your apps or user tools and the database cluster. Node-to-node encryption secures internal replication and gossip traffic moving between the database servers themselves.

Do I need mutual TLS for my ScyllaDB cluster?

Mutual TLS is optional, and it forces the database to check a client certificate during login. Many teams use standard one-way TLS with strong user roles to avoid managing client certificates.

How do I avoid downtime when enabling SSL on an existing cluster?

You can enable optional encryption on the nodes first so they accept both plain and encrypted traffic. Once all client apps switch to the encrypted port, you can lock the nodes to require SSL.

The query runs. The emails stay hidden.