Kaedah pelaksanaan mekanisme pengehad arus teragih Redis

Dengan pembangunan aplikasi Internet, akses serentak yang tinggi telah menjadi isu yang sangat penting bagi syarikat Internet. Untuk memastikan kestabilan sistem, kami perlu mengehadkan akses untuk mengelakkan serangan berniat jahat atau akses berlebihan daripada menyebabkan ranap sistem. Mekanisme pengehad semasa digunakan secara meluas dalam aplikasi Internet Redis, sebagai pangkalan data cache yang popular, juga menyediakan penyelesaian pengehadan semasa.

Mekanisme pengehad semasa Redis terutamanya mempunyai dua kaedah pelaksanaan berikut:

1 Pengehadan semasa berdasarkan algoritma baldi token

Algoritma baldi token adalah yang biasa digunakan. kaedah mengehadkan di Internet Salah satu algoritma penstriman, Redis menyediakan penyelesaian mengehadkan semasa berdasarkan algoritma baldi token. Pelaksanaan penyelesaian ini terutamanya berdasarkan set pesanan Redis (zset) dan skrip Lua.

Prinsip algoritma baldi token ialah baldi berkapasiti tetap, di mana token diletakkan pada kadar tertentu Setiap permintaan perlu mendapatkan token daripada baldi sebelum ia boleh diproses. Jika tiada token dalam baldi, permintaan ditolak.

Dalam Redis, kita boleh menggunakan set tertib (zset) untuk membina baldi token. Setiap elemen dalam set tersusun mewakili token, skornya mewakili masa ketibaan token dan nilainya boleh menjadi sebarang nilai. Skrip Lua digunakan untuk melaksanakan operasi mendapatkan token. Kod pelaksanaan khusus adalah seperti berikut:

-- 获取令牌
local function acquire_token(key, rate, capacity, now)
  local current_capacity = redis.call("zcount", key, "-inf", "+inf")
  local delta_time = 1000 / rate
  local expected_token = math.floor((now - delta_time * capacity) / delta_time)
  local available_token = math.min(expected_token - current_capacity, capacity)
  if available_token > 0 then
    local members = {}
    for i = 1, available_token do
      members[i] = now
    end
    redis.call("zadd", key, unpack(members))
  end

  local current_time = now
  local stop_time = current_time + 1000
  local expire_time = stop_time - delta_time * (available_token - 1)
  local result = redis.call("zrangebyscore", key, "-inf", expire_time)
  if #result > 0 then
    redis.call("zrem", key, unpack(result))
    return 1
  end

  return 0
end

-- 调用获取令牌操作
local result = acquire_token(KEYS[1], ARGV[1], ARGV[2], ARGV[3])
return result

Antaranya, KEYS[1] mewakili Kunci pengehad semasa, ARGV[1] mewakili kadar di mana token dimasukkan, ARGV[2] mewakili baldi kapasiti, dan ARGV[3] mewakili masa semasa.

2. Pengehadan semasa berdasarkan algoritma corong

Algoritma corong juga merupakan algoritma pengehad semasa yang biasa digunakan ialah Permintaan mengalir ke dalam corong penuh, ia akan melimpah. Dalam Redis, kita juga boleh menggunakan set tertib (zset) dan skrip Lua untuk melaksanakan algoritma corong.

Algoritma corong perlu mengekalkan objek corong, merekodkan masa permintaan terakhir dan kapasiti baldi semasa. Apabila permintaan baharu datang, algoritma akan mengira peningkatan kapasiti corong berdasarkan perbezaan antara masa semasa dan masa permintaan terakhir. Jika kapasiti kurang daripada kapasiti maksimum baldi, permintaan dibenarkan untuk lulus dan kapasiti dikurangkan jika tidak, permintaan ditolak.

Kod pelaksanaan khusus adalah seperti berikut:

-- 获取令牌
local function acquire_token(key, rate, capacity, now)
  local current_capacity = redis.call("hget", key, "capacity")
  local last_time = redis.call("hget", key, "last_time")

  if current_capacity == redis.error_reply or current_capacity == ngx.null then
    current_capacity = capacity
    redis.call("hset", key, "capacity", current_capacity)
  else
    current_capacity = tonumber(current_capacity)
  end

  if last_time == redis.error_reply or last_time == ngx.null then
    last_time = now
    redis.call("hset", key, "last_time", last_time)
  else
    last_time = tonumber(last_time)
  end

  local delta_time = now - last_time
  local expected_capacity = delta_time * rate / 1000 + current_capacity
  local actual_capacity = math.min(expected_capacity, capacity)

  if actual_capacity >= 1 then
    redis.call("hset", key, "capacity", actual_capacity - 1)
    redis.call("hset", key, "last_time", now)
    return 1
  end

  return 0
end

-- 调用获取令牌操作
local result = acquire_token(KEYS[1], ARGV[1], ARGV[2], ARGV[3])
return result

Antaranya, KEYS[1] mewakili Kunci pengehad semasa, ARGV[1] mewakili kadar penambahan air corong, ARGV[2 ] mewakili kapasiti corong, dan ARGV [3] mewakili masa semasa.

Ringkasan

Mekanisme pengehad arus teragih yang disediakan oleh Redis boleh mengawal akses serentak dengan berkesan dan memastikan kestabilan sistem. Kita boleh memilih algoritma baldi token atau algoritma corong sebagai algoritma pengehad semasa mengikut keperluan perniagaan, dan melaksanakannya melalui set pesanan Redis (zset) dan skrip Lua. Perlu diingat bahawa apabila menggunakan mekanisme pengehadan semasa, parameter algoritma harus dikonfigurasikan secara munasabah berdasarkan senario perniagaan tertentu dan ciri trafik untuk mengelakkan kesan negatif terhadap pengalaman pengguna.

Atas ialah kandungan terperinci Kaedah pelaksanaan mekanisme pengehad arus teragih Redis. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!