AWS: Users and passwords

Every connection to your instance must authenticate. Users are managed in Configuration → Users.

Every connection to your instance must authenticate. Users are managed in Configuration → Users.

The default user

Each instance is created with an application user, kividbapp — this is the username shown on your overview under Access Credentials, and the one your application uses unless you add others.

The Redis default user exists, has no password, and, unless you turn on passwordless access, can do nothing except authenticate: AUTH, HELLO (so that a client can send its username and password in HELLO 3 AUTH ...) and PING. An unauthenticated client cannot read, write, inspect or copy your data even if it reaches the port.

Replicas log in to their primary as an internal replication user with its own password, which may only run the replication handshake. It is not shown to you and cannot be used by your applications.

Turning the default user off

Configuration → Users → Default user. Turning kividbapp off replaces its password with a random one that only KiviDB's own services hold (the node agent, the metrics exporter and the console's data browser use it), and the console stops showing it. Every client still using kividbapp is refused at its next sign-in, so move your applications to a database user first. Turning it back on issues a new password, shown once on the overview.

While it is off, Set password is not available for kividbapp. KiviDB's own system user is a separate user and is never affected.

Passwordless access

With passwordless access on, a client that sends no password gets kividbapp's permissions, as if it had signed in as kividbapp. It is offered only while the database's public access is blocked (in Configuration → Network, which needs private connectivity first), so only clients on your private path can connect at all. Public access cannot be reopened while it is on: turn it off first.

The free tier keeps its default user, with a password. Both settings are also in the API (PATCH /instances/{id}/default-user with enabled and passwordless) and the MCP tool set_default_user.

Changing your password

Configuration → Users → Set password on the user you want to change.

A new password is written to every node of the database, usually within a minute. Clients using the old one fail on their next connection, so roll it out to your application first, or accept a brief window of failures.

If you have lost the password, you can set a new one without knowing the old.

Adding users

Configuration → Users → Add user. Each user gets a username, a password and its permissions: one of three built-in profiles, or a role your organization defines (below).

ProfileCan do
Read-writeRead and write every key, run search, scripts, transactions and streams. The normal application profile.
Read-onlyThe same reads and searches, no writes.
Pub/SubPublish and subscribe on any channel, and look keys up read-only (GET, MGET, EXISTS, TYPE, TTL, PTTL, KEYS, SCAN) and INFO. Nothing that changes, renames or moves a key.

Users with any profile, or a role, cannot manage the server itself: CONFIG, ACL, DEBUG, MODULE, SHUTDOWN, MONITOR, SWAPDB, MIGRATE, replication and failover commands, and SAVE/BGSAVE/BGREWRITEAOF (snapshots are taken by KiviDB) are denied to them whatever the profile or role says. If you need a narrower publish-and-subscribe user, a role with a rule such as +@pubsub +ping &events:* gives exactly that.

Separate users are worth the small effort. A reporting job with a read-only user cannot corrupt your data through a bug, and revoking one consumer's access does not require rotating everyone's password.

Usernames are lower-case letters, digits and _, starting with a letter. default, kividbapp, kividb_system, kividb_internal and anything starting with kividb_ are reserved.

Custom rules and roles

When the three profiles do not fit — a user that may only read keys under cache:, or one that may write inbox:* and read reports:* — write your own under Settings → Database access.

  • A rule is a named Redis ACL permission string, such as +@read ~cache:*.
  • A role gives each database one rule, and can have one rule for all other databases.
  • A database user is given a role instead of a profile, in the same Configuration → Users list.

A user with a role starts with no permissions at all and gets exactly what its rule for that database says, then loses the server-management commands listed above. So a rule needs keys as well as commands: +@read alone can run read commands on no key. Commands that take no key, such as SCAN and KEYS, list every key name whatever the key patterns say, as in Redis.

What a rule may contain:

PartExampleMeans
+command, -command+get, -flushallAllow or deny one command
+command|sub+client|setnameOne subcommand of a command that has them
+@category, -@category+@read, -@dangerousAllow or deny a category (read, write, string, hash, search, json, vector, pubsub, admin, dangerous and the rest)
allcommands, nocommands, readonlyEvery command; none; deny every write
~pattern~cache:*Read and write keys matching the pattern
%R~pattern, %W~pattern%R~reports:*Read only, or write only, keys matching it
allkeys, resetkeysEvery key; forget the key patterns so far
&pattern&events:*Publish and subscribe to matching channels
allchannels, resetchannelsEvery channel; forget the channel patterns so far

Refused, with the part named: anything that sets or removes a password (>, <, #, !), on, off, nopass, reset, resetpass, selectors in parentheses, command or category names the engine does not have, names not in lower case, a key or channel pattern after ~* or &*, and anything outside printable ASCII. The console checks a rule as you type it.

Changing a rule or a role applies it to every database where a user holds a role that uses it, usually within a minute, and the confirmation names those databases. A database that is stopped takes the change when it starts. On KiviDB 1.1 and later, clients already connected as such a user are held to the new permissions from their next command.

A role cannot stop covering a database its users are on: change those users first, or keep a rule for their database. A rule a role uses, and a role a user holds, cannot be deleted.

Roles work on paid databases running KiviDB 1.1.0 or later, including sharded ones. Free databases offer the three built-in profiles. Only owners and admins can change rules and roles; any member who can manage a database can give its users a role.

Removing users

Configuration → Users → Remove. The user is removed from every node, usually within a minute; on KiviDB 1.1 and later, connections already open as that user are closed then.

The built-in application user cannot be removed — it is the credential your overview shows and your instance's primary identity.

Where credentials are shown

Your application user's password appears on the instance overview, hidden until you click Reveal. A password for a user you add is shown when you create it, and afterwards by Reveal on that user in Configuration → Users, to members whose role may read secrets (not viewers). You can also set a new one at any time.