业务场景设计：直播弹幕、朋友圈、短链与扫码登录

package main

import (
    "log"
    "net/http"
    "sync"

    "github.com/gorilla/websocket"
)

// Room 表示一个直播房间
type Room struct {
    mu      sync.RWMutex
    clients map[*websocket.Conn]bool
}

// 步骤1：创建房间管理器
type RoomManager struct {
    mu    sync.RWMutex
    rooms map[string]*Room
}

func NewRoomManager() *RoomManager {
    return &RoomManager{rooms: make(map[string]*Room)}
}

// 步骤2：用户加入房间
func (rm *RoomManager) Join(roomId string, conn *websocket.Conn) {
    rm.mu.Lock()
    room, ok := rm.rooms[roomId]
    if !ok {
        room = &Room{clients: make(map[*websocket.Conn]bool)}
        rm.rooms[roomId] = room
    }
    rm.mu.Unlock()

    room.mu.Lock()
    room.clients[conn] = true
    room.mu.Unlock()
    log.Printf("用户加入房间 %s, 当前在线: %d", roomId, len(room.clients))
}

// 步骤3：用户离开房间
func (rm *RoomManager) Leave(roomId string, conn *websocket.Conn) {
    rm.mu.RLock()
    room, ok := rm.rooms[roomId]
    rm.mu.RUnlock()
    if !ok {
        return
    }
    room.mu.Lock()
    delete(room.clients, conn)
    room.mu.Unlock()
}

// 步骤4：广播弹幕（读扩散：一条消息推给房间所有人）
func (rm *RoomManager) Broadcast(roomId string, message []byte) {
    rm.mu.RLock()
    room, ok := rm.rooms[roomId]
    rm.mu.RUnlock()
    if !ok {
        return
    }
    room.mu.RLock()
    defer room.mu.RUnlock()
    for conn := range room.clients {
        // 步骤5：非阻塞发送，发送失败则关闭连接
        err := conn.WriteMessage(websocket.TextMessage, message)
        if err != nil {
            log.Printf("发送失败: %v", err)
            conn.Close()
            delete(room.clients, conn)
        }
    }
}

var upgrader = websocket.Upgrader{
    CheckOrigin: func(r *http.Request) bool { return true },
}

func main() {
    rm := NewRoomManager()
    http.HandleFunc("/ws", func(w http.ResponseWriter, r *http.Request) {
        roomId := r.URL.Query().Get("room")
        conn, err := upgrader.Upgrade(w, r, nil)
        if err != nil {
            log.Println("WebSocket升级失败:", err)
            return
        }
        defer conn.Close()

        rm.Join(roomId, conn)
        defer rm.Leave(roomId, conn)

        for {
            // 步骤6：读取用户发来的弹幕
            _, msg, err := conn.ReadMessage()
            if err != nil {
                break
            }
            // 步骤7：广播给房间内所有用户
            rm.Broadcast(roomId, msg)
        }
    })
    log.Println("弹幕服务启动 :8080/ws?room=xxx")
    http.ListenAndServe(":8080", nil)
}

package main

import (
    "context"
    "fmt"
    "time"

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

type FeedService struct {
    rdb           *redis.Client
    bigVThreshold int64 // 大V粉丝数阈值
}

// 步骤1：发布动态
func (s *FeedService) Publish(ctx context.Context, userId string, postId string, timestamp int64) error {
    // 步骤2：写入发布者outbox（所有模式都需要）
    outboxKey := fmt.Sprintf("outbox:%s", userId)
    s.rdb.ZAdd(ctx, outboxKey, redis.Z{
        Score:  float64(timestamp),
        Member: postId,
    })

    // 步骤3：查询粉丝数，决定推还是拉
    fansKey := fmt.Sprintf("fans:%s", userId)
    fanCount, _ := s.rdb.SCard(ctx, fansKey).Result()

    if fanCount < s.bigVThreshold {
        // 步骤4：普通用户-推模式：写入每个粉丝的inbox
        fans, _ := s.rdb.SMembers(ctx, fansKey).Result()
        for _, fanId := range fans {
            inboxKey := fmt.Sprintf("inbox:%s", fanId)
            s.rdb.ZAdd(ctx, inboxKey, redis.Z{
                Score:  float64(timestamp),
                Member: postId,
            })
            // 步骤5：inbox只保留最近1000条
            s.rdb.ZRemRangeByRank(ctx, inboxKey, 0, -1001)
        }
    }
    // 大V不推，粉丝读取时主动拉取outbox
    return nil
}

// 步骤6：读取Feed流（推拉结合）
func (s *FeedService) GetFeed(ctx context.Context, userId string) ([]string, error) {
    // 步骤7：先读inbox（推模式写入的）
    inboxKey := fmt.Sprintf("inbox:%s", userId)
    posts, _ := s.rdb.ZRevRange(ctx, inboxKey, 0, 19).Result()

    // 步骤8：补充拉取关注的大V的outbox
    followingKey := fmt.Sprintf("following:%s", userId)
    followingIds, _ := s.rdb.SMembers(ctx, followingKey).Result()
    for _, followId := range followingIds {
        fansKey := fmt.Sprintf("fans:%s", followId)
        fanCount, _ := s.rdb.SCard(ctx, fansKey).Result()
        if fanCount >= s.bigVThreshold {
            // 步骤9：大V的动态从outbox拉取
            outboxKey := fmt.Sprintf("outbox:%s", followId)
            bigVPosts, _ := s.rdb.ZRevRange(ctx, outboxKey, 0, 19).Result()
            posts = append(posts, bigVPosts...)
        }
    }
    // 步骤10：合并后重新按时间排序，取前20条
    // 实际项目中用Redis ZUNIONSTORE或服务端排序
    return posts, nil
}

func main() {
    rdb := redis.NewClient(&redis.Options{Addr: "localhost:6379"})
    svc := &FeedService{rdb: rdb, bigVThreshold: 1000}

    ctx := context.Background()
    // 模拟发布动态
    svc.Publish(ctx, "user:001", "post:1001", time.Now().Unix())
    // 模拟读取Feed流
    feed, _ := svc.GetFeed(ctx, "user:002")
    fmt.Println("Feed流:", feed)
}

package main

import (
    "context"
    "fmt"
    "time"

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

type StatsService struct {
    rdb *redis.Client
}

// 步骤1：定时预计算热门内容排行榜
func (s *StatsService) PrecomputeHotRanking(ctx context.Context) {
    ticker := time.NewTicker(5 * time.Minute)
    defer ticker.Stop()
    for range ticker.C {
        // 步骤2：从数据库聚合最近24小时的热门内容
        // SQL: SELECT content_id, COUNT(*) as cnt FROM views
        //      WHERE created_at > NOW() - INTERVAL 24 HOUR
        //      GROUP BY content_id ORDER BY cnt DESC LIMIT 100

        // 步骤3：将结果写入Redis ZSet（模拟数据）
        hotKey := "stats:hot:24h"
        items := []redis.Z{
            {Score: 9821, Member: "content:1001"},
            {Score: 8732, Member: "content:1002"},
            {Score: 7621, Member: "content:1003"},
        }
        s.rdb.ZAdd(ctx, hotKey, items...)
        // 步骤4：设置过期时间，防止定时任务挂了数据不更新
        s.rdb.Expire(ctx, hotKey, 10*time.Minute)
        fmt.Println("热门排行榜已更新")
    }
}

// 步骤5：查询时直接读缓存
func (s *StatsService) GetHotRanking(ctx context.Context, limit int64) ([]string, error) {
    // 步骤6：先查Redis缓存
    hotKey := "stats:hot:24h"
    result, err := s.rdb.ZRevRange(ctx, hotKey, 0, limit-1).Result()
    if err == nil && len(result) > 0 {
        return result, nil
    }
    // 步骤7：缓存未命中，回源查DB（实际项目中这里查物化视图）
    // 注意加互斥锁防止缓存击穿（见第四节）
    return []string{"content:fallback"}, nil
}

func main() {
    rdb := redis.NewClient(&redis.Options{Addr: "localhost:6379"})
    svc := &StatsService{rdb: rdb}
    ctx := context.Background()
    go svc.PrecomputeHotRanking(ctx)
    ranking, _ := svc.GetHotRanking(ctx, 10)
    fmt.Println("热门排行:", ranking)
}

package main

import (
    "context"
    "fmt"
    "math/rand"
    "sync"
    "time"

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

type CacheService struct {
    rdb *redis.Client
    mu  sync.Mutex
}

// 步骤1：带互斥锁的缓存查询
func (s *CacheService) GetWithMutex(ctx context.Context, key string) (string, error) {
    // 步骤2：先查Redis缓存
    val, err := s.rdb.Get(ctx, key).Result()
    if err == nil {
        return val, nil // 缓存命中
    }

    // 步骤3：缓存未命中，加互斥锁（只放一个请求去查DB）
    s.mu.Lock()
    defer s.mu.Unlock()

    // 步骤4：双重检查（可能其他协程已经重建了缓存）
    val, err = s.rdb.Get(ctx, key).Result()
    if err == nil {
        return val, nil
    }

    // 步骤5：查数据库
    val = s.queryFromDB(key)

    // 步骤6：回写缓存，过期时间加随机值防止雪崩
    ttl := 300 + rand.Intn(60) // 300到360秒随机
    s.rdb.Set(ctx, key, val, time.Duration(ttl)*time.Second)

    return val, nil
}

// 模拟数据库查询
func (s *CacheService) queryFromDB(key string) string {
    time.Sleep(100 * time.Millisecond) // 模拟DB查询耗时
    return fmt.Sprintf("db_value_for_%s", key)
}

func main() {
    rdb := redis.NewClient(&redis.Options{Addr: "localhost:6379"})
    svc := &CacheService{rdb: rdb}
    ctx := context.Background()

    // 模拟并发请求
    var wg sync.WaitGroup
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            val, _ := svc.GetWithMutex(ctx, "hotkey:product:1001")
            fmt.Printf("goroutine %d 得到: %s\n", id, val)
        }(i)
    }
    wg.Wait()
}

package main

import (
    "context"
    "fmt"
    "net/http"

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

const base62Chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"

type ShortURLService struct {
    rdb *redis.Client
}

// 步骤1：将长ID编码为Base62短码
func EncodeBase62(id int64) string {
    if id == 0 {
        return string(base62Chars[0])
    }
    var result []byte
    for id > 0 {
        remainder := id % 62
        result = append([]byte{base62Chars[remainder]}, result...)
        id = id / 62
    }
    return string(result)
}

// 步骤2：生成短链
func (s *ShortURLService) Generate(ctx context.Context, longURL string) (string, error) {
    // 步骤3：先检查长链是否已有短链映射（避免重复生成）
    existKey := fmt.Sprintf("long:%s", longURL)
    if shortCode, err := s.rdb.Get(ctx, existKey).Result(); err == nil {
        return "https://s.cn/" + shortCode, nil
    }

    // 步骤4：通过发号器获取全局唯一ID（Redis INCR模拟）
    id, err := s.rdb.Incr(ctx, "shorturl🆔seq").Result()
    if err != nil {
        return "", err
    }

    // 步骤5：Base62编码生成短码
    shortCode := EncodeBase62(id)

    // 步骤6：存储双向映射
    s.rdb.Set(ctx, fmt.Sprintf("short:%s", shortCode), longURL, 0)
    s.rdb.Set(ctx, existKey, shortCode, 0)

    return "https://s.cn/" + shortCode, nil
}

// 步骤7：短链重定向
func (s *ShortURLService) Redirect(w http.ResponseWriter, r *http.Request) {
    shortCode := r.URL.Path[1:] // 去掉前导/
    ctx := context.Background()

    // 步骤8：查Redis获取长链
    longURL, err := s.rdb.Get(ctx, fmt.Sprintf("short:%s", shortCode)).Result()
    if err != nil {
        http.NotFound(w, r)
        return
    }

    // 步骤9：记录访问统计（异步）
    go s.rdb.Incr(ctx, fmt.Sprintf("stats:%s", shortCode))

    // 步骤10：302临时重定向（不用301，确保每次都经过服务器统计）
    http.Redirect(w, r, longURL, http.StatusFound)
}

func main() {
    rdb := redis.NewClient(&redis.Options{Addr: "localhost:6379"})
    svc := &ShortURLService{rdb: rdb}
    ctx := context.Background()

    // 测试生成短链
    shortURL, _ := svc.Generate(ctx, "https://www.example.com/products/detail?id=1001&source=wechat")
    fmt.Println("短链:", shortURL)

    // 启动HTTP服务
    http.HandleFunc("/", svc.Redirect)
    fmt.Println("短链服务启动 :9090")
    http.ListenAndServe(":9090", nil)
}

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "net/http"
    "time"

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

type QrLoginService struct {
    rdb *redis.Client
}

// 步骤1：PC端请求生成二维码
func (s *QrLoginService) GenerateQrCode(ctx context.Context) (string, error) {
    // 步骤2：生成临时token（唯一标识本次登录会话）
    token := uuid.New().String()
    // 步骤3：存储token状态，设为"等待扫码"，60秒过期
    statusKey := fmt.Sprintf("qrlogin:%s:status", token)
    s.rdb.Set(ctx, statusKey, "WAITING_SCAN", 60*time.Second)
    return token, nil
}

// 步骤4：手机端扫码
func (s *QrLoginService) Scan(ctx context.Context, token string, userId string) error {
    statusKey := fmt.Sprintf("qrlogin:%s:status", token)
    // 步骤5：检查token是否有效
    status, err := s.rdb.Get(ctx, statusKey).Result()
    if err != nil {
        return fmt.Errorf("二维码已过期")
    }
    if status != "WAITING_SCAN" {
        return fmt.Errorf("二维码状态异常: %s", status)
    }
    // 步骤6：更新状态为"已扫码待确认"，记录用户ID
    s.rdb.Set(ctx, statusKey, "SCANNED", 60*time.Second)
    s.rdb.Set(ctx, fmt.Sprintf("qrlogin:%s:user", token), userId, 60*time.Second)
    return nil
}

// 步骤7：手机端确认登录
func (s *QrLoginService) Confirm(ctx context.Context, token string) error {
    statusKey := fmt.Sprintf("qrlogin:%s:status", token)
    status, _ := s.rdb.Get(ctx, statusKey).Result()
    if status != "SCANNED" {
        return fmt.Errorf("请先扫码")
    }
    // 步骤8：更新状态为"已确认"
    s.rdb.Set(ctx, statusKey, "CONFIRMED", 30*time.Second)
    return nil
}

// 步骤9：PC端轮询登录状态
func (s *QrLoginService) Poll(ctx context.Context, token string) (string, string, error) {
    statusKey := fmt.Sprintf("qrlogin:%s:status", token)
    status, err := s.rdb.Get(ctx, statusKey).Result()
    if err != nil {
        return "EXPIRED", "", fmt.Errorf("二维码已过期")
    }
    // 步骤10：如果已确认，返回登录凭证
    if status == "CONFIRMED" {
        userId, _ := s.rdb.Get(ctx, fmt.Sprintf("qrlogin:%s:user", token)).Result()
        // 生成登录token（JWT等）
        authToken := generateAuthToken(userId)
        return status, authToken, nil
    }
    return status, "", nil
}

func generateAuthToken(userId string) string {
    return fmt.Sprintf("jwt_token_for_%s", userId)
}

func main() {
    rdb := redis.NewClient(&redis.Options{Addr: "localhost:6379"})
    svc := &QrLoginService{rdb: rdb}
    ctx := context.Background()

    // 模拟完整流程
    token, _ := svc.GenerateQrCode(ctx)
    fmt.Println("1. PC端生成二维码, token:", token)

    svc.Scan(ctx, token, "user:1001")
    fmt.Println("2. 手机端扫码成功")

    status, _, _ := svc.Poll(ctx, token)
    fmt.Println("3. PC端轮询状态:", status)

    svc.Confirm(ctx, token)
    fmt.Println("4. 手机端确认登录")

    status, authToken, _ := svc.Poll(ctx, token)
    fmt.Printf("5. PC端轮询状态: %s, 登录凭证: %s\n", status, authToken)

    // HTTP接口示例
    http.HandleFunc("/qr/generate", func(w http.ResponseWriter, r *http.Request) {
        token, _ := svc.GenerateQrCode(r.Context())
        json.NewEncoder(w).Encode(map[string]string{"token": token})
    })
    http.HandleFunc("/qr/poll", func(w http.ResponseWriter, r *http.Request) {
        token := r.URL.Query().Get("token")
        status, authToken, _ := svc.Poll(r.Context(), token)
        json.NewEncoder(w).Encode(map[string]string{
            "status": status,
            "token":  authToken,
        })
    })
}

package main

import (
	"hash/crc32"
	"sort"
	"strconv"
)

// 步骤1：一致性哈希环（简化版，用虚拟节点减少数据倾斜）
type ConsistentHash struct {
	ring   []uint32     // 有序的哈希值列表
	nodes  map[uint32]int // 哈希值 -> 节点编号
	vnodes int          // 每个物理节点的虚拟节点数
}

// 步骤2：添加节点（每个物理节点映射到 vnodes 个虚拟点）
func (c *ConsistentHash) AddNode(nodeID int) {
	for i := 0; i < c.vnodes; i++ {
		key := crc32.ChecksumIEEE([]byte(strconv.Itoa(nodeID) + "#" + strconv.Itoa(i)))
		c.ring = append(c.ring, key)
		c.nodes[key] = nodeID
	}
	sort.Slice(c.ring, func(i, j int) bool { return c.ring[i] < c.ring[j] })
}

// 步骤3：根据用户ID找到归属的存储分片
func (c *ConsistentHash) GetNode(userID string) int {
	h := crc32.ChecksumIEEE([]byte(userID))
	// 步骤4：在有序环上二分查找第一个 >= h 的虚拟节点
	idx := sort.Search(len(c.ring), func(i int) bool { return c.ring[i] >= h })
	if idx == len(c.ring) {
		idx = 0 // 环形回绕
	}
	return c.nodes[c.ring[idx]]
}

func main() {
	ch := &ConsistentHash{vnodes: 100}
	for i := 0; i < 10; i++ {
		ch.AddNode(i) // 10 个存储分片（实际是 1000 个库）
	}
	// 步骤5：user:1001 的聊天消息固定路由到某个分片
	node := ch.GetNode("user:1001")
	println("user:1001 的消息存到分片", node)
}

package main

import (
	"fmt"
	"hash/fnv"
	"net/url"
	"sync"
)

// 步骤1：极简 Bloom Filter（生产用 redisbloom 或 roaring bitmap）
type BloomFilter struct {
	bits []uint64
	size uint64
}

func NewBloomFilter(size uint64) *BloomFilter {
	return &BloomFilter{bits: make([]uint64, (size+63)/64), size: size}
}

// 步骤2：两个哈希函数映射到位数组
func (b *BloomFilter) hashes(s string) (uint64, uint64) {
	h1 := fnv.New32a()
	h1.Write([]byte(s))
	v1 := uint64(h1.Sum32()) % b.size

	h2 := fnv.New32a()
	h2.Write([]byte(s + "salt"))
	v2 := uint64(h2.Sum32()) % b.size
	return v1, v2
}

func (b *BloomFilter) Add(s string) {
	h1, h2 := b.hashes(s)
	b.bits[h1/64] |= 1 << (h1 % 64)
	b.bits[h2/64] |= 1 << (h2 % 64)
}

// 步骤3：可能返回 false（一定没抓过）/ true（可能抓过）
func (b *BloomFilter) MaybeContains(s string) bool {
	h1, h2 := b.hashes(s)
	if b.bits[h1/64]&(1<<(h1%64)) == 0 {
		return false
	}
	if b.bits[h2/64]&(1<<(h2%64)) == 0 {
		return false
	}
	return true
}

// 步骤4：爬虫 Worker
type Crawler struct {
	bf       *BloomFilter
	visited  sync.Map // 精确去重兜底（演示用）
	mu       sync.Mutex
}

func (c *Crawler) ShouldCrawl(rawURL string) bool {
	// 步骤5：先问 Bloom Filter 快速过滤
	if !c.bf.MaybeContains(rawURL) {
		return true // 一定没抓过
	}
	// 步骤6：可能抓过，再查精确表兜底
	if _, ok := c.visited.Load(rawURL); ok {
		return false
	}
	return true
}

func (c *Crawler) Crawl(rawURL string) {
	c.mu.Lock()
	c.bf.Add(rawURL)
	c.visited.Store(rawURL, struct{}{})
	c.mu.Unlock()
	fmt.Println("下载并解析:", rawURL)
}

func main() {
	c := &Crawler{bf: NewBloomFilter(1 << 20)}

	seed := []string{
		"https://example.com/a",
		"https://example.com/b",
		"https://example.com/a", // 重复 URL
	}

	// 步骤7：多 Worker 消费 URL 队列（用 channel 模拟）
	queue := make(chan string, len(seed))
	for _, u := range seed {
		queue <- u
	}
	close(queue)

	var wg sync.WaitGroup
	for i := 0; i < 3; i++ { // 3 个 Worker
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			for u := range queue {
				if c.ShouldCrawl(u) {
					c.Crawl(u)
				} else {
					fmt.Printf("Worker%d 跳过重复: %s\n", id, u)
				}
			}
		}(i)
	}
	wg.Wait()

	// 步骤8：校验 URL 合法性（解析器前过滤非法链接）
	if parsed, err := url.Parse("https://example.com/c"); err == nil {
		fmt.Println("解析出下一层URL:", parsed.Host)
	}
}

package main

import (
	"crypto/tls"
	"fmt"
	"math/rand"
	"net/http"
	"net/url"
	"time"

	"golang.org/x/time/rate"
)

// 步骤1：UA 池
var uaPool = []string{
	"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0 Safari/537.36",
	"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15",
	"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0 Safari/537.36",
}

// 步骤2：代理池（演示用，实际从代理服务拉取并探活）
var proxyPool = []string{
	"http://1.2.3.4:8080",
	"http://5.6.7.8:8080",
	"http://9.10.11.12:8080",
}

// 步骤3：每域限速器（域名 -> limiter）
var limiters = map[string]*rate.Limiter{}

func getLimiter(host string) *rate.Limiter {
	if l, ok := limiters[host]; ok {
		return l
	}
	l := rate.NewLimiter(rate.Limit(2), 1) // 每秒 2 次，突发 1
	limiters[host] = l
	return l
}

// 步骤4：构造带反爬策略的 Client
func newAntiCrawlClient() *http.Client {
	return &http.Client{
		Timeout: 10 * time.Second,
		Transport: &http.Transport{
			TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
			// 步骤5：每次请求随机选代理
			Proxy: func(req *http.Request) (*url.URL, error) {
				p := proxyPool[rand.Intn(len(proxyPool))]
				return url.Parse(p)
			},
		},
	}
}

// 步骤6：带限速 + UA 伪装的一次抓取
func fetch(client *http.Client, target string) (*http.Response, error) {
	u, _ := url.Parse(target)
	// 步骤7：先等限速器放行（按域名限速）
	if err := getLimiter(u.Host).Wait(nil); err != nil {
		return nil, err
	}
	req, _ := http.NewRequest("GET", target, nil)
	// 步骤8：随机 UA 伪装
	req.Header.Set("User-Agent", uaPool[rand.Intn(len(uaPool))])
	req.Header.Set("Accept", "text/html,application/xhtml+xml")
	req.Header.Set("Accept-Language", "zh-CN,zh;q=0.9")
	return client.Do(req)
}

func main() {
	client := newAntiCrawlClient()
	resp, err := fetch(client, "https://example.com/page/1")
	if err != nil {
		fmt.Println("抓取失败:", err)
		return
	}
	defer resp.Body.Close()
	fmt.Println("状态码:", resp.StatusCode, "已应用UA伪装+代理+限速")
}

package main

import (
	"fmt"
	"net/http"
	"strings"
)

// 步骤1：防盗链中间件（Referer 白名单）
func antiLeech(allowedHosts []string, next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		referer := r.Header.Get("Referer")
		// 步骤2：无 Referer 一般放行（直接访问），或按策略拒绝
		if referer != "" {
			ok := false
			for _, h := range allowedHosts {
				if strings.Contains(referer, h) {
					ok = true
					break
				}
			}
			if !ok {
				http.Error(w, "403 防盗链: 不允许外站引用", http.StatusForbidden)
				return
			}
		}
		next.ServeHTTP(w, r)
	})
}

// 步骤3：根据 Accept 头协商返回最佳格式
func negotiateImage(w http.ResponseWriter, r *http.Request) {
	accept := r.Header.Get("Accept")
	switch {
	case strings.Contains(accept, "image/avif"):
		// 步骤4：优先返回 AVIF（体积最小）
		w.Header().Set("Content-Type", "image/avif")
		fmt.Fprint(w, "<AVIF 二进制数据>")
	case strings.Contains(accept, "image/webp"):
		w.Header().Set("Content-Type", "image/webp")
		fmt.Fprint(w, "<WEBP 二进制数据>")
	default:
		// 步骤5：回退到 JPEG（兼容老浏览器）
		w.Header().Set("Content-Type", "image/jpeg")
		fmt.Fprint(w, "<JPEG 二进制数据>")
	}
}

func main() {
	mux := http.NewServeMux()
	mux.HandleFunc("/img/", negotiateImage)

	// 步骤6：套上防盗链，仅允许自家域名引用
	handler := antiLeech([]string{"myshop.com", "cdn.myshop.com"}, mux)
	fmt.Println("图片服务启动 :8080/img/xxx")
	http.ListenAndServe(":8080", handler)
}

package main

import (
	"context"
	"fmt"
	"time"

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

// 步骤1：Lua 脚本——原子地"判断库存>0 并扣减 1"，避免并发超卖
// KEYS[1] = 库存 key，ARGV[1] = 本次扣减数量（秒杀通常为 1）
var deductScript = `
	local stock = tonumber(redis.call("GET", KEYS[1]))
	if stock == nil or stock < tonumber(ARGV[1]) then
		return -1          -- 库存不足，秒杀失败
	end
	return redis.call("DECRBY", KEYS[1], ARGV[1])  -- 原子扣减，返回剩余库存
`

// TrySecKill 预扣库存，返回 true 表示抢到名额
func TrySecKill(ctx context.Context, rdb *redis.Client, userID, itemID string) (bool, error) {
	stockKey := "seckill:stock:" + itemID
	// 步骤2：用 Lua 原子扣减，单线程串行执行，绝不会超卖
	res, err := rdb.Eval(ctx, deductScript, []string{stockKey}, 1).Int()
	if err != nil {
		return false, err
	}
	if res < 0 {
		return false, nil // 没抢到
	}
	fmt.Printf("用户 %s 抢到商品 %s，剩余库存 %d\n", userID, itemID, res)
	return true, nil
}

func main() {
	rdb := redis.NewClient(&redis.Options{Addr: "localhost:6379"})
	ctx := context.Background()

	// 步骤3：初始化库存（实际由运营后台在秒杀开始前写入）
	rdb.Set(ctx, "seckill:stock:iphone15", 100, time.Hour)

	// 步骤4：模拟 200 个并发抢 100 个库存，Lua 原子保证恰好 100 人成功
	for i := 0; i < 200; i++ {
		go func(id int) {
			ok, _ := TrySecKill(ctx, rdb, fmt.Sprintf("u%d", id), "iphone15")
			_ = ok
		}(i)
	}
	time.Sleep(time.Second)
}

// 步骤5：抢到名额后，向队列投递下单消息（削峰，保护 DB）
func EnqueueOrder(ctx context.Context, rdb *redis.Client, userID, itemID string) error {
	// 用 Stream 或 List 当队列；这里用 List 简化演示
	msg := fmt.Sprintf("%s:%s:%d", userID, itemID, time.Now().UnixNano())
	return rdb.LPush(ctx, "seckill:orders", msg).Err()
}

// 步骤6：异步 Worker——从队列取消息，创建订单并"最终扣减"数据库库存
func OrderWorker(ctx context.Context, rdb *redis.Client, db *sql.DB) {
	for {
		// BRPOP 阻塞取，没有消息时 goroutine 休眠不占 CPU
		res, err := rdb.BRPop(ctx, 0, "seckill:orders").Result()
		if err != nil {
			return
		}
		orderMsg := res[1] // "userID:itemID:ts"
		// 步骤7：真正落库——创建订单 + 数据库库存 UPDATE ... WHERE stock>0
		// 数据库层面用行锁/乐观锁兜底：UPDATE inventory SET stock=stock-1 WHERE item=? AND stock>0
		_ = createOrderInDB(db, orderMsg)
	}
}

# 步骤1：创建增量备份（Restic 默认就是增量，只传变化块）
velero backup create prod-pv-bak \
  --include-namespaces prod \
  --default-volumes-to-restic \
  --snapshot-volumes

# 步骤2：查看备份详情，确认每个卷的状态都是 Completed
velero backup describe prod-pv-bak --details

# 步骤3：恢复前先校验完整性（校验和比对，防止静默损坏）
velero backup logs prod-pv-bak | grep -i "checksum\|completed"

# 步骤1：用 Crossplane Composition 声明跨云 MySQL Global Database
apiVersion: database.aws.crossplane.io/v1alpha1
kind: GlobalCluster
metadata:
  name: mysql-global
spec:
  forProvider:
    region: ap-east-1
    # 步骤2：主区域写入自动异步复制到灾备区域（通常 <1s 延迟）
    engine: aurora-mysql
  writeConnectionSecretToRef:
    name: mysql-global-secret
    namespace: prod

# 步骤1：外部探针周期性探测主集群 API Server 健康端点
curl -k -s https://<主集群API>:6443/healthz || echo "UNHEALTHY"

# 步骤2：连续 N 次不健康则调用 DNS/GSLB 切换（示意）
if [ "$(probe_fail_count)" -ge 3 ]; then
  # 把 example.com 的解析从主集群 VIP 切到灾备集群 VIP
  update_dns_record example.com --target <灾备集群VIP>
  echo "主集群 API 不可达，已触发 DNS 切换至灾备"
fi

# 步骤1：Patroni 配置——用 etcd 做选主后端
scope: postgres-cluster
name: pg-node-1
restapi:
  listen: 0.0.0.0:8008
etcd:
  hosts:
    - etcd-1:2379
    - etcd-2:2379
    - etcd-3:2379
bootstrap:
  dcs:
    # 步骤2：定义选主与故障切换参数，防止双主
    ttl: 30
    loop_wait: 10
    retry_timeout: 10
    maximum_lag_on_failover: 1048576   # 步骤3：备库落后超过 1MB 不参与接管

# 步骤1：MirrorMaker 2.0 双向复制配置（截断循环的关键在 replication.policy）
clusters:
  - name: cluster-a
    bootstrapServers: kafka-a:9092
  - name: cluster-b
    bootstrapServers: kafka-b:9092
mirrors:
  - sourceCluster: cluster-a
    targetCluster: cluster-b
    # 步骤2：IdentityReplicationPolicy 让消息保留来源标记，避免被反向再复制
    replicationPolicy: org.apache.kafka.connect.mirror.IdentityReplicationPolicy
  - sourceCluster: cluster-b
    targetCluster: cluster-a
    replicationPolicy: org.apache.kafka.connect.mirror.IdentityReplicationPolicy

# 步骤1：看 etcd 里 Patroni 记录的 Leader 是谁
etcdctl get /service/postgres-cluster/leader

# 步骤2：到该节点执行，必须为 f（false=主）；若是 t 说明视图与实际不一致
psql -c "SELECT pg_is_in_recovery();"   # 期望返回 f

# 步骤3：不一致时让 Patroni 重新选主对齐视图
patronictl reinit postgres-cluster <视图错误的节点>

# 步骤1：用 Istio VirtualService 做蓝绿权重切换 + 会话保持
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: checkout
spec:
  hosts: ["checkout.example.com"]
  http:
    - route:
        - destination: { host: checkout-blue }
          weight: 0      # 步骤2：切换前绿 0 / 蓝 100
        - destination: { host: checkout-green }
          weight: 100
      # 步骤3：基于 cookie 的会话保持，同一用户始终落同一版本
      headers:
        request:
          set:
            x-canary: "green"

apiVersion: argoproj.io/v1alpha1
kind: Rollout
metadata:
  name: checkout
spec:
  strategy:
    blueGreen:
      # 步骤1：切换后保留旧版本（蓝）7 天再缩容，便于快速回切
      scaleDownDelaySeconds: 604800
      activeService: checkout-active
      previewService: checkout-preview
  revisionHistoryLimit: 7   # 步骤2：保留 7 个历史 revision，支持一键回滚

# 步骤1：监控绿环境引发的数据库慢查询数
SLOW=$(mysql -e "SHOW GLOBAL STATUS LIKE 'Slow_queries'" | awk '{print $2}')

# 步骤2：超过阈值则阻断绿组流量，自动回切蓝组
if [ "$SLOW" -gt 100 ]; then
  echo "绿环境引发慢查询风暴，自动阻断并回切蓝组"
  kubectl patch virtualservice checkout -p '{"spec":{"http":[{"route":[{"destination":{"host":"checkout-blue"},"weight":100},{"destination":{"host":"checkout-green"},"weight":0}]}]}}'
fi

# 步骤1：Velero 备份存储位置配置——KMS + SSE-C 双重加密
apiVersion: velero.io/v1
kind: BackupStorageLocation
metadata:
  name: s3-backup
spec:
  provider: aws
  objectStorage:
    bucket: my-velero-bucket
  config:
    # 步骤2：服务端用 KMS 托管密钥加密（SSE-KMS）
    sse-kms-key-id: arn:aws:kms:ap-east-1:123:key/abcd
    # 步骤3：客户端用指定密钥加密（SSE-C），数据在出 Velero 前已加密
    sse-customer-algorithm: AES256
    sse-customer-key: <base64-encoded-key>

#!/bin/bash
# 步骤1：先 snapshot 出 etcd 数据
ETCDCTL_API=3 etcdctl --endpoints=:2379 snapshot save /tmp/etcd-snap.db

# 步骤2：用 Vault Transit 加密快照（信封加密：Vault 管理 KEK）
vault write transit/encrypt/etcd-key \
  plaintext=$(base64 /tmp/etcd-snap.db) \
  > /tmp/etcd-snap.enc.json

# 步骤3：把密文落到备份存储，明文快照立即销毁
rm -f /tmp/etcd-snap.db
echo "etcd 快照已信封加密并安全落盘"

# 步骤1：列出需要轮换密钥的历史备份
aws s3 ls s3://my-velero-bucket/backups/ > /tmp/old_backups.txt

# 步骤2：对每个对象调用 S3 重加密（KMS 服务端就地换密钥，无需重传）
while read obj; do
  aws s3api copy-object \
    --bucket my-velero-bucket \
    --key "$obj" \
    --copy-source "my-velero-bucket/$obj" \
    --sse-kms-key-id arn:aws:kms:ap-east-1:123:key/NEW-KEY \
    --metadata-directive REPLACE
done < /tmp/old_backups.txt

# 步骤1：Fluent Bit 输出到 WORM 存储（以 S3 Object Lock 为例）
apiVersion: v1
kind: ConfigMap
metadata:
  name: fluent-bit-config
data:
  fluent-bit.conf: |
    [OUTPUT]
        Name                s3
        Match               falco.*
        bucket              audit-log-worm
        # 步骤2：开启 Object Lock，写入后合规期内不可删改
        s3_key_format      /logs/$TAG/%Y/%m/%d/%H/%M/%S
        # 步骤3：配合存储桶的 Object Lock 合规模式，满足等保 2.0 不可篡改要求    

# 步骤1：S3 生命周期规则——热转冷、保留 7 年
apiVersion: s3.aws.crossplane.io/v1alpha1
kind: Bucket
metadata:
  name: audit-log-archive
spec:
  forProvider:
    lifecycleConfiguration:
      rules:
        - id: to-glacier-7y
          status: Enabled
          # 步骤2：30 天后从标准层转到 Glacier 深度归档
          transitions:
            - days: 30
              storageClass: GLACIER
          # 步骤3：保留 7 年（2555 天）后自动过期清理
          expiration:
            days: 2555

#!/bin/bash
# 步骤1：对当日审计日志分块计算 Merkle 根哈希
ROOT=$(build_merkle_root /var/log/audit/$(date +%F)/*.log)

# 步骤2：把根哈希写入不可篡改账本（WORM / 区块链）
write_root_to_ledger "$ROOT" "$(date +%F-%H)"

# 步骤3：校验时重新计算并比对，不一致即告警
CURRENT=$(build_merkle_root /var/log/audit/$(date +%F)/*.log)
if [ "$CURRENT" != "$ROOT" ]; then
  echo "ALERT: 审计日志检测到篡改，根哈希不匹配" >&2
  trigger_alert "audit-log-tampered"
fi