시작하기
Redis 연결
redis-cli가 표준 명령줄 클라이언트입니다. 연결 테스트는 PING입니다(PONG 반환). 프로덕션에서는 항상 AUTH 명령이나 -a 플래그를 쓰세요. 공유 환경에서는 비밀번호를 명령줄에 두지 말고 REDISCLI_AUTH 환경 변수를 쓰세요. 현대 Redis(6+)는 범위 지정 권한의 ACL 기반 사용자를 지원합니다.
# connect to a local server (default port 6379)
redis-cli
# connect with a specific host and port
redis-cli -h host.example.com -p 6380
# connect with authentication
redis-cli -a "yourpassword"
redis-cli -h host -p 6379 -a "yourpassword"
# connect over TLS
redis-cli --tls --cert client.crt --key client.key -h host -p 6379
# test the connection
PING # returns PONG
PING "hello" # returns "hello"데이터베이스 선택과 기본
Redis 데이터베이스는 격리된 스키마가 아니라 (0~15로 번호 매겨진) 논리 네임스페이스이며 같은 메모리를 공유합니다. 대부분의 앱은 db 0만 씁니다. FLUSHDB가 현재 db를, FLUSHALL이 전부를 지웁니다. 단일 스레드를 공유하고 개별 설정이 안 되므로 별도 Redis 인스턴스나 키 접두어가 다중 데이터베이스보다 권장됩니다.
# Redis has 16 logical databases (0-15) by default
SELECT 0 # switch to database 0
SELECT 15 # switch to database 15
# move a key to another database
MOVE mykey 1
# flush the current database (DESTRUCTIVE)
FLUSHDB
# flush ALL databases (VERY DESTRUCTIVE)
FLUSHALL
# get the number of keys in the current db
DBSIZE
# get basic server info
INFO server
INFO memory
INFO replication키와 일반 연산
KEYS는 스캔 중 서버를 막으므로 큰 데이터셋의 프로덕션에서 절대 쓰지 말고 (커서 기반, 논블로킹인) SCAN을 쓰세요. 가독성을 위해 키는 콜론으로 구조화하세요(user:1:profile). EX가 초 단위, PX가 밀리초 단위 만료입니다. TYPE이 자료구조(string, list, hash, set, zset, stream)를 반환합니다.
# set and get a key
SET user:1 "Alice"
GET user:1
# check if a key exists
EXISTS user:1 # 1 if exists, 0 if not
# delete keys
DEL user:1
DEL key1 key2 key3 # returns number deleted
# set a key with expiration (seconds)
SET session:abc "data" EX 3600
# find keys matching a pattern (avoid in production)
KEYS user:*
SCAN 0 MATCH user:* COUNT 100 # safer iteration
# rename a key
RENAME oldkey newkey
# get the type of a value stored at a key
TYPE user:1만료와 TTL
TTL은 없는 키에 -2를, 만료 없는 키에 -1을 반환합니다. 만료는 지연 방식이며 Redis는 키 접근이나 주기적 백그라운드 스윕 때만 검사합니다. EX를 준 SET은 원자적입니다(SET과 EXPIRE 사이 경쟁 없음). 기본적으로 만료된 키는 이벤트를 트리거하지 않으며 필요하면 keyspace 알림을 켜세요.
# set expiration on an existing key
EXPIRE user:1 60 # 60 seconds
EXPIREAT user:1 1700000000 # Unix timestamp
# set expiration in milliseconds
PEXPIRE user:1 60000
# view remaining time to live (seconds)
TTL user:1 # -2 if no key, -1 if no expiry
# view TTL in milliseconds
PTTL user:1
# remove expiration (make key persistent)
PERSIST user:1
# set value AND expiration atomically
SET token "abc" EX 3600SCAN과 안전한 순회
SCAN이 KEYS의 프로덕션 안전 대안입니다. 0으로 돌아올 때까지 따라 가는 커서를 반환합니다. COUNT는 (정확한 값이 아니라) 힌트이며 더 많거나 적게 반환할 수 있습니다. SCAN은 약한 보장을 제공합니다. 순회 중 추가된 키를 중복 반환하거나 놓칠 수 있지만 절대 막지 않습니다. 컬렉션 타입에는 HSCAN/SSCAN/ZSCAN을 쓰세요. 커서 루프는 항상 코드에서 처리하세요.
# SCAN: cursor-based iteration (non-blocking)
SCAN 0 MATCH user:* COUNT 100
# returns: [nextCursor, [key1, key2, ...]]
SCAN <nextCursor> MATCH user:* COUNT 100
# continue until cursor returns to 0
# scan a specific type
SCAN 0 TYPE hash
# HSCAN: iterate hash fields
HSCAN myhash 0 MATCH field* COUNT 100
# SSCAN: iterate set members
SSCAN myset 0 MATCH member* COUNT 100
# ZSCAN: iterate sorted set members
ZSCAN myzset 0 MATCH member* COUNT 100데이터 타입 개요
핵심 자료구조
올바른 자료구조 선택이 Redis의 핵심 기술입니다. 카운터/캐시는 문자열, 객체는 해시, 큐는 리스트, 고유성/태그는 셋, 리더보드/순위는 정렬 셋, 이벤트 로그는 스트림. 자료구조의 각 연산이 원자적이므로 동시 클라이언트가 상태를 망치지 못합니다. 접근 패턴에 맞는 구조를 고르세요.
# Redis is a data structure server, not just a key-value store
# Each key holds a typed data structure:
# String: binary-safe blob (up to 512MB)
SET key "value"
SET counter 100
# List: ordered, linked-list of strings
LPUSH mylist "a" "b"
RPUSH mylist "c"
# Hash: field-value map (like a small object)
HSET user:1 name "Alice" age 30
# Set: unordered collection of unique strings
SADD tags "redis" "db"
# Sorted Set (ZSet): set scored by a float
ZADD leaderboard 100 "alice" 200 "bob"
# Stream: append-only log with IDs
XADD mystream * field value
# Bitmap, HyperLogLog, Geo: built on strings/zsets올바른 타입 선택
접근 패턴으로 타입을 고르세요. 고유성이 필요하면 셋, 점수순 정렬이 필요하면 정렬 셋, 객체의 한 필드 갱신이 필요하면 (직렬화된 문자열이 아니라) 해시, 규모 있는 근사 고유 개수가 필요하면 (수십억 항목에 12KB의) HyperLogLog. 올바른 타입 선택 = 더 단순한 코드, 원자적 연산, 극적인 메모리 절약입니다.
# Use case -> data type mapping:
# Cache a string -> String
SET api:response "json_blob"
# Store an object -> Hash (one key, multiple fields)
HSET user:1 name "Alice" email "[email protected]" age 30
# Queue / stack -> List
LPUSH tasks "job1" # push to head
RPOP tasks # pop from tail (FIFO queue)
# Unique tags -> Set
SADD post:1:tags "redis" "db" "cache"
# Leaderboard -> Sorted Set
ZADD scores 100 "alice" 250 "bob"
ZREVRANGE scores 0 9 # top 10
# Event log -> Stream
XADD events * type click user 1
# Count unique -> HyperLogLog (approximate, fixed memory)
PFADD visitors "user1" "user2"메모리 인코딩
Redis가 작은 구조에 (listpack, intset 같은) 컴팩트 인코딩을 써 메모리를 5~10배 아끼고, 커지면 해시 테이블/스킵리스트로 자동 전환합니다. 현재 인코딩 확인은 OBJECT ENCODING이고 바이트 보고는 MEMORY USAGE입니다. (hash-max-listpack-entries 같은) 임계값을 튜닝할 수 있지만 기본값이 잘 골라져 있습니다. 용량 계획에는 인코딩 이해가 도움이 됩니다.
# Redis optimizes storage based on size
# Inspect the internal encoding of a key
OBJECT ENCODING mykey
# String encodings:
# "embstr" - short strings (< 44 bytes)
# "raw" - long strings
# "int" - integer values
# Hash/List/Set/ZSet encodings:
# "listpack" / "intset" - small (compact, memory-efficient)
# "hashtable" / "list" / "skiplist" - large (faster, more memory)
# check memory usage of a key
MEMORY USAGE mykey
# sample memory usage stats
MEMORY STATS
# the encoding changes automatically as the structure growsOBJECT와 메모리 명령
OBJECT IDLETIME은 (거의 접근되지 않는) 콜드 캐시 키 찾기에 유용하고, OBJECT FREQ는 maxmemory-policy가 LFU일 때만 동작합니다. SAMPLES 0을 준 MEMORY USAGE가 정확히 셉니다(큰 컬렉션은 기본 샘플링). 구조화된 문서 반환은 (Redis 7+의) COMMAND DOCS입니다. 이 인트로스펙션 도구들이 메모리 비대 디버깅과 eviction 정책 튜닝에 도움이 됩니다.
# OBJECT subcommands for introspection
OBJECT ENCODING mykey # internal encoding
OBJECT REFCOUNT mykey # reference count
OBJECT IDLETIME mykey # seconds since last access
OBJECT FREQ mykey # access frequency (LFU mode)
# check memory usage (bytes) of a key
MEMORY USAGE mykey
MEMORY USAGE mykey SAMPLES 0 # exact count
# total memory used by the server
INFO memory | grep used_memory_human
# help understand a command
COMMAND INFO GET
COMMAND DOCS SET
# COMMAND lists all commands (huge output)
COMMAND타입 오류와 타입 검사
키의 타입은 수명 동안 고정입니다. 먼저 삭 제하지 않으면 같은 키를 다른 타입으로 재사용할 수 없습니다. WRONGTYPE 오류가 실수로 인한 타입 혼동을 막습니다. 출처를 모르는 키를 다룰 때는 항상 TYPE을 확인하세요. 이 엄격한 타이핑 때문에 Redis 명령이 타입 접두어를 씁니다(HSET vs SET vs SADD).
# each key has ONE type; using the wrong command fails
SET mykey "hello"
LPUSH mykey "x" # WRONGTYPE error
# WRONGTYPE Operation against a key holding the wrong kind of value
# check the type before operating
TYPE mykey # "string"
if [ "$(TYPE mykey)" = "string" ]; then ...
# TYPE returns: string|list|hash|set|zset|stream|none
# rename preserves the type
RENAME mykey newkey
TYPE newkey # still "string"
# type is immutable; delete + recreate to change types
DEL mykey
LPUSH mykey "x" # now a list문자열
기본 문자열 연산
문자열은 바이너리 안전하며 (이미지나 JSON 포함) 최대 512MB의 임의 바이트를 담습니다. NX를 준 SET이 고전 Redis 락 프리미티브입니다(not exists면 set). 원자적이며 설정 교체에 유용한 것은 GETSET이고, 문자열 확장은 SETRANGE입니다. 구조화 데이터에는 필드별 갱신이 가능한 직렬화 JSON 문자열보다 해시를 선호하세요.
# set and get
SET mykey "hello"
GET mykey # "hello"
# set only if not exists (NX) or only if exists (XX)
SET mykey "new" NX # set only if key does NOT exist
SET mykey "new" XX # set only if key DOES exist
SET mykey "new" EX 60 NX # with expiry, only if new
# get and set atomically (returns old value)
GETSET counter 0 # returns old value, sets new
# append to a string
APPEND mykey " world" # "hello world"
# get substring
GETRANGE mykey 0 4 # "hello"
SETRANGE mykey 6 "redis"# "hello redis"
# get string length
STRLEN mykey # 11숫자 카운터
INCR/DECR은 원자적이므로 락 없이 동시 접근에 안전합니다. 이것이 Redis를 카운터, 레이트 리밋(INCR + EXPIRE), 시퀀스 ID 생성에 이상적으로 만듭니다. INCRBYFLOAT가 소수를 지원하지만 배정밀도를 쓰므로(반올림 주의) 값이 정수가 아니면 INCR은 오류를 반환합니다. 시간 버킷 통계에는 EXPIRE와 결합하는 것이 최선입니다.
# increment a numeric string atomically
INCR counter # counter = counter + 1
INCRBY counter 10 # counter = counter + 10
# decrement
DECR counter # counter = counter - 1
DECRBY counter 5 # counter = counter - 5
# floating point operations
SET price "10.50"
INCRBYFLOAT price 0.25 # "10.75"
INCRBYFLOAT price -1.00 # "9.75"
# all increment ops are atomic and concurrency-safe
# use for: counters, rate limiting, sequence IDs, stats다중 키 연산
MSET/MGET이 연산을 한 번의 왕복으로 배칭하며 성능에 필수입니다(Redis 단일 스레드 모델은 명령당 오버헤드가 중요). MSETNX은 원자적입니다. 모든 키가 설정되거나 하나도 안 됩니다(all-or-nothing). (6.2+의) GETDEL이 원자적으로 반환하고 삭제하며 일회성 읽기 메시지 패턴에 유용합니다. 네트워크 지연을 줄이려 가능하면 명령을 배칭하세요.
# set multiple keys at once (atomic)
MSET k1 "v1" k2 "v2" k3 "v3"
# get multiple keys at once
MGET k1 k2 k3 # ["v1", "v2", "v3"]
# set multiple only if ALL keys are new
MSETNX k1 "v1" k4 "v4" # 1 if all set, 0 if any existed
# MSET/MGET reduce round-trips — much faster than
# separate SET/GET calls in a loop
# get the length of a string value
STRLEN k1 # 2
# atomic get-and-delete (useful for queues)
GETDEL mykey # returns value AND deletes key비트맵 (문자열 기반)
비트맵은 약 512MB로 최대 40억 사용자의 불리언 플래그를 저장합니다. 대규모 인구에서 극히 공간 효율적입니다. 비트맵 결합은 BITOP AND/OR/XOR/NOT이며(예: 여러 날 활동 사용자) 활성 사용자 세기는 BITCOUNT입니다. 사용 사례: DAU, 피처 플래그, 출석 추적. 위치 = 사용자 ID.
# bitmaps are strings operated on at the bit level
# great for boolean flags on a large user base
# set bit at position (0 or 1)
SETBIT user:1:active 7 1 # user 1 active
GETBIT user:1:active 7 # 1
# count set bits
BITCOUNT user:1:active # total bits set to 1
# bitwise operations between strings
SETBIT users:daily:2025-01-01 5 1
SETBIT users:daily:2025-01-02 5 1
BITOP AND active-both users:daily:2025-01-01 users:daily:2025-01-02
BITCOUNT active-both # users active on both days
# find the first set bit
BITPOS user:1:active 1 # position of first 1-bitBitfield 연산
BITFIELD가 여러 작은 카운터를 하나의 문자열에 담습니다. 예: 1000개 일일 카운터를 u8로 1KB에. OVERFLOW SAT가 최대에서 포화되고(통계에 좋음), FAIL이 오버플로 시 nil을 반환하고(상한에 좋음), WRAP이 감싸입니다(기본, 보통 원치 않음). 많은 작은 카운터의 별도 키보다 훨씬 메모리 효율적입니다.
# BITFIELD: multiple counters in one string (compact)
# store up to 2^63 counters, each 1-64 bits, in a single key
# set a 8-bit unsigned counter at offset 0
BITFIELD mycount SET u8 0 100
# increment a counter (with overflow control)
BITFIELD mycount INCRBY u8 0 10 # returns 110
BITFIELD mycount INCRBY u8 0 10 # returns 120
# overflow control: WRAP (default), SAT, FAIL
BITFIELD mycount OVERFLOW SAT INCRBY u8 0 200 # saturates at 255
BITFIELD mycount OVERFLOW FAIL INCRBY u8 0 999 # returns nil (overflow)
# read multiple counters in one call
BITFIELD mycount GET u8 0 GET u8 8 GET u8 16해시
해시 기본
해시가 객체 저장에 이상적입니다. 객체당 키 하나, 속성당 필드. 읽기-수정-쓰기 없이 개별 필드를 (HSET으로) 원자적으로 갱신할 수 있어 JSON 직렬화를 이깁니다. 전체 필드는 HGETALL이며 큰 해시에는 HSCAN을 선호하세요. (약 128 필드 미만의) 작은 해시는 listpack 인코딩을 써 메모리 효율적입니다.
# a hash maps fields to values (like a small object)
HSET user:1 name "Alice" age 30 email "[email protected]"
# get a single field
HGET user:1 name # "Alice"
# get multiple fields
HMGET user:1 name age # ["Alice", "30"]
# get all fields and values
HGETALL user:1
# name -> Alice
# age -> 30
# email -> [email protected]
# get all field names or values
HKEYS user:1 # [name, age, email]
HVALS user:1 # [Alice, 30, [email protected]]
# get the number of fields
HLEN user:1 # 3해시 필드 연산
HSETNX가 필드 수준 'set if not exists'를 제공합니다(일회성 초기화에 유용). 해시 필드의 HINCRBY는 원자적으로 사용자별 카운터(로그인 수, 조회 수)에 완벽합니다. 마지막 필드가 제거되면 해시가 자동 삭제됩니다(HDEL). HSET이 이제 여러 필드를 받으므로 HMSET은 폐기 예정이며 항상 HSET을 쓰세요.
# set a field only if it doesn't exist
HSETNX user:1 status "new" # 1 if set, 0 if existed
# delete a field
HDEL user:1 email # removes the email field
# check if a field exists
HEXISTS user:1 name # 1 if exists, 0 if not
# increment a numeric field atomically
HINCRBY user:1 age 1 # age = 31
HINCRBY user:1 age -5 # age = 26
HINCRBYFLOAT user:1 score 0.5
# get the string length of a field's value
HSTRLEN user:1 name # 5 (length of "Alice")
# set multiple fields (same as HSET with multiple)
HMSET user:1 a 1 b 2 # deprecated, use HSET해시 순회
HGETALL은 큰 해시에서 서버를 막으므로 프로덕션 순회에는 HSCAN을 쓰세요. HSCAN은 커서 기반으로 커서가 0으로 돌아올 때까지 반복 호출합니다. COUNT는 힌트입니다. (6.2+의) HRANDFIELD가 (랜덤 피처 플래그 같은) 샘플링에 유용합니다. 수백만 필드의 해시는 샤딩으로 여러 키로 쪼개는 것을 고려하세요.
# HSCAN: cursor-based iteration (for large hashes)
HSCAN user:1 0 MATCH "na*" COUNT 10
# returns [cursor, [field, value, field, value, ...]]
# iterate all fields
cursor=0
while true:
cursor, fields = HSCAN user:1 cursor COUNT 100
process(fields)
if cursor == 0: break
# HGETALL is fine for small hashes (< 100 fields)
# HSCAN is required for large hashes to avoid blocking
# get a random field
HRANDFIELD user:1 # one random field name
HRANDFIELD user:1 3 # 3 random field names
HRANDFIELD user:1 3 WITHVALUES # fields + values해시 만료 (Redis 7.4+)
필드 수준 TTL(7.4+)이 해시의 주요 기능입니다. 이전에는 개별 필드 만료에 별도 키나 우회가 필요했습니다. 수명이 섞인 객체에 유용합니다(세션 토큰은 만료되지만 이름은 남는 사용자 프로필). 오래된 Redis 버전은 만료 필드를 자기 EXPIRE가 있는 별도 키로 저장해야 합니다.
# before 7.4, expiration was only at the key level
EXPIRE user:1 3600 # the whole hash expires
# Redis 7.4+: field-level TTL (HEXPIRE)
HEXPIRE user:1 60 FIELDS 1 session_token
# expires only the session_token field in 60 seconds
# get TTL of a specific field
HPTTL user:1 FIELDS 1 session_token
# persist a specific field (remove its TTL)
HPERSIST user:1 FIELDS 1 session_token
# get all fields and their expiration times
HEXPIRETIME user:1 FIELDS 1 session_token해시 사용 사례
해시가 객체와 그룹 카운터에서 빛납니다. 강력한 메모리 기법: 작은 문자열 키가 많으면 하나의 해시로 묶으세요. listpack 인코딩이 (각각 메타데이터를 가진) 수천 개 개별 키보다 오버헤드가 훨씬 적습니다. 이 '키 버킷팅'이 작은 값의 메모리 사용을 5~10배 줄일 수 있습니다.
# 1. Store an object (user profile, config)
HSET config:app name "MyApp" version "2.0" debug "off"
# 2. Per-user counters
HINCRBY user:1:stats logins 1
HINCRBY user:1:stats page_views 1
HGET user:1:stats logins
# 3. Shopping cart (product_id -> quantity)
HSET cart:user:1 product:100 2
HINCRBY cart:user:1 product:100 1
HDEL cart:user:1 product:100
# 4. Feature flags
HSET feature_flags user:1 new_ui 1 beta 0
HGET feature_flags user:1 new_ui # 1
# 5. Group small key-value pairs into one hash (memory savings)
# instead of SET k1 v1; SET k2 v2 -> HSET bucket k1 v1 k2 v2리스트
리스트 기본 (Push/Pop)
리스트가 양단이므로 LPUSH+RPOP = 큐(FIFO), LPUSH+LPOP = 스택(LIFO)입니다. BLPOP/BRPOP이 항목이 생길 때까지 막으며 Redis 큐의 기반입니다(폴링 불필요). 연결 끊김 처리를 위해 BLPOP에는 항상 타임아웃을 설정하세요. 리스트는 머리/꼬리 연산이 O(1)이지만 중간 접근은 O(N)입니다.
# lists are ordered sequences of strings (linked lists)
# push to head (left) or tail (right)
LPUSH mylist "a" "b" # list: [b, a]
RPUSH mylist "c" # list: [b, a, c]
# pop from head or tail
LPOP mylist # "b" (removes from head)
RPOP mylist # "c" (removes from tail)
# pop multiple
LPOP mylist 2 # ["a", ...]
# get length
LLEN mylist # 0
# blocking pop (waits if empty, up to timeout)
BLPOP queue:tasks 30 # blocks up to 30 seconds
BRPOP queue:tasks 0 # blocks forever리스트 인덱싱과 범위
LRANGE 0 -1이 전체 리스트를 반환합니다. (최신 100 이벤트만 유지하는 식의) 리스트 크기 제한 흔한 패턴은 LTRIM입니다. 값 기반 제거는 LREM이며(count: 양수=머리, 음수=꼬리, 0=전부) 중간 요소의 LINDEX는 O(N)입니다. 리스트는 끝 접근에 최적화되어 인덱스 랜덤 접근에는 다른 구조를 쓰세요.
# get element by index (0-based, O(N) traversal)
LINDEX mylist 0 # first element
LINDEX mylist -1 # last element
# get a range of elements
LRANGE mylist 0 -1 # all elements
LRANGE mylist 0 2 # first 3 elements
LRANGE mylist -3 -1 # last 3 elements
# set an element by index
LSET mylist 1 "new"
# get length
LLEN mylist
# trim to a range (removes everything outside)
LTRIM mylist 0 99 # keep only first 100 elements
# remove elements by value
LREM mylist 2 "value" # remove first 2 occurrences of "value"
LREM mylist -2 "value" # remove last 2 occurrences큐로서의 리스트
BRPOPLPUSH/BLMOVE가 항목을 소스에서 대상으로 원자적으로 옮깁니다. 소비자가 안전히 처리할 수 있고 크래시해도 항목이 대상에 남습니다(신뢰 큐 패턴). BRPOP 후 처리보다 낫습니다. BRPOP 뒤 크래시는 항목을 잃습니다. 처리 후에는 대상 리스트에서 삭제하세요.
# simple FIFO queue: LPUSH to add, RPOP to consume
LPUSH tasks "job1" "job2"
RPOP tasks # "job1" (FIFO order)
# reliable queue with BRPOP (blocking, waits for work)
BRPOP tasks 0 # blocks until a task is available
# move items between lists atomically
LPUSH source "item"
RPOPLPUSH source destination # move one item
# blocking move (reliable queue pattern)
BRPOPLPUSH source destination 30 # blocks up to 30s
# Redis 6.2+: BLMOVE replaces BRPOPLPUSH
BLMOVE source destination RIGHT LEFT 30
# capped queue (e.g., recent events)
LPUSH recent "event"
LTRIM recent 0 99 # keep latest 100리스트 삽입과 제거
LINSERT는 O(N)이므로 큰 리스트에서는 아껴 쓰세요. 제거 없이 요소 위치 찾기는 LPOS입니다. (7.0+의) LMPOP이 한 번의 호출로 여러 리스트에서 pop하며 우선순위 큐에 유용합니다. 잦은 리스트 중간 연산에는 리스트가 잘못된 선택이므로 정렬 셋이나 다른 데이터 모델을 고려하세요.
# insert before or after a pivot element
LINSERT mylist BEFORE "pivot" "new"
LINSERT mylist AFTER "pivot" "new"
# remove elements by value
LREM mylist 1 "value" # remove first occurrence from head
LREM mylist -1 "value" # remove first occurrence from tail
LREM mylist 0 "value" # remove ALL occurrences
# pop and push in one atomic operation
RPOPLPUSH source dest
# get and remove from both ends (6.2+)
LPOP mylist 2 # pop 2 from head
LMPOP 2 mylist LEFT COUNT 3 # (7.0+) pop from one of multiple lists
# find the position of an element (6.0+)
LPOS mylist "value"
LPOS mylist "value" RANK 2 # find 2nd occurrence리스트 사용 사례
리스트가 끝 접근 패턴의 시퀀스에 최선입니다. 큐, 스택, 피드, 버퍼. LTRIM이 (상한이 있는) 로그/피드에 이상적입니다. 레이트 리밋은 타임스탬프 리스트 + LTRIM이 간단한 슬라이딩 윈도우입니다. 정렬/우선순위 큐에는 정렬 셋을 쓰세요. 리스트는 중복 제거를 지원하지 않으니 그건 셋입니다.
# 1. Task queue (FIFO)
LPUSH tasks "process_order:123"
BRPOP tasks 30
# 2. Recent activity feed (capped)
LPUSH user:1:feed "post:99" "post:98"
LTRIM user:1:feed 0 49 # latest 50
# 3. Stack (LIFO)
LPUSH stack "item"
LPOP stack
# 4. Circular buffer (limited size)
LPUSH buffer "new"
LTRIM buffer 0 999 # keep 1000 items
# 5. Rate limiter (sliding window)
LPUSH rate:user:1 <timestamp>
LTRIM rate:user:1 0 99
LLEN rate:user:1 # request count in window셋
셋 기본
셋이 고유 값을 저장합니다. 태그, 카테고리, 중복 제거에 완벽합니다. SISMEMBER는 O(1)로 리스트 검사보다 훨씬 빠릅니다. SMEMBERS는 큰 셋에서 막을 수 있으므로 순회에는 SSCAN입니다. 제거하지 않는 샘플은 SRANDMEMBER, 제거하는 것은 SPOP입니다. 모든 멤버가 정수면 셋은 (정렬 배열인) intset을 써 매우 메모리 효율적입니다.
# sets: unordered collection of unique strings
SADD tags "redis" "db" "cache"
SADD tags "redis" # ignored (already exists)
# remove a member
SREM tags "cache"
# check membership
SISMEMBER tags "redis" # 1 if member, 0 if not
# get the number of members
SCARD tags # 2
# get all members (avoid on large sets)
SMEMBERS tags # ["redis", "db"]
# get a random member
SRANDMEMBER tags # one random member
SRANDMEMBER tags 3 # 3 random (may repeat)
SRANDMEMBER tags -3 # 3 unique random
# pop a random member (removes it)
SPOP tags # removes and returns one셋 연산
셋 연산이 Redis의 슈퍼파워입니다. 클라이언트 측 처리 없이 O(N)의 합집합, 교집합, 차집합. 사용 사례: 공통 친구(SINTER), 고유 방문자(SUNION), 태그 기반 필터링(태그 셋의 SINTER). (7.0+의) SINTERCARD가 개수만 반환하며 멤버가 필요 없을 때 더 빠릅니다. 재계산을 피하려 결과를 저장하세요.
# set union, intersection, difference
SADD set1 "a" "b" "c"
SADD set2 "b" "c" "d"
# union (all unique members from all sets)
SUNION set1 set2 # a, b, c, d
# intersection (members in ALL sets)
SINTER set1 set2 # b, c
# difference (members in set1 but NOT in set2)
SDIFF set1 set2 # a
# store the result in a new set
SUNIONSTORE result set1 set2
SINTERSTORE result set1 set2
SDIFFSTORE result set1 set2
# count intersection without returning members (7.0+)
SINTERCARD 2 set1 set2 LIMIT 0셋 순회와 이동
SMOVE는 원자적이며 (사용자를 'pending'에서 'active' 셋으로 옮기는 식의) 상태 전이에 유용합니다. 큰 셋의 안전한 순회는 SSCAN입니다. (7.4+의) SMISMEMBER가 멤버십을 배칭 검사해 왕복을 줄입니다. (7.0+의) BSPOP이 BLPOP처럼 막지만 셋용이며 순서가 중요하지 않은 이벤트 구동 패턴에 유용합니다.
# SSCAN: cursor-based iteration for large sets
SSCAN myset 0 MATCH "pre*" COUNT 100
# returns [cursor, [member1, member2, ...]]
# move a member from one set to another atomically
SMOVE source dest "member"
# pop multiple random members (6.2+)
SPOP myset 3 # removes and returns 3 members
# blocking set pop (7.0+) - waits until a member exists
BSPOP myset 30 # blocks up to 30 seconds
# check multiple memberships at once (7.4+)
SMISMEMBER myset "a" "b" "c"
# returns [1, 0, 1]셋 사용 사례
셋이 고유성과 관계의 기본입니다. 상호 팔로워/친구의 SINTER 패턴이 고전입니다. 카디널리티가 거대한 '일일 방문자'에는 (근사지만 고정 12KB의) HyperLogLog를 고려하세요. (리더보드 같은) 정렬된 고유 데이터에는 정렬 셋을 쓰세요. 셋은 순서가 없으며 순서가 중요하면 리스트나 정렬 셋을 쓰세요.
# 1. Tags / categories
SADD post:1:tags "redis" "db"
SADD post:2:tags "redis" "cache"
SINTER post:1:tags post:2:tags # posts sharing "redis"
# 2. Unique visitors per day
SADD visitors:2025-01-01 "user:1" "user:2"
SCARD visitors:2025-01-01 # visitor count
# 3. Followers / following
SADD user:1:following "user:2" "user:3"
SADD user:2:following "user:1" "user:3"
SINTER user:1:following user:2:following # mutual follows
# 4. Blacklist / whitelist
SADD blacklist "ip:1.2.3.4"
SISMEMBER blacklist "ip:1.2.3.4"
# 5. Lottery / random selection
SADD participants "u1" "u2" "u3" "u4"
SPOP participants 1 # draw a winner셋 vs 기타 타입
타입 선택이 Redis 설계의 핵심 결정입니다. 고유성 + 빠른 멤버십(순서 없음)은 셋, 순위/정렬(메모리 더 씀)은 정렬 셋, 중복이 있는 시퀀스는 리스트, 필드-값 객체는 해시. 확신이 없으면 접근 패턴을 스케치하세요. 읽기, 쓰기, 정렬, 고유성 요구가 있으면 올바른 타입이 명백해집니다.
# Set: unordered, unique, O(1) membership check
SADD myset "a" "b"
SISMEMBER myset "a" # O(1)
# Sorted Set: unique + ordered by score
ZADD myzset 1 "a" 2 "b"
ZRANK myzset "a" # 0 (rank)
# List: ordered, allows duplicates, O(N) search
LPUSH mylist "a" "a"
LPOS mylist "a" # 0 (first match)
# Hash: field-value pairs, no ordering
HSET myhash a 1 b 2
# Choose:
# - need uniqueness only? -> Set
# - need uniqueness + ordering? -> Sorted Set
# - need ordering + allow dups? -> List
# - need key-value mapping? -> Hash정렬 셋
정렬 셋 기본
정렬 셋(zsets)이 Redis의 가장 강력한 구조입니다. 점수순으로 정렬된 고유 멤버와 O(log N) 연산. (NX/XX/GT/LT 같은) ZADD 옵션이 조건부 갱신을 가능하게 합니다. GT는 새 점수가 더 클 때만 갱신하며('최고 점수' 추적에 좋음) 점수는 double, 멤버는 고유입니다. 동률은 사전순으로 깹니다.
# sorted set: unique members ordered by a float score
ZADD leaderboard 100 "alice" 200 "bob" 150 "carol"
# update a score (re-add with new score)
ZADD leaderboard 250 "alice" # alice's score becomes 250
# add with options (NX: only new, XX: only existing, GT/LT: conditional)
ZADD leaderboard NX 300 "new"
ZADD leaderboard GT 300 "alice" # only if new score is greater
# get a member's score
ZSCORE leaderboard "alice" # "250"
# get a member's rank (0-based, ascending)
ZRANK leaderboard "alice" # rank from lowest
ZREVRANK leaderboard "alice" # rank from highest (0 = top)
# get the number of members
ZCARD leaderboard # 3범위 쿼리
순위(인덱스) 기반 반환은 ZRANGE, 점수 기반은 ZRANGEBYSCORE입니다. '(' 접두어가 점수를 배타로 만듭니다. Redis 6.2가 BYSCORE/BYLEX/REV 옵션의 ZRANGE로 이들을 통합했습니다. WITHSCORES가 출력에 점수를 포함합니다. 리더보드 top 10은 ZREVRANGE 0 9입니다. (6.2+의) ZRANGESTORE가 결과를 새 키에 저장합니다.
# get members by index range (ascending)
ZRANGE leaderboard 0 -1 # all, ascending
ZRANGE leaderboard 0 2 # first 3 (lowest scores)
ZRANGE leaderboard -3 -1 # last 3 (highest scores)
# get members by score range
ZRANGEBYSCORE leaderboard 100 200 # scores 100-200
ZRANGEBYSCORE leaderboard 100 +inf # scores >= 100
ZRANGEBYSCORE leaderboard (100 200 # scores > 100 (exclusive)
# descending order
ZREVRANGE leaderboard 0 2 # top 3 (highest scores)
ZREVRANGEBYSCORE leaderboard 200 100 # 200 down to 100
# with scores
ZRANGE leaderboard 0 -1 WITHSCORES
# Redis 6.2+: unified ZRANGE with BYSCORE/REV options
ZRANGE leaderboard 100 200 BYSCORE
ZRANGE leaderboard 200 100 BYSCORE REV점수 연산과 순위
ZINCRBY가 점수를 원자적으로 조정·재정렬하며 실시간 리더보드에 완벽합니다. (top 1000만 유지하는 식의) zset 크기 유지에 좋은 것은 ZREMRANGEBYRANK이며, 멤버를 가져오지 않고 범위 개수를 주는 것은 ZCOUNT입니다. (6.2+의) ZMSCORE가 점수를 배칭 가져와 다중 멤버 조회의 왕복을 줄입니다.
# increment a member's score
ZINCRBY leaderboard 50 "alice" # alice += 50
# get the score
ZSCORE leaderboard "alice"
# remove a member
ZREM leaderboard "bob"
# remove members by rank range
ZREMRANGEBYRANK leaderboard 0 9 # remove lowest 10
ZREMRANGEBYSCORE leaderboard 0 100 # remove scores <= 100
# count members in a score range
ZCOUNT leaderboard 100 200
# get the rank
ZRANK leaderboard "alice" # ascending rank
ZREVRANK leaderboard "alice" # descending rank (0 = highest)
# get multiple members' scores at once
ZMSCORE leaderboard "alice" "bob" # ["250", "200"]사전식 범위 (BYLEX)
BYLEX가 (점수가 같을 때) 멤버에 대한 범위 쿼리를 가능하게 해 정렬 셋을 자동 정렬 문자열 인덱스로 바꿉니다. 사용 사례: 자동완성(단어를 점수 0으로 저장하고 접두어 범위 조회), 정렬된 사전. '[a'는 포함, '(a'는 배타, '-'는 시작, '+'는 끝입니다. 모든 점수가 동일할 때만 동작합니다.
# when all scores are equal, sorted sets act as a sorted string set
ZADD myset 0 "apple" 0 "banana" 0 "cherry" 0 "date"
# range by lexicographical order
ZRANGEBYLEX myset "[a" "[c" # apple, banana, cherry
ZRANGEBYLEX myset "(a" "[c" # banana, cherry (a exclusive)
ZRANGEBYLEX myset "-" "[b" # from start to banana
ZRANGEBYLEX myset "[c" "+" # cherry to end
# count in a lex range
ZLEXCOUNT myset "[a" "[c" # 3
# remove by lex range
ZREMRANGEBYLEX myset "[a" "[b"
# Redis 6.2+: use ZRANGE with BYLEX
ZRANGE myset "[a" "[c" BYLEX정렬 셋 집계
ZUNIONSTORE/ZINTERSTORE가 (SUM/MIN/MAX의) 설정 가능한 집계와 가중치로 zset을 결합합니다. 가중 점수 매기기(예: relevance = text_match*2 + recency*1)에 강력합니다. Redis 6.2가 저장 없이 결과를 반환하는 ZUNION/ZINTER/ZDIFF를 추가했습니다(명령 하나 덜). O(N*M)이므로 많은 큰 셋에 주의하세요. 셋 개수는 셋 이름 앞에 옵니다.
# ZUNIONSTORE / ZINTERSTORE: combine multiple sorted sets
ZADD set1 1 "a" 2 "b"
ZADD set2 2 "a" 3 "c"
# union: sum scores by default (a = 1+2 = 3)
ZUNIONSTORE result 2 set1 set2
ZRANGE result 0 -1 WITHSCORES # a=3, b=2, c=3
# specify aggregation: SUM (default), MIN, MAX
ZUNIONSTORE result 2 set1 set2 AGGREGATE MAX # a=2, b=2, c=3
# apply weights to each set's scores
ZUNIONSTORE result 2 set1 set2 WEIGHTS 2 1 # set1 scores * 2
# intersection (only members in ALL sets)
ZINTERSTORE result 2 set1 set2 # only "a"
# Redis 6.2+: return without storing
ZUNION 2 set1 set2 WITHSCORES
ZINTER 2 set1 set2 WITHSCORES
ZDIFF 2 set1 set2 WITHSCORESPub/Sub
Pub/Sub 기본
Pub/Sub은 fire-and-forget입니다. 메시지가 현재 연결된 구독자에게 전달되며 영속성이 없습니다. 구독자가 없으면 메시지가 사라집니다. 그래서 신뢰 전달에는 부적합하며 그건 Streams입니다. Pub/Sub은 가끔 손실이 허용되는 실시간 알림, 채팅, 팬아웃에 이상적입니다. 수신하려면 구독자가 연결되어 있어야 합니다.
# subscribe to channels (in one client)
SUBSCRIBE news alerts
# publish a message to a channel (from another client)
PUBLISH news "Breaking: Redis 7.4 released"
# pattern subscription (glob-style)
PSUBSCRIBE news.*
# unsubscribe
UNSUBSCRIBE news
PUNSUBSCRIBE news.*
# note: published messages are NOT persisted
# if no subscriber is listening, the message is lost
# for persistent messaging, use Streams instead샤딩된 Pub/Sub (7.0+)
샤딩된 Pub/Sub(7.0+)가 클러스터 모드 문제를 해결합니다. 일반 Pub/Sub은 모든 PUBLISH를 모든 클러스터 노드에 브로드캐스트해 대역폭을 낭비합니다. 샤딩된 Pub/Sub은 채널 키를 소유한 샤드로만 메시지를 라우팅하며 큰 클러스터에서 훨씬 효율적입니다. 클러스터 배포에서는 SSUBSCRIBE/SPUBLISH를 쓰세요. 채널 이름이 (키처럼) 샤드를 결정합니다.
# regular Pub/Sub broadcasts to ALL cluster nodes (expensive)
# sharded Pub/Sub routes messages only to the shard owning the channel
# subscribe to a shard channel
SSUBSCRIBE mychannel
# publish to a shard channel
SPUBLISH mychannel "hello"
# sharded pub/sub uses the channel name for shard routing
# so messages only travel within one shard (more efficient)
# use sharded pub/sub in a Redis Cluster to avoid
# broadcasting messages to every node
# regular SUBSCRIBE/PUBLISH still work in cluster mode
# but they broadcast to all shards (cluster-wide overhead)Pub/Sub 패턴과 사용 사례
Pub/Sub이 팬아웃 패턴에 완벽합니다. 게시자 하나, 구독자 다수(채팅방, 라이브 대시보드, 캐시 무효화). glob 패턴(user:*:login)의 PSUBSCRIBE가 유연한 라우팅을 가능하게 합니다. 주요 한계는 영속성 부재입니다. 구독자가 연결을 끊으면 메시지를 놓칩니다. 신뢰 전달은 Pub/Sub를 (백업인) 스트림과 짝짓거나 그냥 Streams를 쓰세요.
# 1. Real-time chat
# client subscribes to their room
SUBSCRIBE chat:room:42
# server publishes messages
PUBLISH chat:room:42 "Alice: hello"
# 2. Cache invalidation
# subscribe to invalidation channel
SUBSCRIBE cache:invalidate
# when data changes, publish
PUBLISH cache:invalidate "user:123"
# 3. Event notifications (with PSUBSCRIBE patterns)
PSUBSCRIBE user:*:login
# matches user:1:login, user:2:login, etc.
# 4. Live dashboards
SUBSCRIBE metrics:*
# push real-time updates to dashboards
# 5. Multiplayer game state
PUBLISH game:room:1 "player_moved:5:10"Keyspace 알림
keyspace 알림이 클라이언트가 키 수명 주기 이벤트(set, delete, expire, evict)에 반응하게 합니다. 설정은 notify-keyspace-events입니다. fire-and-forget이며(영속성 없음) 신뢰할 수 없습니다. Redis 서버가 재시작하면 대기 이벤트가 사라집니다. 신뢰할 수 있는 이벤트 처리에는 Streams를 쓰세요. keyspace 알림이 정리나 캐시 예열 같은 부수 효과에 좋습니다.
# enable keyspace notifications (disabled by default)
CONFIG SET notify-keyspace-events "KEA"
# K = keyspace events, E = keyevent events
# g = generic (DEL, EXPIRE, ...), $ = string, l = list
# h = hash, s = set, z = sorted set, x = expired, e = evicted
# A = all except m (m = keymiss)
# subscribe to events on a specific key
SUBSCRIBE __keyspace@0__:mykey
# publishes "set", "del", "expire", etc.
# subscribe to events of a specific type
SUBSCRIBE __keyevent@0__:del
# publishes the key name that was deleted
# example: react when a key expires
SUBSCRIBE __keyspace@0__:session:abc
# receives "expired" when the key TTL endsPub/Sub vs Streams
Pub/Sub은 일회성 실시간 메시징이고 Streams는 지속·재생 가능 메시징입니다. 흔한 하이브리드: 라이브 알림은 Pub/Sub(빠르고 유실 가능), 진실의 원천은 Streams(지속, 재생 가능). 새 구독자는 따라잡으려 스트림을 읽고 라이브 갱신은 Pub/Sub를 구독합니다. 신뢰성이 필요한 대부분의 프로덕션 시스템에서 Streams가 더 나은 기본입니다.
# Pub/Sub: fire-and-forget, no persistence
PUBLISH channel "msg" # lost if no subscribers
# Streams: persistent, replayable, consumer groups
XADD mystream * msg "hello" # stored forever (or capped)
# Pub/Sub pros: simple, low latency, fan-out
# Pub/Sub cons: no persistence, no replay, no consumer groups
# Streams pros: persistent, replayable, consumer groups, ACK
# Streams cons: more complex, requires cleanup (XADD MAXLEN)
# when to use each:
# - real-time notifications (loss OK) -> Pub/Sub
# - chat with presence -> Pub/Sub + Streams
# - reliable task queue -> Streams
# - event sourcing / audit log -> Streams
# - fan-out to transient subscribers -> Pub/Sub트랜잭션과 파이프라이닝
MULTI/EXEC 트랜잭션
MULTI/EXEC가 명령을 원자적 순차 블록으로 묶습니다. 다른 클라이언트가 끼어들 수 없습니다. 명령이 큐잉되고(QUEUED 반환) EXEC에서 함께 실행됩니다. 큐잉 오류(잘못된 명령 이름)가 전체 트랜잭션을 중단하고, 런타임 오류(키의 잘못된 타입)는 그 명령만 건너뛰며 나머지는 실행됩니다. SQL 트랜잭션과 다릅니다.
# MULTI starts a transaction; commands are queued
MULTI
SET counter 1
INCR counter
INCR counter
GET counter
EXEC
# returns: [OK, 2, 3, "3"]
# discard a transaction (cancels all queued commands)
MULTI
SET x 1
DISCARD
# errors during queuing (syntax) abort the whole transaction
# errors during EXEC (e.g., wrong type) skip only that commandWATCH (낙관적 잠금)
WATCH가 낙관적 잠금을 구현합니다. WATCH와 EXEC 사이에 감시된 키가 바뀌면 트랜잭션이 중단됩니다(EXEC가 nil 반환). Redis에 행 락이 없으므로 이것이 (읽기-수정-쓰기 원자성의) 표준 Redis 패턴입니다. nil에서는 항상 재시도하세요. WATCH는 큐잉 중이 아니라 EXEC 시점에 검사됩니다. 감시 취소는 UNWATCH이며 DISCONNECT에서도 일어납니다.
# WATCH monitors keys; if any change before EXEC, the transaction aborts
WATCH counter
val = GET counter # read current value
MULTI
INCR counter # queue the update
EXEC # nil if counter changed -> retry
# typical pattern: read-modify-write with retry
WATCH key
current = GET key
new_value = compute(current)
MULTI
SET key new_value
EXEC
# if EXEC returns nil, the key changed — loop and retry
# UNWATCH cancels all watches
UNWATCH파이프라이닝 (배치 왕복)
파이프라이닝이 네트워크 왕복을 줄이려 명령을 배칭하며 네트워 크를 통한 개별 명령보다 극적으로 빠릅니다. MULTI/EXEC와 달리 파이프라인된 명령은 '원자적이지 않습니다'(다른 클라이언트가 끼어들 수 있음). 원자성이 무관한 대량 연산(대량 삽입, 읽기)에는 파이프라이닝, 원자성이 필요하면 MULTI/EXEC를 쓰세요. 대부분의 클라이언트가 MULTI/EXEC 내에서 자동 파이프라인합니다.
# pipelining sends multiple commands in one network round-trip
# (no atomicity guarantee, just reduced latency)
# in a client library (e.g., Node.js / redis):
const pipe = client.multi()
pipe.set("k1", "v1")
pipe.set("k2", "v2")
pipe.incr("counter")
const results = await pipe.exec()
# vs MULTI/EXEC: pipelining does NOT guarantee atomicity
# other clients can interleave between pipelined commands
# raw protocol example (RESP):
# *1\r\n$4\r\nPING\r\n*1\r\n$4\r\nPING\r\n
# (send multiple commands at once, read multiple replies)Lua 스크립트 (원자적)
Lua 스크립트가 Redis식 복잡한 원자적 연산 방법입니다. 스크립트가 단일 원자 단위로 실행됩니다(끼어들기 없음). 해시로 로드된 스크립트 재실행은 EVALSHA이며(스크립트 재전송 회피) 스크립트는 (서버를 막으므로) 짧게 유지하세요. 복제를 위해 스크립트에는 (랜덤/시간 호출 없는) 결정적 요구가 있습니다. 더 구조화된 대안은 Redis 7+의 FUNCTIONS입니다.
# Lua scripts run atomically — no other command runs during execution
# EVAL: run a script
EVAL "return redis.call('GET', KEYS[1])" 1 mykey
# a check-and-set script:
EVAL "
local cur = redis.call('GET', KEYS[1])
if cur == ARGV[1] then
return redis.call('SET', KEYS[1], ARGV[2])
end
return 0
" 1 mykey "expected" "newvalue"
# load a script once, then run by SHA hash (efficient)
SCRIPT LOAD "return redis.call('GET', KEYS[1])"
# returns a SHA1 hash
EVALSHA <sha1> 1 mykey
# check if a script is loaded
SCRIPT EXISTS <sha1>Functions (Redis 7.0+)
Functions(7.0+)가 EVAL 스크립트를 개선합니다. 이름이 있고(단순 해시가 아님) 라이브러리로 조직되며 재시작에도 유지됩니다(EVAL 스크립트는 일시적). 관리와 배포가 더 쉽습니다. 이름으로 함수 호출은 FCALL입니다. Functions가 원자적 서버 측 로 직 추가의 현대적 방법입니다. 스크립트처럼 복제를 위해 결정적이어야 합니다.
# FUNCTIONS are named, versioned Lua scripts (better than EVAL)
# register a function library
FUNCTION LOAD '#!lua name=mylib
redis.register_function("my_set",
function(keys, args)
return redis.call("SET", keys[1], args[1])
end
)'
# call a function by name
FCALL my_set 1 mykey "hello"
# list loaded libraries
FUNCTION LIST
# get the function's code
FUNCTION DUMP mylib
# delete a library
FUNCTION DELETE mylib
# functions persist across restarts (unlike EVAL scripts)영속성
RDB 스냅샷
RDB 스냅샷은 백업과 재해 복구에 이상적인 컴팩트 바이너리 파일입니다. BGSAVE가 (copy-on-write로) 프로세스를 fork해 메인 스레드를 막지 않지만 큰 데이터셋은 fork 중에도 메모리 스파이크를 일으킬 수 있습니다. ('save' 규칙이) 변경 비율에 따라 자동 스냅샷을 트리거합니다. RDB는 마지막 스냅샷 이후 쓰인 데이터를 잃을 위험이 있으므로 내구성은 AOF와 짝지으세요.
# RDB: point-in-time snapshot of the dataset (compact binary)
# trigger a snapshot manually:
SAVE # blocks until done (use with care)
BGSAVE # forks a background process (non-blocking)
LASTSAVE # Unix timestamp of the last successful save
# configure automatic snapshots in redis.conf:
# save 3600 1 # save if >= 1 key changed in 3600s
# save 300 100 # save if >= 100 keys changed in 300s
# save 60 10000 # save if >= 10000 keys changed in 60s
# save "" # disable RDB entirely
# RDB file location (default: dump.rdb in the working dir)
CONFIG GET dbfilename
CONFIG GET dir
# RDB pros: compact, fast restart, great for backups
# RDB cons: potential data loss between snapshotsAOF (Append-Only File)
AOF가 모든 쓰기 명령을 로그에 append합니다. RDB보다 훨씬 지속적입니다(everysec은 최대 1초 데이터 손실). 'always'가 매 쓰기마다 fsync하며(매우 느림, 중요 데이터 전용) 로그 압축(최소 명령 집합으로 재작성)은 BGREWRITEAOF입니다. AOF 파일이 RDB보다 크고 로드가 느립니다. Redis 7은 (base + 증분의) 다중 부분 AOF 형식을 씁니다.
# AOF: logs every write command (durable, replayable)
# enable in redis.conf:
# appendonly yes
# appendfilename "appendonly.aof"
# fsync policies:
# appendfsync always # fsync every write (safest, slowest)
# appendfsync everysec # fsync once per second (default, balanced)
# appendfsync no # let OS decide (fastest, risk of data loss)
# trigger AOF rewrite (compacts the log)
BGREWRITEAOF
# AOF auto-rewrite thresholds:
# auto-aof-rewrite-percentage 100
# auto-aof-rewrite-min-size 64mb
# AOF pros: minimal data loss (1 sec max with everysec)
# AOF cons: larger files, slower load on restartRDB + AOF 하이브리드
RDB + AOF를 함께 실행하면 RDB의 빠른 재시작과 AOF의 내구성을 모두 얻습니다. Redis 7부터 AOF는 다중 부분 파일입니다. RDB base 스냅샷 + 증분 명령 로그로 빠른 로드와 최소 데이터 손실을 결합합니다. aof-use-rdb-preamble(기본 yes)이 더 빠른 복구를 위해 AOF 시작에 RDB 스냅샷을 둡니다. 권장 프로덕션 설정입니다.
# use BOTH RDB and AOF for the best of both worlds
# redis.conf:
# save 900 1 # RDB snapshots
# appendonly yes # AOF enabled
# aof-use-rdb-preamble yes # RDB header in AOF (faster load)
# on restart, Redis loads AOF (more complete)
# the AOF file can start with an RDB snapshot (faster load)
# followed by incremental AOF commands
# disaster recovery: keep both RDB and AOF backups
# RDB for fast restores, AOF for minimal data loss
# check what's enabled
CONFIG GET save
CONFIG GET appendonly
# monitor persistence operations
INFO persistence백업과 복구
RDB 파일(컴팩트하고 빠름)은 Redis 실행 중에도 일관된 스냅샷이므로(copy-on-write) 정기적으로 백업하세요. AOF는 (Redis 7 다중 부분의) appendonly 디렉터리 전체를 백업합니다. 복구는 Redis 정지, 파일 교체, 재시작입니다. 나쁜 명령에서의 복구는 재시작 전 AOF에서 제거 편집입니다. 백업 검증은 redis-check-rdb/aof로 항상 하세요.
# backup: copy the RDB file while Redis runs
cp /var/lib/redis/dump.rdb /backup/dump-$(date +%F).rdb
# or trigger a BGSAVE first for a consistent snapshot
BGSAVE
# wait for LASTSAVE to update, then copy the file
# AOF backup: copy the AOF manifest + files
cp /var/lib/redis/appendonly.aof.* /backup/
# restore: stop Redis, replace the data files, start
redis-cli SHUTDOWN
cp /backup/dump.rdb /var/lib/redis/dump.rdb
redis-server /etc/redis/redis.conf
# for point-in-time recovery from AOF:
# edit the AOF file to remove unwanted commands, then restart
# RDB file analysis (offline)
redis-check-rdb /var/lib/redis/dump.rdb
redis-check-aof /var/lib/redis/appendonly.aof영속성 절충
영속성 선택은 내구성 요구에 달려 있습니다. 순수 캐시: 최대 속도를 위해 영속성 비활성화. 중요 데이터: RDB+AOF(권장). 흔한 패턴: (성능을 위해) 프라이머리에서 영속성 비활성화, (디스크 I/O 분산을 위해) 레플리카에서 영속화. everysec AOF가 스위트 스팟입니다. 최소 성능 영향으로 최대 1초의 데이터 손실. 복구는 항상 테스트하세요.
# choosing a persistence strategy:
# 1. RDB only (cache, re-buildable data)
# save 3600 1
# appendonly no
# -> fast restart, some data loss on crash
# 2. AOF only (durability-critical, everysec)
# save ""
# appendonly yes
# appendfsync everysec
# -> up to 1s data loss, larger files
# 3. RDB + AOF (recommended production default)
# save 3600 1
# appendonly yes
# aof-use-rdb-preamble yes
# -> durability + fast restart
# 4. No persistence (pure cache, ephemeral)
# save ""
# appendonly no
# -> maximum speed, all data lost on restart
# 5. Replica-only persistence (offload from primary)
# primary: no persistence (max performance)
# replica: RDB + AOF (persist here instead)클러스터링
Redis Cluster 기본
Redis Cluster가 16,384개 해시 슬롯으로 노드에 걸쳐 데이터를 샤딩합니다. 슬롯 결정은 CRC16(key) % 16384입니다. (MGET, 트랜잭션 같은) 다중 키 연산에는 같은 슬롯의 키가 필요하므로 관련 키를 강제로 모으려 해시 태그({user:1})를 쓰세요. 각 프라이머리가 HA를 위해 레플리카를 가질 수 있으며 프라이머리 실패 시 클러스터가 자동 페일오버합니다.