如何借助Redis Sentinel实现多Pod场景下的任务互斥与隐私访问？

核心思路是借助Redis的原子性操作实现分布式锁，确保只有第一个抢到锁的Pod能执行任务，其余Pod直接跳过。具体实现步骤如下：

• 抢锁逻辑用Redis原子命令
  使用SET命令的NX（仅键不存在时设置）和EX（自动过期）参数，这是原子操作，不会出现并发判断漏洞：

  SET task_lock "pod_unique_id" NX EX 300
  

  • task_lock：自定义的锁键名
  • pod_unique_id：Pod的唯一标识（比如从环境变量取Pod名称，方便排查）
  • EX 300：锁的过期时间（单位秒，需设置为比任务最长执行时间更长的值，防止Pod挂掉后锁永久存在）

• Pod的Worker执行流程
  每个Pod启动Worker后，按以下逻辑执行：

  1. 先检查done键的值，如果已经是true，直接跳过任务，进入定期轮询
  2. 尝试执行上述SET命令：
     • 返回OK：成功抢到锁，执行任务；任务完成后设置done=true，锁可选择自动过期（不建议主动删除，避免误删其他Pod的锁）
     • 返回nil：已有Pod抢到锁，直接跳过任务

• .NET Core代码示例（简化版）

  using StackExchange.Redis;
  using System.Threading;
  using System.Threading.Tasks;
  
  public class ExclusiveTaskWorker : BackgroundService
  {
      private readonly IDatabase _redisDb;
      private readonly string _podIdentifier;
  
      public ExclusiveTaskWorker(IConnectionMultiplexer redisConnection)
      {
          _redisDb = redisConnection.GetDatabase();
          // 从环境变量获取Pod唯一标识，K8s中可通过环境变量POD_NAME获取
          _podIdentifier = Environment.GetEnvironmentVariable("POD_NAME") ?? Guid.NewGuid().ToString("N");
      }
  
      protected override async Task ExecuteAsync(CancellationToken stoppingToken)
      {
          while (!stoppingToken.IsCancellationRequested)
          {
              // 先确认任务是否已完成
              var isTaskDone = await _redisDb.StringGetAsync("done") == "true";
              if (isTaskDone)
              {
                  await Task.Delay(TimeSpan.FromMinutes(5), stoppingToken);
                  continue;
              }
  
              // 尝试获取分布式锁
              var lockAcquired = await _redisDb.StringSetAsync(
                  key: "task_execution_lock",
                  value: _podIdentifier,
                  expiry: TimeSpan.FromMinutes(5),
                  when: When.NotExists);
  
              if (lockAcquired)
              {
                  try
                  {
                      // 二次校验，防止抢锁期间其他Pod已完成任务
                      isTaskDone = await _redisDb.StringGetAsync("done") == "true";
                      if (isTaskDone) continue;
  
                      // 执行核心任务：访问文件系统等操作
                      await RunCoreTask(stoppingToken);
  
                      // 标记任务完成
                      await _redisDb.StringSetAsync("done", "true");
                  }
                  finally
                  {
                      // 建议让锁自动过期，避免任务超时后误删其他Pod的锁
                      // await _redisDb.KeyDeleteAsync("task_execution_lock");
                  }
              }
  
              await Task.Delay(TimeSpan.FromMinutes(1), stoppingToken);
          }
      }
  
      private async Task RunCoreTask(CancellationToken stoppingToken)
      {
          // 替换为你的实际任务逻辑
          await Task.Delay(TimeSpan.FromSeconds(45), stoppingToken);
      }
  }
  

• 关键注意点

  • 必须用原子操作抢锁：绝对不能先GET锁键再SET，否则会出现多个Pod同时判断锁不存在，进而重复执行任务的并发问题
  • 锁过期时间要合理：必须大于任务的最长可能执行时间，防止任务未完成时锁过期，导致其他Pod重新抢锁
  • Redis Sentinel集群下的可靠性：主节点负责处理所有写操作，SET命令的原子性由Redis主节点保障，从节点仅做同步，不影响锁的判断

内容的提问来源于stack exchange，提问作者barteloma