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).
| Profile | Can do |
|---|---|
| Read-write | Read and write every key, run search, scripts, transactions and streams. The normal application profile. |
| Read-only | The same reads and searches, no writes. |
| Pub/Sub | Publish 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:
| Part | Example | Means |
|---|---|---|
+command, -command | +get, -flushall | Allow or deny one command |
+command|sub | +client|setname | One subcommand of a command that has them |
+@category, -@category | +@read, -@dangerous | Allow or deny a category (read, write, string, hash, search, json, vector, pubsub, admin, dangerous and the rest) |
allcommands, nocommands, readonly | Every 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, resetkeys | Every key; forget the key patterns so far | |
&pattern | &events:* | Publish and subscribe to matching channels |
allchannels, resetchannels | Every 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.