精通 DevOps 工具与最佳实践 - DevOps 知识中心 精通 DevOps 工具与最佳实践 - DevOps 知识中心

使用 Redis EXPIRE 和 TTL 命令的最佳实践

安全使用 Redis EXPIRE 和 TTL 命令，用于缓存、会话、速率限制、锁和内存清理。

使用 Redis EXPIRE 和 TTL 命令的最佳实践

Redis 是一个强大的内存数据结构存储，通常用作缓存、消息代理和数据库。有效管理 Redis 中的数据生命周期对于优化性能、防止内存耗尽以及实施稳健的缓存策略至关重要。EXPIRE 和 TTL（及其毫秒级对应命令 PEXPIRE 和 PTTL）是实现数据过期控制的基本工具。

如果你忘记为临时数据设置过期时间，Redis 可能会悄悄用陈旧的缓存条目、旧的会话和废弃的锁键填满内存。请有意识地使用过期时间，并在创建键时原子性地设置它们。

理解 Redis 过期命令

Redis 提供了为键设置生存时间（TTL）的命令，超过该时间后键将被自动删除。这种自动删除对于管理内存和确保数据新鲜度至关重要，尤其是在缓存场景中。

EXPIRE 和 PEXPIRE 命令

这些命令为键设置超时时间。一旦超时到达，键将被自动删除。主要区别在于时间单位：

  • EXPIRE key seconds：以秒为单位设置过期时间。
  • PEXPIRE key milliseconds：以毫秒为单位设置过期时间。

使用 PEXPIRE 可以提供更精细的控制，这对于时间敏感的缓存或需要在非常特定的短时间间隔内过期数据的情况非常有用。

示例：

# 将键 'mykey' 设置为在 60 秒后过期
redis-cli> EXPIRE mykey 60
(integer) 1

# 将键 'anotherkey' 设置为在 500 毫秒后过期
redis-cli> PEXPIRE anotherkey 500
(integer) 1

返回值：

  • 1：成功设置超时。
  • 0：键不存在。

EXPIREAT 和 PEXPIREAT 命令

这些命令与 EXPIRE 和 PEXPIRE 类似，但不是设置持续时间，而是设置键过期的特定绝对时间。

  • EXPIREAT key timestamp：将过期时间设置为特定的Unix 时间戳（自纪元以来的秒数）。
  • PEXPIREAT key millitimestamp：将过期时间设置为特定的Unix 时间戳（毫秒）。

当你希望某个项目在特定的挂钟时间过期时（无论它何时被设置），这些命令非常有用。

示例：

# 将键 'session:123' 设置为在 Unix 时间戳 1678886400（即 2023 年 3 月 15 日 12:00:00 PM UTC）过期
redis-cli> EXPIREAT session:123 1678886400
(integer) 1

TTL 和 PTTL 命令

这些命令返回键的剩余生存时间。这对于监控键的过期以及实现依赖于剩余时间的逻辑至关重要。

  • TTL key：以秒为单位返回键的剩余生存时间。
  • PTTL key：以毫秒为单位返回键的剩余生存时间。

返回值：

  • 正整数：以秒（对于 TTL）或毫秒（对于 PTTL）为单位的生存时间。
  • -1：键存在但没有关联的过期时间。
  • -2：键不存在。

示例：

redis-cli> TTL mykey
(integer) 55

redis-cli> PTTL anotherkey
(integer) 480

redis-cli> TTL non_existent_key
(integer) -2

redis-cli> SET permanent_key "some value"
OK
redis-cli> TTL permanent_key
(integer) -1

使用 EXPIRE 和 TTL 的最佳实践

有效利用这些命令需要一种战略性的缓存和数据管理方法。以下是关键的最佳实践：

1. 为缓存积极设置过期时间

对于作为缓存的数据，设置过期时间几乎总是更好的选择。这确保了陈旧数据不会无限期存在。关键在于选择一个能够平衡缓存命中率与数据新鲜度的过期时间。

  • 缓存失效： 过期充当了一种自动缓存失效的形式。当缓存条目过期时，应用程序可以从主数据源重新获取新鲜数据并更新缓存。
  • 内存管理： 防止缓存无限增长，这可能导致内存耗尽和性能下降。

示例： 缓存用户配置文件 5 分钟。

import redis
import time

r = redis.Redis(decode_responses=True)

def get_user_profile(user_id):
    cache_key = f"user_profile:{user_id}"
    profile_data = r.get(cache_key)

    if profile_data:
        print(f"用户 {user_id} 缓存命中")
        return profile_data
    else:
        print(f"用户 {user_id} 缓存未命中。从数据库获取...")
        # 模拟从数据库获取
        user_profile = {"name": "Alice", "email": "[email protected]"}
        # 存储到 Redis 并设置 5 分钟过期时间（300 秒）
        r.set(cache_key, str(user_profile), ex=300)
        return user_profile

# 第一次调用（缓存未命中）
print(get_user_profile(123))

# 第二次调用（缓存命中）
print(get_user_profile(123))

# 等待一段时间，但小于过期时间
time.sleep(10)
print(f"缓存键的 TTL：{r.ttl(cache_key)} 秒")

# 等待过期
time.sleep(300) # 模拟剩余的 5 分钟
print(f"过期后的 TTL：{r.ttl(cache_key)} 秒")

2. 对高频/短生命周期数据使用 PEXPIRE

对于速率限制、有效期非常短的会话令牌或临时锁等场景，毫秒级精度可能至关重要。PEXPIRE 提供了更精细的控制。

示例： 实现一个简单的速率限制器。

import redis
import time

r = redis.Redis(decode_responses=True)

def check_rate_limit(user_id, limit=5, period_ms=60000): # 每分钟 5 次请求
    key = f"rate_limit:{user_id}"
    current_requests = r.get(key)

    if current_requests is None:
        # 此时间段内的第一次请求
        r.set(key, 1, px=period_ms)
        return True
    else:
        current_requests = int(current_requests)
        if current_requests < limit:
            # INCR 保留现有的 TTL。
            r.incr(key)
            return True
        else:
            # 超出限制
            return False

# 模拟用户的请求
user = "user:abc"
for i in range(7):
    if check_rate_limit(user):
        print(f"请求 {i+1}：允许。剩余 TTL：{r.pttl(f'rate_limit:{user}')}ms")
    else:
        print(f"请求 {i+1}：超出速率限制。")
    time.sleep(0.1) # 模拟请求之间的时间间隔

3. 使用 EXPIREAT 处理基于时间的事件

当需要数据在特定的日历时间过期时（例如，促销结束、基于登录时间加上固定持续时间的会话过期），使用 EXPIREAT 比计算持续时间更合适。

示例： 在固定时间过期一个特别优惠。

import redis
import datetime

r = redis.Redis(decode_responses=True)

offer_id = "SUMMER2026"
end_time = datetime.datetime(2023, 8, 31, 23, 59, 59)

# 转换为 Unix 时间戳
end_timestamp = int(end_time.timestamp())

# 将优惠详情存储到 Redis 并设置过期时间
r.set(f"offer:{offer_id}", "所有商品 20% 折扣！")
r.expireat(f"offer:{offer_id}", end_timestamp)

print(f"优惠 '{offer_id}' 设置为在 {end_time} 过期（时间戳：{end_timestamp}）")
print(f"当前优惠的 TTL：{r.ttl(f'offer:{offer_id}')} 秒")

4. 注意没有过期时间的键

没有显式使用 EXPIRE、PEXPIRE、EXPIREAT 或 PEXPIREAT 命令设置的键将无限期存在，直到被显式删除或 Redis 服务器重启（除非配置了持久化）。这可能导致内存问题。

  • 永久数据： 如果你打算让数据永久存在，请确保它没有被意外分配过期时间。相反，如果数据应该过期但你忘记设置，它将一直保留。
  • 监控： 定期监控你的 Redis 内存使用情况和键数量。使用 INFO memory 和 redis-cli --stat 等命令或 Redis Enterprise 的 UI 等工具来识别可能消耗过多内存且没有过期时间的键。

5. 使用 PERSIST 移除过期时间

如果你已经为键设置了过期时间，但后来决定它应该是永久的，请使用 PERSIST 命令。

示例：

redis-cli> SET temp_key "data"
OK
redis-cli> EXPIRE temp_key 300
(integer) 1
redis-cli> TTL temp_key
(integer) 295
redis-cli> PERSIST temp_key
(integer) 1
redis-cli> TTL temp_key
(integer) -1

6. 原子性：将 SET 与过期时间结合

当设置一个应该有过期时间的新键时，使用带有 EX 或 PX 选项的 SET 命令通常更高效且原子性更好，而不是先执行 SET 再执行 EXPIRE。

  • SET key value EX seconds：设置键的值及其以秒为单位的过期时间。
  • SET key value PX milliseconds：设置键的值及其以毫秒为单位的过期时间。

这是原子性的，意味着操作要么完全成功，要么完全失败，从而防止在 SET 和 EXPIRE 命令之间出现 EXPIRE 命令可能失败或被遗漏的竞态条件。

示例：

# 而不是：
# redis-cli> SET mycache "some value"
# redis-cli> EXPIRE mycache 3600

# 使用：
redis-cli> SET mycache "some value" EX 3600
OK

# 或者对于毫秒：
redis-cli> SET anothercache "other value" PX 500
OK

7. 考虑将 SETNX 与过期时间结合

如果你使用 SETNX（仅当键不存在时设置）来实现分布式锁或仅在键不存在时设置值，你需要将其与过期时间结合以防止死锁。

  • SET key value NX EX seconds：仅在键不存在时将 key 设置为 value，并设置指定的过期时间（秒）。
  • SET key value NX PX milliseconds：类似，但使用毫秒。

这是实现分布式锁的常见模式。

示例： 获取分布式锁。

# 尝试为资源 'resource_X' 获取锁，持续 10 秒
redis-cli> SET lock:resource_X "process_abc" NX EX 10
OK
# 如果上述命令返回 'OK'，则你已获得锁。
# 如果返回 'nil'（或在某些客户端中为空字符串），则锁已被持有。

# 释放锁（小心操作，通常使用 Lua 脚本在删除前检查值）
# redis-cli> DEL lock:resource_X

8. 监控过期事件

Redis 有一种清理过期键的机制：惰性过期和主动过期。

  • 惰性过期： 仅在通过命令（例如 GET、TTL）访问键时检查其是否过期。这是最常见且资源效率最高的方法。
  • 主动过期： Redis 定期采样具有 TTL 的键并删除过期的键，即使它们没有被访问。这有助于更主动地回收内存。

虽然你不能直接控制主动过期的频率（除非修改服务器配置），但你可以使用 TTL 和 PTTL 来检查键的状态，并确保你的应用程序逻辑正确处理过期数据。

要点

在创建临时键时使用 SET ... EX 或 SET ... PX，在调试时检查 TTL，并将 TTL = -1 的键视为清理风险，除非它们是有意设置为永久的。