Key Value Store practice questions

Set the depth parameter to 1.

Why it fails: Depth is not a parameter for the standard Consul KV API.

Use the index parameter with value 0.

Why it fails: Index is for long polling.

Use the keys parameter with the prefix.

Why it fails: While keys can be used, recurse is the standard approach to retrieve the full tree.

labels

Why it fails: Labels are not used in Consul KV.

metadata

Why it fails: Metadata is not a field in the KV object.

tags

Why it fails: Tags are used for services, not KV.

The session stays active.

Why it fails: It will expire due to inactivity or health check failure.

The session is immediately deleted.

Why it fails: It remains until the TTL expires.

The session is transferred to another node.

Why it fails: Sessions are tied to the node's lifecycle.

server_dir

Why it fails: This setting does not exist.

kv_dir

Why it fails: This setting does not exist.

state_dir

Why it fails: This setting does not exist.

Direct file system access to KV data

Why it fails: Directly accessing the Raft log files is unsupported.

SQL queries

Why it fails: Consul does not support SQL.

Consul GUI (Web UI)

Why it fails: The Web UI allows viewing, but is not considered a primary programmatic interface for complex operations.

A 'write' ACL policy

Why it fails: While good for security, it is not part of the mechanics of locking itself.

A 'wait' parameter

Why it fails: Wait is for blocking queries.

sync=true

Why it fails: This parameter does not exist.

consistency=strong

Why it fails: Consistency parameter is for reads.

wait=majority

Why it fails: This parameter does not exist.

The write overwrites the lock.

Why it fails: Locks are exclusive.

The lock is transferred.

Why it fails: Locks are not transferred.

The write is queued.

Why it fails: Consul does not queue writes.

Keys can only contain alphanumeric characters

Why it fails: Keys can contain most characters.

All KV writes are synchronous across all nodes

Why it fails: Writes are synchronous across a quorum, not necessarily all nodes.

The KV store is limited to 1GB of data

Why it fails: There is no hard 1GB limit, but performance degrades with size.

transfer

Why it fails: This is not a session behavior.

terminate

Why it fails: This is not a session behavior.

Reading the key

Why it fails: Reads do not trigger watches.

Creating a new session

Why it fails: Sessions are independent of KV watches.

Changing the key's TTL

Why it fails: Keys do not have TTLs.

describe

Why it fails: Describe is not a valid KV command.

list

Why it fails: List is usually done via get with -recurse.

consul kv put app/config --file=config.json

Why it fails: The consul kv put command does not support a --file flag. It accepts the value as a positional argument, and file input is specified with the @ prefix. Using --file would result in an error or be ignored, and the value would not be read from the file.

consul kv import app/config config.json

Why it fails: There is no consul kv import subcommand. The available subcommands include put, get, delete, and export. Import is not part of the Consul KV CLI. This command would fail, and the configuration would not be stored.

consul kv put app/config < config.json

Why it fails: Shell redirection would pass the file content as standard input, but consul kv put does not read from stdin by default. It expects the value as an argument or via the @ syntax. Without @, the value would be empty or cause an error, so the file content would not be stored.

The service instance is using the 'stale' consistency mode, which does not return updates until the wait time expires.

Why it fails: The 'stale' consistency mode allows reads from any server, which may be slightly out of date, but it does not delay updates for the entire wait time. Blocking queries still return when the index changes or the wait time expires. So this is not the cause.

The service instance is querying a Consul server that is not the leader, and the leader did not propagate the update.

Why it fails: In Consul, any server can serve reads, and updates are replicated via Raft. A non-leader server may serve slightly stale data, but blocking queries will still return when the local state changes or the wait time expires. The leader propagates updates to followers, so the update would eventually be seen. This is not the primary cause.

The KV store is configured with a default ACL policy that denies read access, causing the query to hang.

Why it fails: If ACLs denied read access, the query would return a permission denied error immediately, not hang for the wait time. ACLs do not cause blocking queries to delay; they either allow or deny access. Thus, this is not the reason.

stale

Why it fails: Stale mode allows reads from any server, including those that may be out of date. It is even less consistent than default and is used to reduce latency by allowing reads from any datacenter. This does not meet the requirement for the most up-to-date value.

default

Why it fails: The default consistency mode allows reads from any Consul server, which may be stale if the server has not yet received the latest write. It provides better performance but does not guarantee strong consistency. In this scenario, you need the most up-to-date value, so default is not suitable.

linearizable

Why it fails: Linearizable is not a valid consistency mode for Consul KV reads. Consul supports 'default', 'stale', and 'consistent' modes. While linearizable is a consistency model in distributed systems, it is not a parameter value for Consul's KV API.

consul kv put ci/builds/ --empty

Why it fails: This writes an empty value at the key rather than removing the subtree. The nested keys remain in place, and the operation actually creates or overwrites a key, so it does the opposite of the intended cleanup.

consul kv delete -recurse ci/builds/

Why it fails: The -recurse flag is not a valid option for consul kv delete; recursion is triggered by the trailing slash on the key itself. Supplying an unsupported flag causes the command to fail with a usage error rather than deleting anything.

consul kv delete ci

Why it fails: Without a trailing slash, this targets only the literal key named ci. It would not remove nested keys under ci/builds, and if such a key existed it would also be a broader path than intended, so it does not satisfy the scoped deletion requirement.

Check the index of a key.

Why it fails: Checking the index is not a transaction operation. The transaction API supports only set, delete, and check-and-set operations. Index checking is used for blocking queries, not for atomic updates. It cannot be combined in a transaction to modify keys.

Acquire a lock on the key.

Why it fails: Locks are managed via sessions and are not direct transaction operations. While you can use a session to acquire a lock, the transaction API does not include a lock acquisition operation. Locks are separate from KV transactions and would not be part of a single atomic transaction.

Delete a key.

Why it fails: While deleting a key is a valid transaction operation, the scenario requires updating two keys, not deleting one. Deleting would remove the feature flag or rollout percentage, which is not desired. Therefore, delete is not part of the required atomic update.

The lock will be released immediately because Consul detects that the process holding the session is no longer running.

Why it fails: Consul does not track which OS process created a session. It only knows the session ID and the associated node. There is no process-level monitoring, so Consul cannot detect that the application process crashed. The lock remains until the session ends by TTL expiry, explicit destruction, or node failure.

The lock will be released after the key's default TTL of 15 seconds, regardless of the session TTL.

Why it fails: Consul KV keys do not have a default TTL. The only TTL involved is the session TTL, which you set when creating the session. There is no built-in key expiration mechanism in Consul KV, so the lock release timing is governed solely by the session lifecycle, not by any key TTL.

The lock will be released after the session TTL expires because the agent stops renewing the session when the application process exits.

Why it fails: The agent does not monitor application processes for session renewal. Session TTL renewal is performed by the agent on behalf of the session, independent of the application that created it. Unless the session is explicitly destroyed or the agent fails to renew, the lock remains held even after the application process exits.

Writes in Consul KV are always eventually consistent and may be lost if a server fails.

Why it fails: Writes in Consul are strongly consistent by default; they are committed via Raft and require a quorum of servers. They are not eventually consistent and are not lost if a quorum remains. This statement is false.

The 'default' consistency mode allows reads to be served by any server, which may be slightly stale.

Why it fails: The 'default' mode typically forwards reads to the leader to ensure strong consistency, unless 'stale' is specified. It does not allow any server to serve reads; that is the 'stale' mode. So this statement is incorrect.

The 'stale' consistency mode cannot be used for writes, only for reads.

Why it fails: Consistency modes apply to reads; writes are always strongly consistent in Consul. While it is true that 'stale' is not used for writes, the statement as phrased is misleading because it implies writes have a consistency mode option. In Consul, writes do not accept a consistency parameter; they are always consistent. Thus, this statement is not accurate.

Set the `stale` query parameter to allow the nearest server to answer.

Why it fails: The `stale` parameter permits any server, including non-leaders, to answer from local state, which can be arbitrarily behind the leader. That is the opposite of the requirement: it trades freshness for lower latency and reduced leader load. For lock values where staleness could cause split-brain decisions, stale reads are unsafe.

Set the `stale` parameter to false and rely on the default read mode.

Why it fails: Omitting `stale` yields the default read mode, which answers from the leader's local state. While usually fresh, it does not perform the leader-lease verification that guarantees no stale response after a leadership change. The scenario demands the strongest guarantee, so the default is insufficient.

Target the `/v1/kv/` path on a client agent with `?consistent`.

Why it fails: The `consistent` parameter forces a leader query but still allows the leader to answer from its local state without verifying it is still the leader through a quorum round. During a network partition a deposed leader could answer with stale data. This mode is stricter than default but weaker than the linearizable guarantee required here.