پیداوار میں Redis اعلی دستیابی: سینٹینیل، کلسٹر، اور Kubernetes آپریٹرز

Redis جدید ایپلیکیشن انفراسٹرکچر کی ریڑھ کی ہڈی ہے۔ یہ دنیا بھر میں لاکھوں ایپلیکیشنز کے لیے کیش، سیشن اسٹور، میسج بروکر، ریٹ محدود کرنے والا، لیڈر بورڈ انجن، اور ریئل ٹائم اینالیٹکس پائپ لائن کے طور پر کام کرتا ہے۔ ایک واحد Redis مثال ذیلی ملی سیکنڈ لیٹینسی کے ساتھ فی سیکنڈ سیکڑوں ہزاروں کارروائیوں کو سنبھال سکتی ہے — لیکن ایک واحد مثال ناکامی کا ایک واحد نقطہ بھی ہے۔ جب Redis نیچے جاتا ہے تو، ایپلیکیشنز کو جھنجھوڑ کر ناکامی کا سامنا کرنا پڑتا ہے: کیش سٹیمپیڈز بیک اینڈ ڈیٹا بیس پر حاوی ہو جاتے ہیں، سیشن ختم ہو جاتے ہیں، ریٹ محدود کرنے والے کام کرنا چھوڑ دیتے ہیں، اور حقیقی وقت کی خصوصیات تاریک ہو جاتی ہیں۔ پروڈکشن سسٹمز کے لیے انتہائی دستیاب Redis کی تعیناتی اختیاری نہیں ہے - یہ انجینئرنگ کی ضرورت ہے۔

یہ گائیڈ Redis اعلی دستیابی میں ایک جامع، پیداوار پر مرکوز گہری غوطہ ہے۔ ہم Redis ریپلیکیشن کے بنیادی اصولوں کا احاطہ کریں گے (غیر مطابقت پذیر نقل، WAIT کمانڈ، اور جزوی دوبارہ مطابقت پذیری)، خودکار فیل اوور اور سروس کی دریافت کے لیے Redis سینٹینیل، ہیش سلاٹ کی تقسیم کے ساتھ افقی اسکیلنگ کے لیے Redis کلسٹر، Kubernetes آپریٹرز، Kubernetes آپریٹرز (SpotreeX)، ایکس پی آر 4 ایکس آپریٹرز حکمت عملی (RDB سنیپ شاٹس، AOF، اور ہائبرڈ استقامت)، AWS ElastiCache پر کلاؤڈ کے زیر انتظام تعیناتیاں، Redis کے لیے Azure کیش، اور GCP میموری اسٹور، رینچر اور لانگ ہارن کے ساتھ ننگی دھاتی k3s کی تعیناتیاں، میموری مینجمنٹ اور بے دخلی کی پالیسیاں، XPRPX کنٹرول پالیسیاں، ایکس پی آر ایکس سی ایل ایکس سی ایل کنٹرول HA کنفیگریشنز میں پب/سب اور اسٹریمز کا رویہ، HA میں Redis ماڈیولز (RedisJSON، RediSearch، RedisTimeSeries)، کنکشن پولنگ اور فیل اوور لچک کے لیے کلائنٹ کنفیگریشن، بیک اپ اور بحالی کی حکمت عملی، Redis INFO کے ساتھ مانیٹرنگ، Redis INFO اور ایکسپورٹ ایکسپورٹ بورڈ، ایکس پی آر 3 ایکسپورٹ اور ایکسپورٹ بورڈ۔ KeyDB بطور Redis-مطابقت پذیر متبادل، پائپ لائننگ کے ساتھ پرفارمنس ٹیوننگ، Lua اسکرپٹنگ، اور میموری آپٹیمائزیشن، عام ناکامی کے منظرنامے اور ٹربل شوٹنگ کے طریقہ کار، اور صلاحیت کی منصوبہ بندی اور اسکیلنگ کی حکمت عملی۔

Redis نقل کے بنیادی اصول

Redis نقل وہ بنیاد ہے جس پر تمام اعلیٰ دستیابی کے فن تعمیرات بنائے گئے ہیں۔ ایک Redis ماسٹر مثال تحریروں کو قبول کرتا ہے اور متضاد طور پر ان کو ایک یا زیادہ نقل مثالوں میں پھیلاتا ہے۔ نقلیں ماسٹر کے ڈیٹاسیٹ کی قریب قریب ریئل ٹائم کاپی کو برقرار رکھتی ہیں اور پڑھنے کے سوالات پیش کرتی ہیں، ڈیٹا کی فالتو پن اور پڑھنے کی اسکیل ایبلٹی دونوں فراہم کرتی ہیں۔

PostgreSQL کی WAL پر مبنی سٹریمنگ ریپلیکیشن کے برعکس، Redis کمانڈ پر مبنی ریپلیکیشن پروٹوکول استعمال کرتا ہے۔ ماسٹر پر عمل میں لائی جانے والی ہر تحریری کمانڈ کو ریپلیکیشن اسٹریم میں سیریلائز کیا جاتا ہے اور منسلک ریپلیکس کو بھیجا جاتا ہے، جو اپنے مقامی ڈیٹاسیٹس کے خلاف وہی کمانڈ چلاتے ہیں۔ یہ نقطہ نظر سادہ اور موثر ہے لیکن مستقل مزاجی کے لیے اس کے اہم مضمرات ہیں — چونکہ نقل بطور ڈیفالٹ غیر مطابقت پذیر ہے، اس لیے ہمیشہ ایک ونڈو موجود ہوتی ہے جہاں ماسٹر پر تسلیم شدہ تحریریں ابھی تک نقل تک نہیں پہنچی ہیں۔

اسینکرونس ریپلیکیشن اور WAIT کمانڈ

بطور ڈیفالٹ، Redis نقل مکمل طور پر غیر مطابقت پذیر ہے۔ ماسٹر مقامی طور پر درخواست دینے کے فوراً بعد کلائنٹ کو ایک تحریر تسلیم کرتا ہے، رسید کی تصدیق کے لیے کسی نقل کا انتظار کیے بغیر۔ یہ زیادہ سے زیادہ رائٹ تھرو پٹ دیتا ہے لیکن ایک ممکنہ ڈیٹا ضائع کرنے والی ونڈو کو متعارف کراتا ہے — اگر کسی تحریر تک پہنچنے سے پہلے ماسٹر کریش ہو جاتا ہے، تو وہ تحریر ضائع ہو جاتی ہے۔

WAITکمانڈ ایک ہم وقت ساز نقل تیار کرتی ہے۔ تحریر جاری کرنے کے بعد، کلائنٹ اس وقت تک بلاک کرنے کے لیےWAIT numreplicas timeoutکو کال کر سکتا ہے جب تک کہ نقل کی مخصوص تعداد تحریر کو تسلیم نہ کر لے یا ٹائم آؤٹ ختم نہ ہو جائے۔ یہ Redis کو مکمل طور پر مطابقت پذیر نہیں بناتا ہے —WAITصرف اس بات کی ضمانت دیتا ہے کہ نقلوں کو ڈیٹا موصول ہوا ہے، یہ نہیں کہ اسے نقل پر ڈسک پر برقرار رکھا گیا ہے۔ تاہم، یہ ڈیٹا ضائع ہونے والی ونڈو کو نمایاں طور پر کم کرتا ہے۔

# Write a critical value and wait for 2 replicas to acknowledge
SET order:12345 '{"status":"confirmed","amount":599.99}'
WAIT 2 5000
# Returns the number of replicas that acknowledged within 5000ms
# Returns 0 if no replica acknowledged (timeout or no replicas connected)

تنقیدی تحریروں (مالی لین دین، آرڈر کی تصدیق) کے لیے منتخب طور پرWAITکا استعمال کریں جبکہ غیر تنقیدی تحریروں (کیش اپ ڈیٹس، سیشن ریفریشز) کو متضاد طور پر آگے بڑھنے کی اجازت دیں۔ فی کمان کی لچک مکمل مطابقت پذیر نقل کی تاخیر کے جرمانے سے بچتی ہے۔

جزوی دوبارہ مطابقت پذیری (PSYNC)

جب ایک نقل مختصر طور پر منقطع ہو جاتی ہے (نیٹ ورک بلپ، دوبارہ شروع)، اسے دوبارہ شامل ہونے کے لیے مکمل ڈیٹاسیٹ کی منتقلی کی ضرورت نہیں ہوتی ہے۔ Redis ایک نقلی بیک لاگ کو برقرار رکھتا ہے — حالیہ تحریری کمانڈز کا ایک سرکلر بفر — ماسٹر پر۔ جب ریپلیکا دوبارہ منسلک ہوتا ہے، تو یہ اپنی نقل کو آفسیٹ ماسٹر کو بھیجتا ہے۔ اگر آفسیٹ ابھی بھی بیک لاگ کے اندر ہے، تو ماسٹر صرف غائب کمانڈز بھیجتا ہے (جزوی دوبارہ مطابقت پذیری)۔ اگر آفسیٹ بیک لاگ سے باہر ہو گیا ہے تو، ایک مکمل دوبارہ ہم آہنگی شروع ہو جاتی ہے، جس میں RDB سنیپ شاٹ بنانا اور منتقل کرنا شامل ہوتا ہے۔

# redis.conf — Replication backlog configuration
repl-backlog-size 256mb          # Size of the replication backlog buffer
repl-backlog-ttl 3600            # Seconds to retain backlog after last replica disconnects
repl-diskless-sync yes           # Transfer RDB via socket instead of disk (faster for full sync)
repl-diskless-sync-delay 5       # Wait 5s for more replicas before starting diskless sync
repl-diskless-sync-period 0      # No periodic full sync
repl-diskless-load on-empty-db   # Replica loads RDB from socket directly into memory

نقل کے بیک لاگ کو درست طریقے سے سائز کرنا اہم ہے۔ یہ اتنا بڑا ہونا چاہئے کہ سب سے طویل متوقع ریپلیکا منقطع ہونے کے دوران تیار کردہ تمام تحریری کمانڈز کو روک سکے۔ ایک Redis مثال کے لیے 50MB/s تحریری ٹریفک پر کارروائی کرنے کے لیے، ایک 256MB بیک لاگ تقریباً 5 سیکنڈ کی تحریروں پر محیط ہوتا ہے — اگر آپ کی نقلیں طویل عرصے تک آف لائن ہو سکتی ہیں تو اس میں اضافہ کریں۔

Master-Replica Replication کو ترتیب دینا

# redis.conf — Master configuration
bind 0.0.0.0
port 6379
protected-mode no
requirepass strong_master_password
masterauth strong_master_password

# Persistence
save 900 1
save 300 10
save 60 10000
appendonly yes
appendfsync everysec
aof-use-rdb-preamble yes

# Replication
repl-backlog-size 256mb
repl-backlog-ttl 3600
repl-diskless-sync yes
min-replicas-to-write 1          # Refuse writes if fewer than 1 replica connected
min-replicas-max-lag 10          # Replica considered disconnected if lag > 10 seconds

# redis.conf — Replica configuration
bind 0.0.0.0
port 6379
protected-mode no
requirepass strong_master_password
masterauth strong_master_password

replicaof master-host 6379
replica-read-only yes
replica-serve-stale-data yes     # Serve (possibly stale) data during sync
replica-priority 100             # Lower values get promoted first by Sentinel

min-replicas-to-writeاورmin-replicas-max-lagکی ترتیبات ماسٹر کو تحریروں کو قبول کرنے سے روکتی ہیں جب وہ نقل پر ڈیٹا کے استحکام کی ضمانت نہیں دے سکتا۔ یہ ایک اہم حفاظتی جال ہے — اس کے بغیر، نیٹ ورک سے تقسیم شدہ ماسٹر ایسی تحریروں کو قبول کرتا رہتا ہے جو سینٹینیل کے نقل کو فروغ دینے پر ختم ہو جائیں گی۔

Redis سینٹینیل: خودکار فیل اوور اور سروس ڈسکوری

Redis سینٹینیل ایک تقسیم شدہ نظام ہے جو Redis ماسٹر اور ریپلیکا مثالوں کی نگرانی کرتا ہے، ماسٹر کی ناکامیوں کا پتہ لگاتا ہے، ایک نقل کو ماسٹر پر ترقی دے کر خودکار فیل اوور انجام دیتا ہے، اور سروس کی دریافت فراہم کرتا ہے تاکہ کلائنٹس ہمیشہ موجودہ ماسٹر کو تلاش کر سکیں۔ سینٹینیل Redis کے ساتھ ایک الگ عمل کے طور پر چلتا ہے اور ایک متفقہ پروٹوکول کے ذریعے کام کرتا ہے - سینٹینیل مثالوں کے ایک کورم کو اس بات پر متفق ہونا چاہیے کہ فیل اوور شروع کرنے سے پہلے ایک ماسٹر ناقابل رسائی ہے۔

سینٹینیل کنفیگریشن

سینٹینیل کو ایک سینٹینیل کی ناکامی کو برداشت کرنے اور پھر بھی کورم کو برقرار رکھنے کے لیے کم از کم تین مثالوں کی ضرورت ہوتی ہے۔ ہر سینٹینیل ایک ہی Redis ماسٹر کی نگرانی کرتا ہے اور ماسٹر کی صحت کی حیثیت پر متفق ہونے کے لیے گپ شپ پروٹوکول کے ذریعے دوسرے سینٹینیلز کے ساتھ بات چیت کرتا ہے۔

# /etc/redis/sentinel.conf — Sentinel instance configuration
port 26379
bind 0.0.0.0
protected-mode no

# Monitor the master named "mymaster" at 10.0.1.10:6379
# The quorum value (2) means 2 Sentinels must agree the master is down
sentinel monitor mymaster 10.0.1.10 6379 2

# Authentication
sentinel auth-pass mymaster strong_master_password

# Timing parameters
sentinel down-after-milliseconds mymaster 5000    # SDOWN after 5s of no PING response
sentinel failover-timeout mymaster 60000          # Max 60s for failover procedure
sentinel parallel-syncs mymaster 1                # Only 1 replica syncs from new master at a time

# Deny script execution for security
sentinel deny-scripts-reconfig yes

# Notification script (called on failover events)
# sentinel notification-script mymaster /opt/redis/notify.sh

# Client reconfiguration script (called when master changes)
# sentinel client-reconfig-script mymaster /opt/redis/reconfig.sh

# Logging
logfile /var/log/redis/sentinel.log
logevel notice

# Enable TLS for Sentinel communication
# tls-port 26379
# port 0
# tls-cert-file /etc/redis/tls/sentinel.crt
# tls-key-file /etc/redis/tls/sentinel.key
# tls-ca-cert-file /etc/redis/tls/ca.crt
# tls-replication yes
# tls-auth-clients optional

سینٹینل کی ناکامی کا پتہ لگانا دو مراحل میں کام کرتا ہے۔ سب سے پہلے، ایک فرد سینٹینیل ایک ماسٹر کوSubjectively Down (SDOWN)کے بطور نشان زد کرتا ہے جب اسےdown-after-millisecondsکے اندر PING کا کوئی درست جواب نہیں ملتا ہے۔ پھر، جب سینٹینلز کا ایک کورم اس بات سے اتفاق کرتا ہے کہ ماسٹر ناقابل رسائی ہے، تو اسےObjectively Down (ODOWN)کے طور پر نشان زد کیا جاتا ہے، اور فیل اوور کا عمل شروع ہوتا ہے۔ ایک سینٹینیل کو فیل اوور لیڈر کے طور پر منتخب کیا جاتا ہے، جو بہترین نقل کا انتخاب کرتا ہے (ترجیح، ریپلیکیشن آفسیٹ، اور رنیڈ کی بنیاد پر)، اسے ماسٹر پر ترقی دیتا ہے، نئے ماسٹر کی پیروی کرنے کے لیے بقیہ ریپلیکا کو دوبارہ ترتیب دیتا ہے، اور سینٹینیل اسٹیٹ کو اپ ڈیٹ کرتا ہے۔

سینٹینیل سروس ڈسکوری اور کلائنٹ کنفیگریشن

سٹیٹک ماسٹر ریپلیکا سیٹ اپ پر سینٹینیل کا اہم فائدہ سروس کی دریافت ہے۔ کلائنٹ ایک مقررہ Redis ایڈریس سے منسلک نہیں ہوتے ہیں — وہ سینٹینیل سے موجودہ ماسٹر ایڈریس کے لیے پوچھتے ہیں اور فیل اوور اطلاعات کو سبسکرائب کرتے ہیں۔ ہر بڑی Redis کلائنٹ لائبریری سینٹینیل کو مقامی طور پر سپورٹ کرتی ہے۔

# Node.js — ioredis with Sentinel support
const Redis = require('ioredis');

const redis = new Redis({
  sentinels: [
    { host: '10.0.1.20', port: 26379 },
    { host: '10.0.1.21', port: 26379 },
    { host: '10.0.1.22', port: 26379 }
  ],
  name: 'mymaster',
  password: 'strong_master_password',
  sentinelPassword: 'sentinel_password',
  db: 0,
  retryStrategy(times) {
    const delay = Math.min(times * 200, 5000);
    return delay;
  },
  reconnectOnError(err) {
    const targetError = 'READONLY';
    if (err.message.includes(targetError)) {
      return true; // Reconnect on READONLY error (failover happened)
    }
    return false;
  },
  maxRetriesPerRequest: 3,
  enableReadyCheck: true,
  connectTimeout: 10000,
  lazyConnect: false
});

redis.on('connect', () => console.log('Connected to Redis master'));
redis.on('error', (err) => console.error('Redis error:', err));
redis.on('+switch-master', (msg) => {
  console.log('Master switched:', msg);
});

# Python — redis-py with Sentinel support
from redis.sentinel import Sentinel
import redis

sentinel = Sentinel(
    [('10.0.1.20', 26379), ('10.0.1.21', 26379), ('10.0.1.22', 26379)],
    socket_timeout=5,
    password='strong_master_password',
    sentinel_kwargs={'password': 'sentinel_password'}
)

# Get a connection to the current master (for writes)
master = sentinel.master_for(
    'mymaster',
    socket_timeout=5,
    retry_on_timeout=True,
    db=0
)

# Get a connection to a replica (for reads)
replica = sentinel.slave_for(
    'mymaster',
    socket_timeout=5,
    db=0
)

# Usage
master.set('session:user123', '{"logged_in": true}')
result = replica.get('session:user123')
print(result)

// Go — go-redis with Sentinel support
package main

import (
    "context"
    "fmt"
    "time"

    "github.com/redis/go-redis/v9"
)

func main() {
    ctx := context.Background()

    rdb := redis.NewFailoverClient(&redis.FailoverOptions{
        MasterName:       "mymaster",
        SentinelAddrs:    []string{"10.0.1.20:26379", "10.0.1.21:26379", "10.0.1.22:26379"},
        Password:         "strong_master_password",
        SentinelPassword: "sentinel_password",
        DB:               0,
        DialTimeout:      10 * time.Second,
        ReadTimeout:      5 * time.Second,
        WriteTimeout:     5 * time.Second,
        PoolSize:         50,
        MinIdleConns:     10,
        MaxRetries:       3,
        MinRetryBackoff:  200 * time.Millisecond,
        MaxRetryBackoff:  5 * time.Second,
    })
    defer rdb.Close()

    err := rdb.Set(ctx, "key", "value", 5*time.Minute).Err()
    if err != nil {
        fmt.Printf("Error: %v
", err)
        return
    }

    val, err := rdb.Get(ctx, "key").Result()
    if err != nil {
        fmt.Printf("Error: %v
", err)
        return
    }
    fmt.Printf("key = %s
", val)
}

Redis کلسٹر: ہیش سلاٹس

جبکہ سینٹینیل ایک واحد ڈیٹاسیٹ کے لیے اعلیٰ دستیابی فراہم کرتا ہے، Redis کلسٹر HA اور افقی اسکیلنگ دونوں فراہم کرتا ہے۔ Redis کلسٹر ڈیٹا کو ہیش سلاٹ میکانزم کا استعمال کرتے ہوئے متعدد ماسٹر نوڈس میں تقسیم کرتا ہے — کی اسپیس کو 16,384 ہیش سلاٹس میں تقسیم کیا گیا ہے، اور ہر ماسٹر ان سلاٹس کے ذیلی سیٹ کے لیے ذمہ دار ہے۔ ہر ماسٹر کے پاس فیل اوور کے لیے ایک یا زیادہ نقلیں ہوتی ہیں۔ کلسٹر اجتماعی طور پر خودکار شارڈنگ، بلٹ ان فیل اوور، اور نوڈس کو شامل کرکے سٹوریج اور تھرو پٹ دونوں کو لکیری طور پر پیمانہ کرنے کی صلاحیت فراہم کرتا ہے۔

Redis کلسٹر

# Create a 6-node Redis Cluster (3 masters + 3 replicas)
# Each node needs a redis.conf with cluster-enabled

# redis.conf for each cluster node (adjust port per node)
port 7000
cluster-enabled yes
cluster-config-file nodes-7000.conf
cluster-node-timeout 5000
appendonly yes
appendfsync everysec
aof-use-rdb-preamble yes
requirepass cluster_password
masterauth cluster_password
bind 0.0.0.0
protected-mode no
repl-backlog-size 256mb

# Start all 6 Redis instances
redis-server /etc/redis/7000.conf
redis-server /etc/redis/7001.conf
# ... repeat for all 6 nodes

# Create the cluster
redis-cli --cluster create \
  10.0.1.10:7000 10.0.1.11:7000 10.0.1.12:7000 \
  10.0.1.13:7000 10.0.1.14:7000 10.0.1.15:7000 \
  --cluster-replicas 1 \
  -a cluster_password

# Verify cluster status
redis-cli -c -h 10.0.1.10 -p 7000 -a cluster_password cluster info
redis-cli -c -h 10.0.1.10 -p 7000 -a cluster_password cluster nodes

ریشارڈنگ اور ملٹی کلیدی آپریشنز

ریشارڈنگ نوڈس کو شامل کرنے یا ہٹانے کے بعد ڈیٹا کو متوازن کرنے کے لیے ماسٹرز کے درمیان ہیش سلاٹس کو منتقل کرتا ہے۔ دوبارہ شارڈنگ کے دوران، منتقلی کے سلاٹس میں کیز ASK ری ڈائریکشنز حاصل کر سکتی ہیں، جسے کلائنٹ شفاف طریقے سے ہینڈل کرتا ہے۔

# Add a new node to the cluster
redis-cli --cluster add-node 10.0.1.16:7000 10.0.1.10:7000 -a cluster_password

# Reshard slots to the new node
redis-cli --cluster reshard 10.0.1.10:7000 \
  --cluster-from all \
  --cluster-to NEW_NODE_ID \
  --cluster-slots 4096 \
  --cluster-yes \
  -a cluster_password

# Rebalance the cluster automatically
redis-cli --cluster rebalance 10.0.1.10:7000 -a cluster_password

# Check cluster slot distribution
redis-cli -c -h 10.0.1.10 -p 7000 -a cluster_password cluster slots

ملٹی کلیدی آپریشنز صرف اس وقت کام کرتے ہیں جب شامل تمام کلیدیں ایک ہی ہیش سلاٹ میں رہیں۔ ایک ہی سلاٹ پر متعلقہ کلیدوں کے نقشے کو یقینی بنانے کے لیے ہیش ٹیگز کا استعمال کریں:{user:123}.profileاور{user:123}.sessionsدونوں ہیشuser:123پر، اس بات کی ضمانت دیتے ہوئے کہ وہ ایک ہی نوڈ پر اترتے ہیں۔ یہ ایم جی ای ٹی، ایم ایس ای ٹی، لین دین، اور لوا اسکرپٹ کو متعلقہ کلیدوں پر قابل بناتا ہے۔

# Hash tags ensure these keys are in the same slot
SET {order:5000}.details '{"item":"widget","qty":3}'
SET {order:5000}.payment '{"method":"card","status":"paid"}'
SET {order:5000}.shipping '{"carrier":"fedex","tracking":"FX123"}'

# Multi-key operations work because all keys share the {order:5000} hash tag
MGET {order:5000}.details {order:5000}.payment {order:5000}.shipping

# Transaction across same-slot keys
MULTI
SET {order:5000}.details '{"item":"widget","qty":3,"status":"confirmed"}'
SET {order:5000}.payment '{"method":"card","status":"captured"}'
EXEC

Redis آپریٹر Kubernetes

Redis کو Kubernetes میں چلانے کے لیے مستقل اسٹوریج، نیٹ ورک کی شناخت، شاندار فیل اوور، اور کنفیگریشن مینجمنٹ کو احتیاط سے سنبھالنے کی ضرورت ہے۔ Kubernetes آپریٹرز اس آپریشنل علم کو اپنی مرضی کے کنٹرولرز میں انکوڈ کرتے ہیں جو کسٹم ریسورس ڈیفینیشنز (CRDs) کے ذریعے اعلانیہ طور پر Redis کلسٹرز کا انتظام کرتے ہیں۔

Spotahome Redis آپریٹر

Spotahome آپریٹر (جسے redis-operator بھی کہا جاتا ہے) Kubernetes میں Redis سینٹینیل پر مبنی HA کو تعینات کرنے کے لیے ایک بالغ، وسیع پیمانے پر استعمال ہونے والا آپریٹر ہے۔ یہ سینٹینیل پر مبنی فیل اوور کے ساتھ Redis ماسٹر ریپلیکا سیٹ کا انتظام کرتا ہے۔

# Install the Spotahome Redis Operator
helm repo add spotahome https://spotahome.github.io/redis-operator
helm install redis-operator spotahome/redis-operator \
  --namespace redis-system --create-namespace

# RedisFailover CRD — 3 Redis instances + 3 Sentinels
apiVersion: databases.spotahome.com/v1
kind: RedisFailover
metadata:
  name: redis-ha
  namespace: production
spec:
  sentinel:
    replicas: 3
    resources:
      requests:
        cpu: 100m
        memory: 128Mi
      limits:
        cpu: 200m
        memory: 256Mi
    customConfig:
      down-after-milliseconds: "5000"
      failover-timeout: "60000"
  redis:
    replicas: 3
    resources:
      requests:
        cpu: "2"
        memory: 8Gi
      limits:
        cpu: "4"
        memory: 16Gi
    storage:
      persistentVolumeClaim:
        metadata:
          name: redis-data
        spec:
          accessModes:
            - ReadWriteOnce
          resources:
            requests:
              storage: 50Gi
          storageClassName: longhorn
    customConfig:
      maxmemory: "6gb"
      maxmemory-policy: "allkeys-lru"
      save: "900 1 300 10 60 10000"
      appendonly: "yes"
      appendfsync: "everysec"
      aof-use-rdb-preamble: "yes"
      repl-backlog-size: "256mb"
    exporter:
      enabled: true
      image: oliver006/redis_exporter:latest
      args:
        - --include-system-metrics

OpsTree Redis آپریٹر

OpsTree آپریٹر Redis سینٹینیل (اسٹینڈ ایلون HA) اور Redis کلسٹر (شارڈڈ HA) ٹوپولاجی دونوں کو سپورٹ کرتا ہے، جو اسے مختلف استعمال کے معاملات کے لیے زیادہ ورسٹائل بناتا ہے۔

# Install the OpsTree Redis Operator
helm repo add ot-helm https://ot-container-kit.github.io/helm-charts/
helm install redis-operator ot-helm/redis-operator \
  --namespace redis-system --create-namespace

# Redis Cluster CRD — 3 masters + 3 replicas
apiVersion: redis.redis.opstreelabs.in/v1beta2
kind: RedisCluster
metadata:
  name: redis-cluster
  namespace: production
spec:
  clusterSize: 3
  clusterVersion: v7
  persistenceEnabled: true
  kubernetesConfig:
    image: redis:7.2-alpine
    imagePullPolicy: IfNotPresent
    resources:
      requests:
        cpu: "2"
        memory: 8Gi
      limits:
        cpu: "4"
        memory: 16Gi
  redisLeader:
    replicas: 3
    redisConfig:
      additionalRedisConfig: |
        maxmemory 6gb
        maxmemory-policy allkeys-lru
        appendonly yes
        appendfsync everysec
  redisFollower:
    replicas: 3
    redisConfig:
      additionalRedisConfig: |
        maxmemory 6gb
        replica-read-only yes
  storage:
    volumeClaimTemplate:
      spec:
        accessModes:
          - ReadWriteOnce
        resources:
          requests:
            storage: 50Gi
        storageClassName: longhorn
  redisExporter:
    enabled: true
    image: quay.io/opstree/redis-exporter:v1.44.0

Redis انٹرپرائز آپریٹر

Redis انٹرپرائز ایک تجارتی Kubernetes آپریٹر فراہم کرتا ہے جس میں ایکٹیو ایکٹو جیو ریپلیکیشن (CRDTs)، Redis ماڈیولز سپورٹ، آٹو ٹائرنگ (RAM + فلیش) اور خودکار کلسٹر مینجمنٹ شامل ہیں۔ یہ ان تنظیموں کے لیے تجویز کردہ آپشن ہے جنہیں انٹرپرائز گریڈ SLAs اور تعاون کی ضرورت ہے۔

# Redis Enterprise Operator CRD
apiVersion: app.redislabs.com/v1
kind: RedisEnterpriseCluster
metadata:
  name: redis-enterprise
  namespace: redis-enterprise
spec:
  nodes: 3
  persistentSpec:
    enabled: true
    storageClassName: longhorn
    volumeSize: 100Gi
  redisEnterpriseNodeResources:
    limits:
      cpu: "8"
      memory: 32Gi
    requests:
      cpu: "4"
      memory: 16Gi
  uiServiceType: ClusterIP
  servicesRiggerSpec:
    databaseServiceType: ClusterIP
---
apiVersion: app.redislabs.com/v1alpha1
kind: RedisEnterpriseDatabase
metadata:
  name: redis-ha-db
  namespace: redis-enterprise
spec:
  memorySize: 10GB
  replication: true
  shardCount: 3
  persistence: aofEverySecond
  tlsMode: enabled
  modulesList:
    - name: search
      version: latest
    - name: json
      version: latest

استقامت کی حکمت عملی: RDB، AOF، اور ہائبرڈ

Redis تین استقامت کا طریقہ کار پیش کرتا ہے۔ صحیح حکمت عملی کا انتخاب آپ کے ریکوری پوائنٹ مقصد (RPO)، کارکردگی کی ضروریات اور اسٹوریج کی رکاوٹوں پر منحصر ہے۔

RDB سنیپ شاٹسترتیب شدہ وقفوں پر پورے ڈیٹا سیٹ کے پوائنٹ ان ٹائم اسنیپ شاٹس بناتے ہیں۔ وہ کمپیکٹ، دوبارہ شروع ہونے پر لوڈ کرنے میں تیز، اور بیک اپ کے لیے مثالی ہیں۔ تاہم، اسنیپ شاٹس کے درمیان لکھا ہوا ڈیٹا کریش پر ضائع ہو جاتا ہے۔ RDB ایک کانٹے دار چائلڈ پروسیس کا استعمال کرتا ہے، اس لیے اسنیپ شاٹ کی تخلیق مرکزی Redis تھریڈ کو مسدود نہیں کرتی ہے — لیکن فورک خود کاپی آن رائٹ میموری ایلوکیشن کی وجہ سے بڑے ڈیٹا سیٹس پر تاخیر کا سبب بن سکتا ہے۔

AOF (صرف فائل شامل کریں)ہر تحریری عمل کو ڈسک پر لاگ کرتا ہے۔ یہ RDB سے کہیں زیادہ بہتر استحکام فراہم کرتا ہے —appendfsync everysecکے ساتھ، آپ کریش ہونے پر زیادہ سے زیادہ ایک سیکنڈ کا ڈیٹا کھو دیتے ہیں۔appendfsync alwaysکے ساتھ، آپ کچھ بھی نہیں کھوتے، لیکن کارکردگی کی ایک اہم قیمت پر۔ AOF فائلیں RDB سے بڑی ہیں اور دوبارہ شروع ہونے پر لوڈ ہونے میں سست ہیں۔

ہائبرڈ استقامت(تجویز کردہ نقطہ نظر) دونوں کو یکجا کرتا ہے:aof-use-rdb-preamble yesAOF فائل کے شروع میں ایک RDB سنیپ شاٹ لکھتا ہے، اس کے بعد بعد کی تحریروں کے لیے AOF اندراجات۔ یہ مضبوط استحکام (AOF سیکشن) کے ساتھ تیز آغاز کے اوقات (RDB سیکشن) دیتا ہے۔

# redis.conf — Hybrid persistence (recommended for production)

# RDB snapshots
save 900 1          # Snapshot if at least 1 write in 900 seconds
save 300 10         # Snapshot if at least 10 writes in 300 seconds
save 60 10000       # Snapshot if at least 10000 writes in 60 seconds
stop-writes-on-bgsave-error yes
rdbcompression yes
rdbchecksum yes
dbfilename dump.rdb
dir /data/redis

# AOF
appendonly yes
appendfilename "appendonly.aof"
appendfsync everysec           # Best balance of durability and performance
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb
aof-use-rdb-preamble yes       # Hybrid: RDB preamble + AOF tail
aof-timestamp-enabled yes      # Enable timestamps for PITR (Redis 7+)

# Recovery options
rdb-del-sync-files no
aof-load-truncated yes

کلاؤڈ مینیجڈ Redis تعیناتیاں

AWS ElastiCache Redis

AWS ElastiCache مکمل طور پر منظم Redis کو دو HA موڈز کے ساتھ پیش کرتا ہے:کلسٹر موڈ ڈس ایبلڈ(سنگل شارڈ، 5 ریپلیکس تک، سینٹینیل جیسا فیل اوور) اورکلسٹر موڈ فعال (ہر ایک کے ساتھ

تک، XTAG350 تک نقلیں، ہیش سلاٹ کی تقسیم)۔ گلوبل ڈیٹا اسٹور تباہی کی بحالی کے لیے کراس ریجن کی نقل فراہم کرتا ہے۔

# AWS CLI — Create ElastiCache Redis Cluster Mode Enabled
aws elasticache create-replication-group \
  --replication-group-id redis-ha-prod \
  --replication-group-description "Production Redis HA Cluster" \
  --engine redis \
  --engine-version 7.1 \
  --cache-node-type cache.r7g.2xlarge \
  --num-node-groups 3 \
  --replicas-per-node-group 2 \
  --automatic-failover-enabled \
  --multi-az-enabled \
  --at-rest-encryption-enabled \
  --transit-encryption-enabled \
  --auth-token strong_auth_token \
  --cache-subnet-group-name redis-subnet-group \
  --security-group-ids sg-0123456789abcdef0 \
  --snapshot-retention-limit 7 \
  --snapshot-window "03:00-05:00" \
  --preferred-maintenance-window "sun:05:00-sun:07:00" \
  --cache-parameter-group-name redis-ha-params \
  --log-delivery-configurations '[
    {"LogType":"slow-log","DestinationType":"cloudwatch-logs","DestinationDetails":{"CloudWatchLogsDetails":{"LogGroup":"/aws/elasticache/redis-ha-prod"}}},
    {"LogType":"engine-log","DestinationType":"cloudwatch-logs","DestinationDetails":{"CloudWatchLogsDetails":{"LogGroup":"/aws/elasticache/redis-ha-prod"}}}
  ]'

# Create Global Datastore for cross-region DR
aws elasticache create-global-replication-group \
  --global-replication-group-id-suffix redis-global \
  --primary-replication-group-id redis-ha-prod

# Add secondary region
aws elasticache create-replication-group \
  --replication-group-id redis-ha-dr \
  --replication-group-description "DR Redis in eu-west-2" \
  --global-replication-group-id ldgnf-redis-global \
  --cache-node-type cache.r7g.2xlarge \
  --num-node-groups 3 \
  --replicas-per-node-group 1 \
  --region eu-west-2

# Custom parameter group for HA tuning
aws elasticache create-cache-parameter-group \
  --cache-parameter-group-name redis-ha-params \
  --cache-parameter-group-family redis7 \
  --description "HA-optimised Redis 7 parameters"

aws elasticache modify-cache-parameter-group \
  --cache-parameter-group-name redis-ha-params \
  --parameter-name-values \
    "ParameterName=maxmemory-policy,ParameterValue=allkeys-lru" \
    "ParameterName=timeout,ParameterValue=300" \
    "ParameterName=tcp-keepalive,ParameterValue=60" \
    "ParameterName=activedefrag,ParameterValue=yes"

Azure کیشے Redis

کے لیے Redis کے لیے

Azure کیش تین درجات فراہم کرتا ہے: بنیادی (کوئی نقل نہیں)، معیاری (نقل شدہ) اور پریمیم/انٹرپرائز۔ پریمیم ٹائر کلسٹرنگ، جیو ریپلیکیشن، زون فالتو پن، VNet انجیکشن، اور ڈیٹا پرسسٹینس کو سپورٹ کرتا ہے۔ انٹرپرائز ٹائر Redis ماڈیولز اور ایکٹیو ایکٹو جیو ڈسٹری بیوشن کو شامل کرتا ہے۔

# Azure CLI — Create Premium Azure Cache for Redis with clustering
az redis create \
  --resource-group redis-ha-rg \
  --name redis-ha-prod \
  --location westeurope \
  --sku Premium \
  --vm-size P3 \
  --shard-count 3 \
  --replicas-per-master 1 \
  --zones 1 2 3 \
  --minimum-tls-version 1.2 \
  --redis-version 7

# Enable geo-replication (link primary to secondary)
az redis server-link create \
  --name redis-ha-prod \
  --resource-group redis-ha-rg \
  --server-to-link /subscriptions/.../redis-ha-dr \
  --replication-role Secondary

# Configure data persistence
az redis update \
  --name redis-ha-prod \
  --resource-group redis-ha-rg \
  --set redisConfiguration.rdb-backup-enabled=true \
  --set redisConfiguration.rdb-backup-frequency=60 \
  --set redisConfiguration.rdb-storage-connection-string="DefaultEndpointsProtocol=https;..."

# Enable diagnostics
az monitor diagnostic-settings create \
  --name redis-diagnostics \
  --resource /subscriptions/.../redis-ha-prod \
  --workspace /subscriptions/.../log-analytics-workspace \
  --metrics '[{"category":"AllMetrics","enabled":true}]'

GCP میموری اسٹور برائے Redis

GCP میموری اسٹور کے دو درجات پیش کرتا ہے:سٹینڈرڈ(آٹومیٹک فیل اوور ریپلیکا کے ساتھ واحد مثال) اورRedis کلسٹر(شارڈڈ، خودکار اسکیلنگ کے ساتھ مکمل طور پر منظم کلسٹر)۔ معیاری درجہ زیادہ تر HA کے استعمال کے کیسز کے لیے موزوں ہے، جبکہ Redis کلسٹر بڑے ڈیٹا سیٹس کو ہینڈل کرتا ہے جس میں افقی اسکیلنگ کی ضرورت ہوتی ہے۔

# GCP — Create Standard tier Memorystore (HA with auto-failover)
gcloud redis instances create redis-ha-prod \
  --size=26 \
  --region=europe-west1 \
  --zone=europe-west1-b \
  --alternative-zone=europe-west1-c \
  --tier=standard \
  --redis-version=redis_7_2 \
  --redis-config="maxmemory-policy=allkeys-lru,activedefrag=yes" \
  --network=projects/my-project/global/networks/vpc-main \
  --transit-encryption-mode=SERVER_AUTHENTICATION \
  --enable-auth \
  --persistence-mode=RDB \
  --rdb-snapshot-period=12h \
  --rdb-snapshot-start-time="2026-04-12T03:00:00Z" \
  --maintenance-window-day=SUNDAY \
  --maintenance-window-hour=4

# GCP — Create Memorystore Redis Cluster
gcloud redis clusters create redis-cluster-prod \
  --region=europe-west1 \
  --shard-count=3 \
  --replica-count=1 \
  --network=projects/my-project/global/networks/vpc-main \
  --transit-encryption-mode=SERVER_AUTHENTICATION

ملٹی ریجن Redis تعیناتی

ملٹی ریجن Redis کی تعیناتی تباہی کی بحالی اور عالمی تاخیر میں کمی کے لیے ضروری ہے۔ نقطہ نظر فن تعمیر کے لحاظ سے مختلف ہوتا ہے: Redis انٹرپرائز حقیقی ملٹی ماسٹر تحریروں کے لیے CRDTs (تصادم سے پاک نقل شدہ ڈیٹا کی اقسام) کے ساتھ ایکٹیو ایکٹیو کا استعمال کرتا ہے، جبکہ اوپن سورس Redis اور کلاؤڈ مینیجڈ سروسز ثانوی علاقوں میں پڑھی ہوئی نقلوں کے ساتھ فعال-غیر فعال نقل کا استعمال کرتی ہیں۔

ننگی دھات k3s/رنچر لانگ ہارن

کے ساتھ

اپنے ہارڈ ویئر چلانے والی تنظیموں کے لیے، Redis HA کو ننگی دھات k3s پر تعینات کرنا بنیادی ڈھانچے پر مکمل کنٹرول فراہم کرتا ہے، کلاؤڈ وینڈر لاک ان کو ختم کرتا ہے، اور بڑے پیمانے پر تعیناتیوں کے لیے نمایاں طور پر زیادہ لاگت سے موثر ہو سکتا ہے۔ k3s ایک ہلکا پھلکا، تصدیق شدہ Kubernetes ڈسٹری بیوشن ہے جو کنارے اور ننگی دھاتی ماحول کے لیے مثالی ہے، جبکہ Rancher ملٹی کلسٹر آپریشنز کے لیے ایک انتظامی طیارہ فراہم کرتا ہے۔

k3s تنصیب اور Redis آپریٹر کی تعیناتی

# Install k3s on the first server node
curl -sfL https://get.k3s.io | K3S_TOKEN=redis-cluster-token \
  INSTALL_K3S_EXEC="server --cluster-init --disable traefik --disable servicelb" sh -

# Join additional server nodes
curl -sfL https://get.k3s.io | K3S_TOKEN=redis-cluster-token \
  K3S_URL=https://10.0.0.1:6443 \
  INSTALL_K3S_EXEC="server" sh -

# Install Longhorn for distributed block storage
helm repo add longhorn https://charts.longhorn.io
helm install longhorn longhorn/longhorn \
  --namespace longhorn-system --create-namespace \
  --set defaultSettings.defaultDataPath=/mnt/longhorn \
  --set defaultSettings.replicaCount=3 \
  --set defaultSettings.storageMinimalAvailablePercentage=15

# Install MetalLB for bare-metal LoadBalancer services
helm repo add metallb https://metallb.github.io/metallb
helm install metallb metallb/metallb --namespace metallb-system --create-namespace

# Configure MetalLB IP address pool
kubectl apply -f - <

Redis HA Helm قدریں k3s

کے لیے

# values-redis-ha.yaml — Helm values for Redis HA on k3s/Longhorn
redis:
  replicas: 3
  resources:
    requests:
      cpu: "2"
      memory: 8Gi
    limits:
      cpu: "4"
      memory: 16Gi
  storage:
    persistentVolumeClaim:
      metadata:
        name: redis-data
      spec:
        accessModes:
          - ReadWriteOnce
        resources:
          requests:
            storage: 50Gi
        storageClassName: longhorn
  customConfig:
    maxmemory: "6gb"
    maxmemory-policy: "allkeys-lru"
    save: "900 1 300 10 60 10000"
    appendonly: "yes"
    appendfsync: "everysec"
    aof-use-rdb-preamble: "yes"
    repl-backlog-size: "256mb"
    tcp-keepalive: "60"
    timeout: "300"
    hz: "10"
    activedefrag: "yes"
  exporter:
    enabled: true
    image: oliver006/redis_exporter:latest

sentinel:
  replicas: 3
  resources:
    requests:
      cpu: 100m
      memory: 128Mi
    limits:
      cpu: 200m
      memory: 256Mi
  customConfig:
    down-after-milliseconds: "5000"
    failover-timeout: "60000"
    parallel-syncs: "1"

affinity:
  podAntiAffinity:
    requiredDuringSchedulingIgnoredDuringExecution:
      - labelSelector:
          matchExpressions:
            - key: app.kubernetes.io/component
              operator: In
              values:
                - redis
        topologyKey: kubernetes.io/hostname

میموری مینجمنٹ اور بے دخلی کی پالیسیاں

Redis تمام ڈیٹا کو میموری میں محفوظ کرتا ہے، جس سے میموری کا انتظام سب سے اہم آپریشنل تشویش ہے۔ جب Redis ترتیب شدہmaxmemoryکی حد تک پہنچ جاتا ہے، تو اسے یہ فیصلہ کرنا چاہیے کہ آنے والی تحریری کمانڈز کے ساتھ کیا کرنا ہے۔ بے دخلی کی پالیسی اس رویے کو کنٹرول کرتی ہے۔

# redis.conf — Memory management
maxmemory 6gb
maxmemory-policy allkeys-lru

# Available eviction policies:
# noeviction        — Return errors on writes when memory limit reached
# allkeys-lru       — Evict least recently used keys (general-purpose cache)
# allkeys-lfu       — Evict least frequently used keys (better for skewed access patterns)
# volatile-lru      — Evict LRU keys with TTL set
# volatile-lfu      — Evict LFU keys with TTL set
# volatile-ttl      — Evict keys with shortest TTL first
# allkeys-random    — Evict random keys
# volatile-random   — Evict random keys with TTL set

# Active defragmentation (Redis 4.0+)
activedefrag yes
active-defrag-enabled yes
active-defrag-ignore-bytes 100mb
active-defrag-threshold-lower 10
active-defrag-threshold-upper 100
active-defrag-cycle-min 1
active-defrag-cycle-max 25
active-defrag-max-scan-fields 1000

# Memory usage monitoring
# redis-cli INFO memory
# Key metrics:
#   used_memory           — Total bytes allocated by Redis
#   used_memory_rss       — Resident set size (OS-level memory)
#   mem_fragmentation_ratio — RSS / used_memory (should be close to 1.0)
#   maxmemory             — Configured memory limit
#   evicted_keys          — Total keys evicted due to maxmemory

HA کی تعیناتیوں کے لیے،maxmemoryکو نوڈ کی دستیاب RAM کے تقریباً 75% پر سیٹ کریں۔ بقیہ 25% ریپلیکشن آؤٹ پٹ بفر، AOF ری رائٹ بفر، RDB سنیپ شاٹس کے دوران کاپی آن رائٹ میموری، اور OS اوور ہیڈ کو ایڈجسٹ کرتا ہے۔ 16GB پوڈ کے لیے، maxmemory کو 12GB پر سیٹ کریں۔ 64GB ننگے دھاتی سرور کے لیے، اسے 48GB پر سیٹ کریں۔

TLS انکرپشن اور ACLs

پروڈکشن Redis تعیناتیوں کو TLS کے ساتھ ٹرانزٹ میں ڈیٹا کو انکرپٹ کرنا چاہیے اور Redis 6.0 میں متعارف کرائے گئے ACLs (ایکسیس کنٹرول لسٹوں) کے ساتھ عمدہ رسائی کنٹرول کو نافذ کرنا چاہیے۔

# redis.conf — TLS configuration
tls-port 6380
port 0                            # Disable non-TLS port entirely
tls-cert-file /etc/redis/tls/redis.crt
tls-key-file /etc/redis/tls/redis.key
tls-ca-cert-file /etc/redis/tls/ca.crt
tls-auth-clients optional         # Require client certificates (mutual TLS)
tls-replication yes               # Encrypt replication traffic
tls-cluster yes                   # Encrypt cluster bus traffic
tls-protocols "TLSv1.3"           # Only allow TLS 1.3

# ACL configuration (Redis 6.0+)
# user  on|off [>password] [~pattern] [+command|-command] [&channel]
user default off                  # Disable the default user
user admin on >strong_admin_pass ~* +@all
user appuser on >app_pass ~app:* ~session:* ~cache:* +@read +@write +@connection -@admin -@dangerous
user readonly on >readonly_pass ~* +@read +@connection -@write -@admin
user replicator on >repl_pass +psync +replconf +ping

# Load ACL from external file
aclfile /etc/redis/users.acl

HA سیٹ اپ

#!/bin/bash
# redis-backup.sh — Automated Redis backup script

REDIS_HOST="10.0.1.10"
REDIS_PORT="6379"
REDIS_PASS="strong_master_password"
BACKUP_DIR="/backups/redis"
S3_BUCKET="s3://redis-backups-prod"
RETENTION_DAYS=30
DATE=$(date +%Y%m%d_%H%M%S)

mkdir -p "$BACKUP_DIR"

# Trigger RDB snapshot on the master
redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" -a "$REDIS_PASS" BGSAVE

# Wait for background save to complete
while [ "$(redis-cli -h $REDIS_HOST -p $REDIS_PORT -a $REDIS_PASS LASTSAVE)" = "$(redis-cli -h $REDIS_HOST -p $REDIS_PORT -a $REDIS_PASS LASTSAVE)" ]; do
  sleep 1
done
sleep 2

# Copy the RDB file
RDB_FILE=$(redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" -a "$REDIS_PASS" CONFIG GET dir | tail -1)
cp "${RDB_FILE}/dump.rdb" "${BACKUP_DIR}/dump_${DATE}.rdb"

# Compress and upload to S3
gzip "${BACKUP_DIR}/dump_${DATE}.rdb"
aws s3 cp "${BACKUP_DIR}/dump_${DATE}.rdb.gz" "${S3_BUCKET}/daily/dump_${DATE}.rdb.gz" \
  --storage-class STANDARD_IA

# Cleanup old local backups
find "$BACKUP_DIR" -name "dump_*.rdb.gz" -mtime +$RETENTION_DAYS -delete

# Verify backup integrity
redis-check-rdb "${BACKUP_DIR}/dump_${DATE}.rdb.gz" && \
  echo "Backup verified: dump_${DATE}.rdb.gz" || \
  echo "ERROR: Backup verification failed!"

echo "Backup complete: ${BACKUP_DIR}/dump_${DATE}.rdb.gz"

# Restore from RDB backup
# 1. Stop Redis
systemctl stop redis

# 2. Replace the RDB file
gunzip /backups/redis/dump_20260412_030000.rdb.gz
cp /backups/redis/dump_20260412_030000.rdb /data/redis/dump.rdb
chown redis:redis /data/redis/dump.rdb

# 3. Disable AOF temporarily (if enabled) to prevent AOF overriding RDB on startup
redis-cli -a password CONFIG SET appendonly no

# 4. Start Redis (loads RDB)
systemctl start redis

# 5. Re-enable AOF and rewrite it from the loaded data
redis-cli -a password CONFIG SET appendonly yes
redis-cli -a password BGREWRITEAOF

# Run Dragonfly as a Redis replacement
docker run -d --name dragonfly \
  -p 6379:6379 \
  -v /data/dragonfly:/data \
  docker.dragonflydb.io/dragonflydb/dragonfly \
  --maxmemory 12gb \
  --proactor_threads 8 \
  --dbfilename dump.rdb \
  --requirepass strong_password

# Dragonfly in Kubernetes
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: dragonfly
  namespace: production
spec:
  replicas: 1
  selector:
    matchLabels:
      app: dragonfly
  template:
    metadata:
      labels:
        app: dragonfly
    spec:
      containers:
        - name: dragonfly
          image: docker.dragonflydb.io/dragonflydb/dragonfly:latest
          args:
            - --maxmemory=12gb
            - --proactor_threads=8
            - --requirepass=strong_password
            - --snapshot_cron=*/30 * * * *
          ports:
            - containerPort: 6379
          resources:
            requests:
              cpu: "4"
              memory: 16Gi
            limits:
              cpu: "8"
              memory: 16Gi
          volumeMounts:
            - name: data
              mountPath: /data
  volumeClaimTemplates:
    - metadata:
        name: data
      spec:
        accessModes: ["ReadWriteOnce"]
        storageClassName: longhorn
        resources:
          requests:
            storage: 100Gi

# keydb.conf — Multi-threaded configuration with active replication
server-threads 4                  # Use 4 threads for command processing
bind 0.0.0.0
port 6379
requirepass strong_password
masterauth strong_password

# Active-active replication (multi-master)
active-replica yes
replicaof peer-host 6379          # Bidirectional replication

# On the peer node, configure the reverse:
# replicaof this-host 6379

# FLASH storage tiering (for datasets larger than RAM)
# storage-provider flash /mnt/flash-storage 100
# maxmemory 16gb
# Will keep hot data in RAM and spill cold data to SSD

# SubKey expiration (unique to KeyDB)
# Allows setting TTL on hash fields, not just top-level keys
# EXPIREMEMBER myhash field1 3600

# Python — Pipelining with redis-py
import redis
import time

r = redis.Redis(host='10.0.1.10', port=6379, password='password', decode_responses=True)

# Without pipelining: 1000 round-trips
start = time.time()
for i in range(1000):
    r.set(f'key:{i}', f'value:{i}')
print(f'Without pipeline: {time.time() - start:.3f}s')

# With pipelining: 1 round-trip for 1000 commands
start = time.time()
pipe = r.pipeline(transaction=False)
for i in range(1000):
    pipe.set(f'key:{i}', f'value:{i}')
pipe.execute()
print(f'With pipeline: {time.time() - start:.3f}s')
# Typically 5-10x faster

# Lua script for atomic rate limiting
# KEYS[1] = rate limit key
# ARGV[1] = max requests
# ARGV[2] = window in seconds
local current = redis.call('INCR', KEYS[1])
if current == 1 then
    redis.call('EXPIRE', KEYS[1], ARGV[2])
end
if current > tonumber(ARGV[1]) then
    return 0  -- Rate limited
end
return 1  -- Allowed

# Load and execute
redis-cli -a password EVAL "\
  local current = redis.call('INCR', KEYS[1]) \
  if current == 1 then redis.call('EXPIRE', KEYS[1], ARGV[2]) end \
  if current > tonumber(ARGV[1]) then return 0 end \
  return 1" 1 ratelimit:user:123 100 60

# redis.conf — Memory optimisation settings

# Use ziplist encoding for small hashes, lists, sorted sets
hash-max-listpack-entries 128
hash-max-listpack-value 64
list-max-listpack-size -2          # 8KB per node
zset-max-listpack-entries 128
zset-max-listpack-value 64
set-max-intset-entries 512

# Lazy freeing (avoid blocking on large key deletion)
lazyfree-lazy-eviction yes
lazyfree-lazy-expire yes
lazyfree-lazy-server-del yes
lazyfree-lazy-user-del yes
lazyfree-lazy-user-flush yes

# jemalloc tuning
# MALLOC_CONF="background_thread:true,dirty_decay_ms:5000,muzzy_decay_ms:5000"

# Analyse memory usage
redis-cli -a password MEMORY DOCTOR
redis-cli -a password MEMORY STATS
redis-cli -a password --bigkeys
redis-cli -a password --memkeys

# Diagnosis
redis-cli -p 26379 SENTINEL master mymaster
# Check: flags should show 's_down' or 'o_down' if master is unreachable

redis-cli -p 26379 SENTINEL get-master-addr-by-name mymaster
# Returns the current master address (should be the promoted replica)

# Check Sentinel logs for failover events
tail -f /var/log/redis/sentinel.log
# Look for: +sdown, +odown, +try-failover, +elected-leader,
#           +failover-state-select-slave, +selected-slave,
#           +failover-state-send-slaveof-noone, +failover-end

# Diagnosis: check if min-replicas-to-write is configured
redis-cli -a password CONFIG GET min-replicas-to-write
redis-cli -a password CONFIG GET min-replicas-max-lag

# Prevention: configure min-replicas on all masters
redis-cli -a password CONFIG SET min-replicas-to-write 1
redis-cli -a password CONFIG SET min-replicas-max-lag 10

# If split-brain occurred: identify the stale master
# Compare replication offsets — the master with the higher offset has more data
redis-cli -h master1-ip -a password INFO replication | grep master_repl_offset
redis-cli -h master2-ip -a password INFO replication | grep master_repl_offset

# Force the stale master to become a replica
redis-cli -h stale-master-ip -a password REPLICAOF correct-master-ip 6379

# Diagnosis: check replication backlog
redis-cli -a password INFO replication | grep repl_backlog
# If repl_backlog_first_byte_offset is ahead of replica's offset, full sync triggers

# Prevention: increase backlog size
redis-cli -a password CONFIG SET repl-backlog-size 512mb

# Monitor for full syncs
redis-cli -a password INFO stats | grep sync_full
redis-cli -a password INFO stats | grep sync_partial_ok
redis-cli -a password INFO stats | grep sync_partial_err

# Diagnosis
redis-cli -a password INFO memory
# Check: used_memory vs maxmemory, mem_fragmentation_ratio

redis-cli -a password MEMORY DOCTOR
# Returns advice on memory issues

# Prevention: set proper maxmemory and eviction
redis-cli -a password CONFIG SET maxmemory 12gb
redis-cli -a password CONFIG SET maxmemory-policy allkeys-lru

# Find large keys consuming memory
redis-cli -a password --bigkeys
redis-cli -a password --memkeys --memkeys-samples 100

# Emergency: manually evict keys
redis-cli -a password SCAN 0 COUNT 1000 TYPE string
# Identify and DEL unnecessary large keys

# Diagnosis: check slowlog
redis-cli -a password SLOWLOG GET 20
redis-cli -a password SLOWLOG LEN

# Check for blocking commands
redis-cli -a password CLIENT LIST | grep -E 'cmd=(keys|sort|smembers)'

# Prevention: configure slowlog threshold
redis-cli -a password CONFIG SET slowlog-log-slower-than 10000   # 10ms
redis-cli -a password CONFIG SET slowlog-max-len 256

# Rename dangerous commands
rename-command KEYS ""              # Disable KEYS entirely
rename-command FLUSHALL ""          # Disable FLUSHALL
rename-command FLUSHDB ""           # Disable FLUSHDB
rename-command DEBUG ""             # Disable DEBUG

# Capacity estimation formulas

# Memory per node:
#   Base dataset size (use redis-cli DBSIZE and MEMORY USAGE on a sample)
#   + Replication output buffer: ~64MB per replica
#   + AOF rewrite buffer: ~64MB during rewrites
#   + Copy-on-write overhead during BGSAVE: up to 2x during heavy writes
#   + Client output buffers: ~1KB per client
#   + OS overhead: ~1-2GB
#   Rule of thumb: maxmemory = 75% of available RAM

# Network bandwidth:
#   Replication: write_throughput_bytes * num_replicas
#   Client traffic: ops_per_sec * avg_response_size
#   Full sync: dataset_size (one-time during replica bootstrap or failover)

# Example sizing for 20GB dataset, 100K ops/sec:
#   RAM per node: 20GB data + 4GB buffers + 2GB OS = 26GB -> 32GB node (75% = 24GB maxmemory)
#   CPU: 1 core handles ~100K ops/sec for simple commands (GET/SET)
#   Network: 100K ops * 1KB avg = 100MB/s client + 50MB/s replication = 150MB/s per master

# Scaling decision tree:
#   Need more read throughput? -> Add replicas (up to 5 per master)
#   Need more write throughput? -> Redis Cluster (add shards)
#   Need more memory? -> Redis Cluster (distribute dataset across shards)
#   Need lower latency? -> Reduce network hops (co-locate, use unix sockets)
#   Need global distribution? -> Multi-region replication or Redis Enterprise Active-Active

# When to scale vertically vs horizontally:

# Scale UP (bigger instances) when:
#   - Dataset fits in single-node memory
#   - Workload uses multi-key operations (MGET, SUNION, Lua across keys)
#   - Operational simplicity is more important than cost efficiency
#   - Using Redis modules that don't support Cluster mode well

# Scale OUT (more shards) when:
#   - Dataset exceeds single-node memory
#   - Write throughput exceeds single-thread capacity (~200K ops/sec)
#   - You need per-shard isolation for multi-tenant workloads
#   - Cost per GB of RAM is a concern (many smaller nodes vs few large ones)

# Cloud instance recommendations:
# AWS:   cache.r7g.xlarge (4 vCPU, 26GB) to cache.r7g.16xlarge (64 vCPU, 419GB)
# Azure: P1 (6GB) to P5 (120GB) per shard
# GCP:   5GB to 300GB per instance (Memorystore Standard)

# Bare metal:
#   CPU: 2-4 cores dedicated to Redis (single-threaded, but background tasks use extra cores)
#   RAM: 32-128GB per node (NVMe for swap-as-last-resort)
#   Network: 10Gbps minimum, 25Gbps for large datasets
#   Storage: NVMe SSD for AOF/RDB persistence (IOPS matters for fsync)