Redis CLI (redis-cli) basics - Deep Dive

Overview - Redis CLI (redis-cli) basics

What is it?

Redis CLI (redis-cli) is a simple command-line tool to interact with a Redis database. It lets you send commands to Redis, see responses, and manage data directly from your terminal. You can use it to add, read, update, or delete data stored in Redis. It works like a chat window where you type commands and Redis replies instantly.

Why it matters

Without Redis CLI, managing Redis would be harder because you would need to write programs or use complex tools just to check or change data. Redis CLI makes it easy to quickly test commands, debug issues, or explore your data. It helps developers and administrators work faster and understand what Redis is doing behind the scenes.

Where it fits

Before learning Redis CLI, you should know what Redis is and basic database concepts like keys and values. After mastering Redis CLI basics, you can learn scripting with Redis commands, use Redis in applications, or explore advanced Redis features like transactions and pub/sub messaging.

Mental Model

Core Idea

Redis CLI is your direct conversation line to Redis, letting you send commands and get instant answers in a simple text chat style.

Think of it like...

Using Redis CLI is like talking to a helpful librarian through a walkie-talkie: you ask for a book (data), and the librarian quickly tells you where it is or brings it to you.

┌─────────────┐       ┌─────────────┐
│  User types │──────▶│ redis-cli   │
│  commands   │       │  (client)   │
└─────────────┘       └─────┬───────┘
                             │
                             ▼
                      ┌─────────────┐
                      │ Redis Server│
                      │ (database)  │
                      └─────┬───────┘
                            │
                            ▼
                   ┌─────────────────┐
                   │ Command results  │
                   │ sent back to CLI │
                   └─────────────────┘

Build-Up - 6 Steps

1

Foundation

Connecting to Redis with redis-cli

Concept: How to start redis-cli and connect to a Redis server.

To start redis-cli, open your terminal and type 'redis-cli'. By default, it connects to Redis on your local machine at port 6379. If your Redis server is elsewhere, you can connect using 'redis-cli -h hostname -p port'. Once connected, you see a prompt where you can type commands.

Result

You get a prompt like '127.0.0.1:6379>' ready to accept Redis commands.

Knowing how to connect is the first step to using Redis CLI; without a connection, you cannot send commands or manage data.

2

Foundation

Basic Redis commands in CLI

Concept: Using simple commands to store and retrieve data.

Try commands like 'SET key value' to store data and 'GET key' to retrieve it. For example, 'SET name Alice' stores 'Alice' under 'name'. Then 'GET name' returns 'Alice'. You can also delete keys with 'DEL key'.

Result

Commands return simple replies like 'OK' for SET and the stored value for GET.

Understanding these basic commands lets you interact with Redis data directly and see immediate effects.

3

Intermediate

Using redis-cli for data inspection

🤔Before reading on: Do you think 'KEYS *' is a good way to list all keys in a large Redis database? Commit to your answer.

Concept: How to explore and inspect data stored in Redis using redis-cli commands.

You can list keys with 'KEYS pattern', for example 'KEYS *' lists all keys. Use 'TYPE key' to see the data type stored. Commands like 'TTL key' show how long a key will live before expiring. However, 'KEYS *' can be slow on big databases.

Result

You get lists of keys, their types, and expiration info, helping you understand your data layout.

Knowing how to inspect data helps you manage and debug Redis, but also teaches you to avoid commands that hurt performance.

4

Intermediate

Pipelining commands in redis-cli

🤔Before reading on: Do you think sending multiple commands one by one is faster or slower than sending them all at once in redis-cli? Commit to your answer.

Concept: Sending many commands together to improve speed using pipelining.

Redis CLI supports pipelining by entering multiple commands separated by newlines and then sending them all at once. This reduces network delays. For example, you can type several SET commands and then press Enter twice to send them together.

Result

Commands execute faster because Redis processes them in a batch without waiting for each reply individually.

Understanding pipelining helps you optimize performance when working with many commands, especially over slow networks.

5

Advanced

Using redis-cli for scripting and automation

🤔Before reading on: Can redis-cli run Lua scripts directly? Commit to your answer.

Concept: Running Lua scripts and automating tasks with redis-cli.

Redis supports Lua scripting for complex operations. You can run scripts with 'EVAL' command in redis-cli. For example, 'EVAL "return redis.call(\'GET\', KEYS[1])" 1 keyname' runs a script that gets a key's value. This allows atomic and complex operations.

Result

You can perform multi-step logic inside Redis safely and efficiently.

Knowing scripting in redis-cli unlocks powerful Redis features beyond simple commands, enabling automation and atomicity.

6

Expert

Understanding redis-cli internals and protocol

🤔Before reading on: Do you think redis-cli sends commands as plain text or uses a special format? Commit to your answer.

Concept: How redis-cli communicates with Redis server using the Redis Serialization Protocol (RESP).

Redis CLI sends commands using RESP, a simple, efficient format that encodes commands and responses. This protocol uses special characters to mark data types and lengths, making communication fast and reliable. Redis-cli translates your typed commands into RESP messages and parses RESP replies back to readable text.

Result

Commands and replies are exchanged in a structured way that ensures correctness and speed.

Understanding the protocol explains why redis-cli is fast and reliable, and helps when debugging low-level issues or building custom clients.

Under the Hood

Redis CLI acts as a client that connects to the Redis server over TCP/IP. When you type a command, redis-cli converts it into the Redis Serialization Protocol (RESP) format, sends it to the server, and waits for a response. The server processes the command, executes it on its in-memory data, and sends back a RESP-formatted reply. Redis-cli then parses this reply and displays it in a human-readable form.

Why designed this way?

Redis-cli was designed to be lightweight and fast, using RESP to minimize data size and parsing complexity. This design allows quick command execution and easy debugging. The simplicity of RESP also makes it easy to implement clients in many languages, promoting Redis's wide adoption.

User Input
   │
   ▼
┌─────────────┐
│ redis-cli   │
│ (client)    │
└─────┬───────┘
      │ Convert to RESP
      ▼
┌─────────────┐
│ TCP Socket  │
└─────┬───────┘
      │ Send RESP
      ▼
┌─────────────┐
│ Redis Server│
│ (process)   │
└─────┬───────┘
      │ RESP reply
      ▼
┌─────────────┐
│ TCP Socket  │
└─────┬───────┘
      │ Receive RESP
      ▼
┌─────────────┐
│ redis-cli   │
│ (parse &   │
│ display)   │
└─────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does 'KEYS *' perform well on large Redis databases? Commit to yes or no.

Common Belief: Many believe 'KEYS *' is safe and fast to use anytime to list all keys.

Reality: 'KEYS *' scans the entire database and can block Redis, causing slowdowns or outages on large datasets.

Why it matters: Using 'KEYS *' in production can freeze your Redis server, affecting all applications relying on it.

Quick: Does redis-cli automatically reconnect if the Redis server goes down? Commit to yes or no.

Common Belief: Some think redis-cli keeps trying to reconnect automatically if the connection drops.

Reality: Redis-cli exits immediately on connection loss; it does not auto-reconnect.

Why it matters: Assuming auto-reconnect can cause confusion and lost commands during network issues.

Quick: Can redis-cli run multiple commands atomically by default? Commit to yes or no.

Common Belief: People often think typing multiple commands in redis-cli runs them all atomically.

Reality: Each command runs separately unless wrapped in a MULTI/EXEC transaction or Lua script.

Why it matters: Misunderstanding atomicity can lead to race conditions and data inconsistency.

Quick: Does redis-cli send commands as plain text over the network? Commit to yes or no.

Common Belief: Some believe redis-cli sends commands as plain text strings directly.

Reality: Redis-cli uses RESP, a structured protocol, not plain text, to communicate with Redis.

Why it matters: Knowing this helps understand Redis's speed and why clients must follow RESP format.

Expert Zone

1

Redis-cli supports raw mode to send binary-safe commands, which is crucial for keys or values containing special characters.

2

The latency of redis-cli commands can be affected by network round-trips; pipelining reduces this by batching commands.

3

Redis-cli can be scripted with input redirection or here-documents, enabling automation without writing full programs.

When NOT to use

Redis-cli is not suitable for high-throughput or complex application logic; use Redis client libraries in programming languages instead. For large data scans, use SCAN command or Redis modules designed for analytics.

Production Patterns

In production, redis-cli is mainly used for debugging, quick checks, and manual data fixes. Automation scripts often use redis-cli in batch mode. Monitoring tools may invoke redis-cli commands to gather metrics.

Connections

Command Line Interfaces (CLI)

Redis-cli is a specific example of a CLI tool for databases.

Understanding redis-cli helps grasp how CLIs provide direct, text-based control over software, a pattern common in many tools.

Network Protocols

Redis-cli communicates using the Redis Serialization Protocol (RESP), a network protocol.

Knowing redis-cli's use of RESP reveals how protocols structure data exchange efficiently, a concept vital in networking and distributed systems.

Human-Computer Interaction (HCI)

Redis-cli's prompt and immediate feedback exemplify interactive command-line design.

Studying redis-cli shows how simple interfaces can provide powerful control, informing design of user-friendly developer tools.

Common Pitfalls

#1 Trying to list all keys in a large Redis database with 'KEYS *'.

Wrong approach:

redis-cli> KEYS *

Correct approach:

redis-cli> SCAN 0

Root cause:

Misunderstanding that 'KEYS *' blocks Redis and does not scale; SCAN is the non-blocking alternative.

#2 Assuming redis-cli reconnects automatically after server restart.

Wrong approach:

Start redis-cli once and expect it to reconnect if Redis restarts.

Correct approach:

Manually restart redis-cli after Redis server restarts.

Root cause:

Not knowing redis-cli exits on connection loss and requires manual restart.

#3 Sending multiple commands expecting atomic execution without transactions.

Wrong approach:

redis-cli> SET key1 val1
SET key2 val2

Correct approach:

redis-cli> MULTI
SET key1 val1
SET key2 val2
EXEC

Root cause:

Confusing command batching with atomic transactions.

Key Takeaways

Redis CLI is a simple, direct way to communicate with Redis using typed commands and immediate responses.

It uses a special protocol (RESP) to send commands and receive replies efficiently and reliably.

Basic commands like SET and GET let you store and retrieve data quickly from the command line.

Advanced features like pipelining and scripting unlock powerful performance and automation capabilities.

Understanding redis-cli's limits and proper usage prevents common mistakes that can harm Redis performance or data integrity.

Practice

1. What does the Redis CLI command SET key value do?

easy

A. Retrieves the value of the key

B. Deletes the key from Redis

C. Stores the value under the given key in Redis

D. Lists all keys in Redis

Solution

1. Step 1: Understand the SET command

   The SET command in Redis stores a value under a specified key.

2. Step 2: Match command to action

   Since SET assigns a value to a key, it stores data rather than deleting or retrieving it.

3. Final Answer:

   Stores the value under the given key in Redis -> Option C

4. Quick Check:

   SET command = store value [OK]

Hint: SET means store a value for a key [OK]

Common Mistakes:

• Confusing SET with GET
• Thinking SET deletes keys
• Assuming SET lists keys

2. Which of the following is the correct syntax to get the value of a key named user1 in Redis CLI?

easy

A. KEYS user1

B. GET user1

C. DEL user1

D. SET user1

Solution

1. Step 1: Identify the command to retrieve a value

   The GET command is used to fetch the value stored at a key in Redis.

2. Step 2: Check syntax correctness

   GET followed by the key name is the correct syntax to get the value of 'user1'.

3. Final Answer:

   GET user1 -> Option B

4. Quick Check:

   GET command syntax = GET key [OK]

Hint: GET retrieves value, SET stores, DEL deletes [OK]

Common Mistakes:

• Using SET instead of GET
• Using DEL to get value
• Using KEYS to get value

3. What will be the output of the following Redis CLI commands?

SET count 10
INCR count
GET count

medium

A. "11"

B. "10"

C. Error: wrong type operation

D. nil

Solution

1. Step 1: Analyze the commands step-by-step

   SET count 10 stores the string "10" under key 'count'. INCR count increments the integer value by 1.

2. Step 2: Understand INCR effect and GET result

   INCR converts the string "10" to integer 10, adds 1 to make 11. GET count returns "11" as a string.

3. Final Answer:

   "11" -> Option A

4. Quick Check:

   INCR on "10" = "11" [OK]

Hint: INCR adds 1 to numeric string values [OK]

Common Mistakes:

• Expecting original value "10"
• Thinking INCR causes error
• Expecting nil for existing key

4. You run the command GET mykey but get an error: WRONGTYPE Operation against a key holding the wrong kind of value. What is the likely cause?

medium

A. The key holds a non-string value like a list or set

B. The key does not exist

C. The Redis server is down

D. The GET command is misspelled

Solution

1. Step 1: Understand the error message

   The error means GET was used on a key that stores a data type other than string, like a list or set.

2. Step 2: Identify the cause from options

   Since the key exists but is not a string, GET cannot retrieve it, causing the error.

3. Final Answer:

   The key holds a non-string value like a list or set -> Option A

4. Quick Check:

   WRONGTYPE error = wrong data type for GET [OK]

Hint: GET works only on string keys, not lists or sets [OK]

Common Mistakes:

• Thinking key does not exist
• Assuming server is down
• Misspelling GET causes this error

5. You want to store a user's name and age in Redis using redis-cli. Which sequence of commands correctly stores the name "Alice" and age 30, then retrieves both values?

hard

A. SET user:name Alice
SET user:age 30
HGET user:name
HGET user:age

B. LPUSH user Alice 30
LRANGE user 1 1

C. SET user Alice 30
GET user

D. HSET user name Alice age 30
HGET user name
HGET user age

Solution

1. Step 1: Identify the best data structure for multiple fields

   Using a hash (HSET) allows storing multiple fields like name and age under one key.

2. Step 2: Check commands for storing and retrieving fields

   HSET user name Alice age 30 stores both fields. HGET user name and HGET user age retrieve them separately.

3. Final Answer:

   HSET user name Alice age 30 HGET user name HGET user age -> Option D

4. Quick Check:

   Use hashes for multiple related fields [OK]

Hint: Use HSET/HGET for multiple fields in one key [OK]

Common Mistakes:

• Using SET with multiple values
• Using list commands for key-value pairs
• Trying to GET multiple values at once