怎样用脚本批量清除API缓存？

本文目录导读：

1. 使用curl脚本批量清除
2. Python脚本批量清除
3. 使用Redis清空模式（如果缓存使用Redis）
4. 使用配置文件批量清除
5. 通用清除函数库
6. 使用Docker容器批量清除
7. 注意事项

我来介绍几种批量清除API缓存的方法和脚本示例：

使用curl脚本批量清除

Linux/Mac Bash脚本

#!/bin/bash
# API配置
API_BASE_URL="https://api.example.com"
API_KEY="your-api-key"
ENDPOINTS=("users" "products" "orders" "categories")
# 清除单个端点缓存
clear_cache() {
    local endpoint=$1
    response=$(curl -s -o /dev/null -w "%{http_code}" \
        -X DELETE \
        -H "Authorization: Bearer $API_KEY" \
        -H "Content-Type: application/json" \
        "${API_BASE_URL}/cache/${endpoint}")
    if [ "$response" -eq 200 ]; then
        echo "✓ 清除 $endpoint 缓存成功"
    else
        echo "✗ 清除 $endpoint 缓存失败 (HTTP $response)"
    fi
}
# 批量清除
for endpoint in "${ENDPOINTS[@]}"; do
    clear_cache "$endpoint"
done

Python脚本批量清除

#!/usr/bin/env python3
import requests
import json
from concurrent.futures import ThreadPoolExecutor, as_completed
class CacheClearer:
    def __init__(self, base_url, api_key):
        self.base_url = base_url
        self.headers = {
            'Authorization': f'Bearer {api_key}',
            'Content-Type': 'application/json'
        }
    def clear_endpoint_cache(self, endpoint):
        """清除单个端点缓存"""
        url = f"{self.base_url}/cache/{endpoint}"
        try:
            response = requests.delete(url, headers=self.headers)
            if response.status_code == 200:
                return f"✓ {endpoint}: 缓存清除成功"
            else:
                return f"✗ {endpoint}: 失败 (HTTP {response.status_code})"
        except Exception as e:
            return f"✗ {endpoint}: 错误 - {str(e)}"
    def batch_clear(self, endpoints=None, parallel=True):
        """批量清除缓存"""
        if endpoints is None:
            # 从配置文件或API获取端点列表
            endpoints = self.get_endpoints()
        if parallel:
            # 并行清除
            with ThreadPoolExecutor(max_workers=5) as executor:
                futures = {executor.submit(self.clear_endpoint_cache, ep): ep 
                          for ep in endpoints}
                for future in as_completed(futures):
                    print(future.result())
        else:
            # 顺序清除
            for endpoint in endpoints:
                result = self.clear_endpoint_cache(endpoint)
                print(result)
    def get_endpoints(self):
        """获取需要清除缓存的端点列表"""
        try:
            response = requests.get(
                f"{self.base_url}/cache/endpoints",
                headers=self.headers
            )
            if response.status_code == 200:
                return response.json()['endpoints']
        except:
            pass
        return ['users', 'products', 'orders', 'categories']
# 使用示例
if __name__ == "__main__":
    clearer = CacheClearer(
        base_url="https://api.example.com",
        api_key="your-api-key"
    )
    # 指定端点清除
    endpoints = ['users', 'products', 'orders']
    clearer.batch_clear(endpoints, parallel=True)
    # 或者自动获取所有需要清除的端点
    clearer.batch_clear()

使用Redis清空模式（如果缓存使用Redis）

#!/bin/bash
# Redis配置
REDIS_HOST="localhost"
REDIS_PORT=6379
REDIS_PASSWORD="your-password"
# 清空特定模式的缓存键
clear_redis_cache() {
    local pattern=$1
    # 获取匹配的键
    keys=$(redis-cli -h $REDIS_HOST -p $REDIS_PORT -a $REDIS_PASSWORD \
        KEYS "api:cache:${pattern}*")
    if [ -n "$keys" ]; then
        echo "$keys" | while read -r key; do
            redis-cli -h $REDIS_HOST -p $REDIS_PORT -a $REDIS_PASSWORD \
                DEL "$key"
            echo "删除: $key"
        done
    else
        echo "没有匹配的键: ${pattern}"
    fi
}
# 批量清除不同类型的缓存
patterns=("users:" "products:" "orders:")
for pattern in "${patterns[@]}"; do
    echo "清除缓存: api:cache:${pattern}*"
    clear_redis_cache "$pattern"
done

使用配置文件批量清除

# cache-config.yaml
api:
  base_url: "https://api.example.com"
  key: "your-api-key"
  endpoints:
    - name: "users"
      methods: ["GET", "POST"]
    - name: "products"
      methods: ["GET"]
    - name: "orders"
      methods: ["GET", "PUT"]
    - name: "inventory"
      methods: ["GET", "POST", "DELETE"]
cache_strategy:
  batch_size: 5
  timeout: 30
  retry_count: 3
  parallel: true

通用清除函数库

// Node.js脚本
const axios = require('axios');
const fs = require('fs');
class ApiCacheManager {
    constructor(config) {
        this.apiKey = config.apiKey;
        this.baseUrl = config.baseUrl;
        this.client = axios.create({
            baseURL: config.baseUrl,
            headers: {
                'Authorization': `Bearer ${config.apiKey}`,
                'Content-Type': 'application/json'
            }
        });
    }
    async clearEndpoint(endpoint) {
        try {
            const response = await this.client.delete(`/cache/${endpoint}`);
            return { endpoint, status: 'success', code: response.status };
        } catch (error) {
            return { endpoint, status: 'failed', error: error.message };
        }
    }
    async batchClear(endpoints, options = {}) {
        const { parallel = true, batchSize = 5, delay = 1000 } = options;
        const results = [];
        if (parallel) {
            // 并行处理
            const batches = [];
            for (let i = 0; i < endpoints.length; i += batchSize) {
                batches.push(endpoints.slice(i, i + batchSize));
            }
            for (const batch of batches) {
                const batchResults = await Promise.all(
                    batch.map(ep => this.clearEndpoint(ep))
                );
                results.push(...batchResults);
                await new Promise(resolve => setTimeout(resolve, delay));
            }
        } else {
            // 顺序处理
            for (const endpoint of endpoints) {
                const result = await this.clearEndpoint(endpoint);
                results.push(result);
                if (result.status === 'failed') {
                    console.warn(`清除 ${endpoint} 失败: ${result.error}`);
                }
                // 添加延迟避免请求过快
                await new Promise(resolve => setTimeout(resolve, 500));
            }
        }
        return results;
    }
    async clearByPattern(pattern) {
        // 通过模式匹配清除
        const endpoints = await this.getEndpointsByPattern(pattern);
        return this.batchClear(endpoints);
    }
}
// 使用示例
async function main() {
    const config = {
        apiKey: 'your-api-key',
        baseUrl: 'https://api.example.com'
    };
    const manager = new ApiCacheManager(config);
    // 清除指定端点
    const endpoints = ['users', 'products', 'orders'];
    const results = await manager.batchClear(endpoints, {
        parallel: true,
        batchSize: 3,
        delay: 2000
    });
    console.log('清除结果:', results);
}
main().catch(console.error);

使用Docker容器批量清除

# docker-compose.yml
version: '3.8'
services:
  cache-clearer:
    image: alpine/curl
    entrypoint: |
      /bin/sh -c "
      apk add --no-cache jq;
      while IFS= read -r endpoint; do
        echo 'Clearing cache for: ' $endpoint;
        curl -X DELETE -H 'Authorization: Bearer \${API_KEY}' \
          https://api.example.com/cache/\$endpoint;
        sleep 1;
      done < /endpoints.txt
      "
    volumes:
      - ./endpoints.txt:/endpoints.txt
    environment:
      - API_KEY=${API_KEY}

注意事项

1. 安全考虑：

   • 使用环境变量存储API密钥
   • 实现认证和授权检查
   • 添加操作日志记录

2. 性能优化：

   • 使用并发控制限制请求速率
   • 实现重试机制处理临时错误
   • 添加超时控制

3. 错误处理：

   • 记录失败的清除操作
   • 实现部分成功的回滚机制
   • 发送通知报告清除结果

4. 监控告警：

   • 记录清除操作的性能指标
   • 设置失败率告警阈值
   • 定期验证缓存是否被成功清除

根据你的具体需求选择合适的方法,记得在生产环境使用前进行充分测试。