1. 自建Redis上云迁移概述

随着云计算的快速发展，越来越多的企业选择将自建的Redis环境迁移到云端，以获得更好的弹性扩展、运维自动化和管理便利性。Redis上云迁移是一个复杂的过程，需要综合考虑数据安全、业务连续性、成本优化等多个因素。

1.1 自建Redis上云迁移优势

  1. 运维简化: 减少硬件维护和系统管理成本
  2. 弹性扩展: 根据业务需求动态调整资源
  3. 高可用保障: 云平台提供的基础设施保障
  4. 成本优化: 按需付费，降低总体拥有成本
  5. 安全可靠: 云平台的安全防护和备份机制
  6. 监控完善: 云平台提供的监控和告警服务

1.2 迁移挑战与风险

  • 数据一致性: 确保迁移过程中数据不丢失
  • 业务连续性: 最小化对业务的影响
  • 性能差异: 云端环境与自建环境的性能差异
  • 网络延迟: 云端访问的网络延迟问题
  • 成本控制: 迁移后的成本优化
  • 安全合规: 数据安全和合规性要求

1.3 迁移策略类型

  1. 一次性迁移: 停机迁移，适合小规模数据
  2. 渐进式迁移: 分阶段迁移，适合大规模数据
  3. 双写迁移: 同时写入两个环境，适合高可用要求
  4. 热迁移: 在线迁移，适合业务连续性要求

2. 云平台Redis服务对比

2.1 主流云平台Redis服务

阿里云Redis

1
2
3
4
5
6
7
# 阿里云Redis特点
- 服务名称: 云数据库Redis版
- 支持版本: Redis 2.8, 3.0, 4.0, 5.0, 6.0, 7.0
- 架构支持: 标准版、集群版、读写分离版
- 存储类型: 内存型、持久内存型
- 地域覆盖: 全球多地域部署
- 价格: 按实例规格和存储容量计费

腾讯云Redis

1
2
3
4
5
6
7
# 腾讯云Redis特点
- 服务名称: 云数据库Redis
- 支持版本: Redis 2.8, 3.0, 4.0, 5.0, 6.0, 7.0
- 架构支持: 标准版、集群版、读写分离版
- 存储类型: 内存型、持久内存型
- 地域覆盖: 全球多地域部署
- 价格: 按实例规格和存储容量计费

AWS ElastiCache

1
2
3
4
5
6
7
# AWS ElastiCache特点
- 服务名称: Amazon ElastiCache for Redis
- 支持版本: Redis 3.2, 4.0, 5.0, 6.0, 7.0
- 架构支持: 单节点、集群模式
- 存储类型: 内存型
- 地域覆盖: 全球多地域部署
- 价格: 按实例规格和存储容量计费

2.2 云平台功能对比

功能特性 阿里云 腾讯云 AWS
Redis版本支持 2.8-7.0 2.8-7.0 3.2-7.0
集群模式 ✅ ✅ ✅
读写分离 ✅ ✅ ✅
数据持久化 ✅ ✅ ✅
自动备份 ✅ ✅ ✅
监控告警 ✅ ✅ ✅
安全加密 ✅ ✅ ✅
多可用区 ✅ ✅ ✅
弹性扩展 ✅ ✅ ✅

2.3 成本对比分析

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 成本对比示例（以2GB内存为例）
阿里云Redis:
- 标准版: 约200元/月
- 集群版: 约300元/月
- 读写分离版: 约250元/月

腾讯云Redis:
- 标准版: 约180元/月
- 集群版: 约280元/月
- 读写分离版: 约230元/月

AWS ElastiCache:
- 单节点: 约$50/月
- 集群模式: 约$80/月

3. 迁移前准备工作

3.1 环境评估

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#!/bin/bash
# redis-environment-assessment.sh

# 检查Redis版本
redis_version=$(redis-cli --version | cut -d' ' -f2)
echo "Redis版本: $redis_version"

# 检查内存使用
memory_usage=$(redis-cli info memory | grep used_memory_human | cut -d: -f2)
echo "内存使用: $memory_usage"

# 检查数据量
data_size=$(redis-cli info memory | grep used_memory_dataset | cut -d: -f2)
echo "数据大小: $data_size"

# 检查连接数
connections=$(redis-cli info clients | grep connected_clients | cut -d: -f2)
echo "连接数: $connections"

# 检查命令执行数
commands=$(redis-cli info stats | grep total_commands_processed | cut -d: -f2)
echo "命令执行数: $commands"

# 检查持久化配置
persistence=$(redis-cli config get save)
echo "持久化配置: $persistence"

# 检查复制配置
replication=$(redis-cli info replication)
echo "复制配置: $replication"

3.2 数据备份

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#!/bin/bash
# redis-backup.sh

BACKUP_DIR="/opt/redis-backup/$(date +%Y%m%d-%H%M%S)"
mkdir -p $BACKUP_DIR

# 创建RDB快照
echo "创建RDB快照..."
redis-cli bgsave

# 等待快照完成
while [ $(redis-cli lastsave) -eq $(redis-cli lastsave) ]; do
    sleep 1
done

# 复制RDB文件
cp /var/lib/redis/dump.rdb $BACKUP_DIR/

# 复制AOF文件（如果启用）
if [ -f /var/lib/redis/appendonly.aof ]; then
    cp /var/lib/redis/appendonly.aof $BACKUP_DIR/
fi

# 复制配置文件
cp /etc/redis/redis.conf $BACKUP_DIR/

echo "备份完成: $BACKUP_DIR"

3.3 网络连通性测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#!/bin/bash
# network-connectivity-test.sh

# 测试云平台网络连通性
test_cloud_connectivity() {
    local cloud_provider=$1
    local region=$2
    
    case $cloud_provider in
        "aliyun")
            # 测试阿里云Redis连接
            redis-cli -h r-xxx.redis.rds.aliyuncs.com -p 6379 -a password ping
            ;;
        "tencent")
            # 测试腾讯云Redis连接
            redis-cli -h xxx.redis.tencentcloudapi.com -p 6379 -a password ping
            ;;
        "aws")
            # 测试AWS ElastiCache连接
            redis-cli -h xxx.cache.amazonaws.com -p 6379 -a password ping
            ;;
    esac
}

# 测试网络延迟
test_network_latency() {
    local host=$1
    local port=$2
    
    echo "测试网络延迟..."
    redis-cli --latency-history -h $host -p $port -i 1
}

4. 迁移工具选择

4.1 Redis官方迁移工具

redis-cli –rdb

1
2
3
4
5
# 使用redis-cli进行数据迁移
redis-cli --rdb /path/to/dump.rdb

# 将RDB文件导入到目标Redis
redis-cli -h target-host -p 6379 --pipe < /path/to/dump.rdb

redis-cli –replica

1
2
3
4
5
# 设置从节点复制
redis-cli -h target-host -p 6379 replicaof source-host 6379

# 等待同步完成
redis-cli -h target-host -p 6379 info replication

4.2 第三方迁移工具

redis-shake

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 下载redis-shake
wget https://github.com/alibaba/RedisShake/releases/download/release-v2.0.3-20200724/redis-shake-linux-amd64.tar.gz
tar -xzf redis-shake-linux-amd64.tar.gz

# 配置redis-shake
cat > redis-shake.conf << EOF
source.type = standalone
source.address = source-host:6379
source.password = source-password

target.type = standalone
target.address = target-host:6379
target.password = target-password

# 迁移模式
sync.type = rdb
EOF

# 启动迁移
./redis-shake -conf=redis-shake.conf

redis-port

1
2
3
4
5
6
7
8
9
# 下载redis-port
wget https://github.com/CodisLabs/redis-port/releases/download/v3.0.0/redis-port-linux-amd64.tar.gz
tar -xzf redis-port-linux-amd64.tar.gz

# 实时同步
./redis-port sync --from=source-host:6379 --to=target-host:6379

# 批量导入
./redis-port restore --from=dump.rdb --to=target-host:6379

4.3 云平台迁移工具

阿里云DTS

1
2
3
4
5
6
7
8
9
# 使用阿里云DTS进行迁移
aliyun dts CreateMigrationJob \
  --SourceEndpointEngineName "Redis" \
  --SourceEndpointInstanceType "RDS" \
  --SourceEndpointInstanceID "r-xxx" \
  --TargetEndpointEngineName "Redis" \
  --TargetEndpointInstanceType "RDS" \
  --TargetEndpointInstanceID "r-yyy" \
  --MigrationMode "FullData"

腾讯云DTS

1
2
3
4
5
6
7
8
9
# 使用腾讯云DTS进行迁移
tccli dts CreateMigrationJob \
  --SrcDatabaseType "Redis" \
  --SrcAccessType "cdb" \
  --SrcInfo '{"InstanceId":"xxx"}' \
  --DstDatabaseType "Redis" \
  --DstAccessType "cdb" \
  --DstInfo '{"InstanceId":"yyy"}' \
  --JobName "redis-migration"

5. 迁移方案实施

5.1 一次性迁移方案

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#!/bin/bash
# one-time-migration.sh

# 1. 停止应用服务
echo "停止应用服务..."
systemctl stop application-service

# 2. 创建最终备份
echo "创建最终备份..."
redis-cli bgsave
while [ $(redis-cli lastsave) -eq $(redis-cli lastsave) ]; do
    sleep 1
done

# 3. 导出数据
echo "导出数据..."
redis-cli --rdb /tmp/final-backup.rdb

# 4. 创建云Redis实例
echo "创建云Redis实例..."
# 使用云平台CLI创建实例

# 5. 导入数据到云Redis
echo "导入数据到云Redis..."
redis-cli -h cloud-redis-host -p 6379 -a password --pipe < /tmp/final-backup.rdb

# 6. 验证数据
echo "验证数据..."
source_count=$(redis-cli dbsize)
target_count=$(redis-cli -h cloud-redis-host -p 6379 -a password dbsize)
echo "源数据量: $source_count, 目标数据量: $target_count"

# 7. 更新应用配置
echo "更新应用配置..."
sed -i 's/localhost:6379/cloud-redis-host:6379/g' /etc/application/config.conf

# 8. 启动应用服务
echo "启动应用服务..."
systemctl start application-service

echo "迁移完成！"

5.2 渐进式迁移方案

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#!/bin/bash
# progressive-migration.sh

# 1. 设置云Redis为从节点
echo "设置云Redis为从节点..."
redis-cli -h cloud-redis-host -p 6379 -a password replicaof source-host 6379

# 2. 等待数据同步
echo "等待数据同步..."
while true; do
    lag=$(redis-cli -h cloud-redis-host -p 6379 -a password info replication | grep master_repl_offset | cut -d: -f2)
    if [ "$lag" = "0" ]; then
        echo "数据同步完成"
        break
    fi
    echo "同步延迟: $lag"
    sleep 10
done

# 3. 停止从节点复制
echo "停止从节点复制..."
redis-cli -h cloud-redis-host -p 6379 -a password replicaof no one

# 4. 切换应用连接
echo "切换应用连接..."
# 逐步切换应用连接到云Redis

# 5. 验证业务功能
echo "验证业务功能..."
# 验证应用功能是否正常

echo "渐进式迁移完成！"

5.3 双写迁移方案

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#!/bin/bash
# dual-write-migration.sh

# 1. 配置双写
echo "配置双写..."
# 修改应用代码，同时写入两个Redis

# 2. 数据一致性检查
echo "数据一致性检查..."
check_data_consistency() {
    local key=$1
    local source_value=$(redis-cli get $key)
    local target_value=$(redis-cli -h cloud-redis-host -p 6379 -a password get $key)
    
    if [ "$source_value" = "$target_value" ]; then
        echo "Key $key 数据一致"
        return 0
    else
        echo "Key $key 数据不一致"
        return 1
    fi
}

# 3. 逐步切换读操作
echo "逐步切换读操作..."
# 修改应用代码，从云Redis读取数据

# 4. 停止双写
echo "停止双写..."
# 修改应用代码，只写入云Redis

# 5. 清理自建Redis
echo "清理自建Redis..."
# 停止自建Redis服务

echo "双写迁移完成！"

6. 云平台Redis配置优化

6.1 阿里云Redis优化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 阿里云Redis配置优化
aliyun r-kvstore ModifyInstanceConfig \
  --InstanceId "r-xxx" \
  --Config "maxmemory-policy=allkeys-lru" \
  --Config "timeout=300" \
  --Config "tcp-keepalive=60"

# 设置监控告警
aliyun cms PutMetricRule \
  --RuleName "redis-cpu-usage" \
  --MetricName "CPUUtilization" \
  --Namespace "acs_rds" \
  --Dimensions '{"instanceId":"r-xxx"}' \
  --Period 300 \
  --Statistics "Average" \
  --Threshold 80 \
  --ComparisonOperator "GreaterThanThreshold"

6.2 腾讯云Redis优化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 腾讯云Redis配置优化
tccli redis ModifyInstanceParams \
  --InstanceId "crs-xxx" \
  --InstanceParams '[
    {"Name":"maxmemory-policy","Value":"allkeys-lru"},
    {"Name":"timeout","Value":"300"},
    {"Name":"tcp-keepalive","Value":"60"}
  ]'

# 设置监控告警
tccli monitor PutMetricRule \
  --RuleName "redis-memory-usage" \
  --MetricName "MemoryUsage" \
  --Namespace "QCE/REDIS" \
  --Dimensions '[{"Name":"instanceId","Value":"crs-xxx"}]' \
  --Period 300 \
  --Statistics "Average" \
  --Threshold 80 \
  --ComparisonOperator "GreaterThanThreshold"

6.3 AWS ElastiCache优化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# AWS ElastiCache配置优化
aws elasticache modify-cache-parameter-group \
  --cache-parameter-group-name "custom-redis-params" \
  --parameter-name-values \
    ParameterName=maxmemory-policy,ParameterValue=allkeys-lru \
    ParameterName=timeout,ParameterValue=300 \
    ParameterName=tcp-keepalive,ParameterValue=60

# 设置CloudWatch告警
aws cloudwatch put-metric-alarm \
  --alarm-name "redis-cpu-usage" \
  --alarm-description "Redis CPU usage alarm" \
  --metric-name "CPUUtilization" \
  --namespace "AWS/ElastiCache" \
  --statistic "Average" \
  --period 300 \
  --threshold 80 \
  --comparison-operator "GreaterThanThreshold" \
  --dimensions Name=CacheClusterId,Value=redis-cluster

7. 迁移后验证与测试

7.1 数据完整性验证

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#!/bin/bash
# data-integrity-check.sh

# 检查数据量
echo "检查数据量..."
source_count=$(redis-cli dbsize)
target_count=$(redis-cli -h cloud-redis-host -p 6379 -a password dbsize)
echo "源数据量: $source_count, 目标数据量: $target_count"

# 检查数据类型
echo "检查数据类型..."
redis-cli --scan --pattern "*" | while read key; do
    source_type=$(redis-cli type $key)
    target_type=$(redis-cli -h cloud-redis-host -p 6379 -a password type $key)
    
    if [ "$source_type" != "$target_type" ]; then
        echo "Key $key 类型不一致: $source_type vs $target_type"
    fi
done

# 检查过期时间
echo "检查过期时间..."
redis-cli --scan --pattern "*" | while read key; do
    source_ttl=$(redis-cli ttl $key)
    target_ttl=$(redis-cli -h cloud-redis-host -p 6379 -a password ttl $key)
    
    if [ "$source_ttl" != "$target_ttl" ]; then
        echo "Key $key TTL不一致: $source_ttl vs $target_ttl"
    fi
done

7.2 性能测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#!/bin/bash
# performance-test.sh

# 测试写入性能
echo "测试写入性能..."
redis-benchmark -h cloud-redis-host -p 6379 -a password -t set -n 10000 -c 100

# 测试读取性能
echo "测试读取性能..."
redis-benchmark -h cloud-redis-host -p 6379 -a password -t get -n 10000 -c 100

# 测试混合性能
echo "测试混合性能..."
redis-benchmark -h cloud-redis-host -p 6379 -a password -t set,get -n 10000 -c 100

# 测试延迟
echo "测试延迟..."
redis-cli --latency-history -h cloud-redis-host -p 6379 -a password -i 1

7.3 业务功能测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#!/bin/bash
# business-function-test.sh

# 测试缓存功能
echo "测试缓存功能..."
redis-cli -h cloud-redis-host -p 6379 -a password set "test:cache" "test_value"
cache_value=$(redis-cli -h cloud-redis-host -p 6379 -a password get "test:cache")
if [ "$cache_value" = "test_value" ]; then
    echo "缓存功能正常"
else
    echo "缓存功能异常"
fi

# 测试会话存储
echo "测试会话存储..."
redis-cli -h cloud-redis-host -p 6379 -a password setex "session:user123" 3600 "session_data"
session_value=$(redis-cli -h cloud-redis-host -p 6379 -a password get "session:user123")
if [ "$session_value" = "session_data" ]; then
    echo "会话存储功能正常"
else
    echo "会话存储功能异常"
fi

# 测试计数器功能
echo "测试计数器功能..."
redis-cli -h cloud-redis-host -p 6379 -a password incr "counter:test"
counter_value=$(redis-cli -h cloud-redis-host -p 6379 -a password get "counter:test")
if [ "$counter_value" = "1" ]; then
    echo "计数器功能正常"
else
    echo "计数器功能异常"
fi

8. 监控与运维

8.1 云平台监控配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
# 阿里云监控配置
aliyun cms PutMetricRule \
  --RuleName "redis-connection-count" \
  --MetricName "ConnectionCount" \
  --Namespace "acs_rds" \
  --Dimensions '{"instanceId":"r-xxx"}' \
  --Period 300 \
  --Statistics "Average" \
  --Threshold 1000 \
  --ComparisonOperator "GreaterThanThreshold"

# 腾讯云监控配置
tccli monitor PutMetricRule \
  --RuleName "redis-memory-usage" \
  --MetricName "MemoryUsage" \
  --Namespace "QCE/REDIS" \
  --Dimensions '[{"Name":"instanceId","Value":"crs-xxx"}]' \
  --Period 300 \
  --Statistics "Average" \
  --Threshold 80 \
  --ComparisonOperator "GreaterThanThreshold"

# AWS CloudWatch配置
aws cloudwatch put-metric-alarm \
  --alarm-name "redis-memory-usage" \
  --alarm-description "Redis memory usage alarm" \
  --metric-name "DatabaseMemoryUsagePercentage" \
  --namespace "AWS/ElastiCache" \
  --statistic "Average" \
  --period 300 \
  --threshold 80 \
  --comparison-operator "GreaterThanThreshold" \
  --dimensions Name=CacheClusterId,Value=redis-cluster

8.2 自定义监控脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
#!/bin/bash
# custom-monitoring.sh

# 监控Redis连接数
monitor_connections() {
    local host=$1
    local port=$2
    local password=$3
    
    connections=$(redis-cli -h $host -p $port -a $password info clients | grep connected_clients | cut -d: -f2)
    echo "Redis连接数: $connections"
    
    if [ $connections -gt 1000 ]; then
        echo "警告: 连接数过高"
        # 发送告警
    fi
}

# 监控Redis内存使用
monitor_memory() {
    local host=$1
    local port=$2
    local password=$3
    
    memory_used=$(redis-cli -h $host -p $port -a $password info memory | grep used_memory_human | cut -d: -f2)
    memory_max=$(redis-cli -h $host -p $port -a $password info memory | grep maxmemory_human | cut -d: -f2)
    
    echo "Redis内存使用: $memory_used / $memory_max"
    
    # 计算内存使用率
    memory_percent=$(redis-cli -h $host -p $port -a $password info memory | grep used_memory_percentage | cut -d: -f2)
    if [ ${memory_percent%.*} -gt 80 ]; then
        echo "警告: 内存使用率过高"
        # 发送告警
    fi
}

# 监控Redis性能
monitor_performance() {
    local host=$1
    local port=$2
    local password=$3
    
    # 测试延迟
    latency=$(redis-cli -h $host -p $port -a $password --latency -i 1 -c 10 | tail -1 | cut -d' ' -f1)
    echo "Redis延迟: ${latency}ms"
    
    if [ ${latency%.*} -gt 10 ]; then
        echo "警告: 延迟过高"
        # 发送告警
    fi
}

8.3 自动化运维脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
#!/bin/bash
# automated-ops.sh

# 自动备份
auto_backup() {
    local host=$1
    local port=$2
    local password=$3
    local backup_dir=$4
    
    echo "开始自动备份..."
    
    # 创建备份目录
    mkdir -p $backup_dir/$(date +%Y%m%d)
    
    # 执行备份
    redis-cli -h $host -p $port -a $password bgsave
    
    # 等待备份完成
    while [ $(redis-cli -h $host -p $port -a $password lastsave) -eq $(redis-cli -h $host -p $port -a $password lastsave) ]; do
        sleep 1
    done
    
    # 复制备份文件
    scp $host:/var/lib/redis/dump.rdb $backup_dir/$(date +%Y%m%d)/dump-$(date +%H%M%S).rdb
    
    echo "备份完成"
}

# 自动清理
auto_cleanup() {
    local host=$1
    local port=$2
    local password=$3
    
    echo "开始自动清理..."
    
    # 清理过期key
    expired_keys=$(redis-cli -h $host -p $port -a $password --scan --pattern "*" | wc -l)
    echo "发现过期key: $expired_keys"
    
    # 清理内存碎片
    redis-cli -h $host -p $port -a $password memory purge
    
    echo "清理完成"
}

# 自动扩容
auto_scale() {
    local host=$1
    local port=$2
    local password=$3
    
    echo "检查是否需要扩容..."
    
    # 检查内存使用率
    memory_percent=$(redis-cli -h $host -p $port -a $password info memory | grep used_memory_percentage | cut -d: -f2)
    
    if [ ${memory_percent%.*} -gt 90 ]; then
        echo "内存使用率过高，需要扩容"
        # 触发扩容流程
    fi
}

9. 成本优化策略

9.1 实例规格优化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 实例规格选择建议
# 小规模应用 (< 1GB)
- 阿里云: redis.master.small.default
- 腾讯云: S1.SMALL1
- AWS: cache.t3.micro

# 中等规模应用 (1-4GB)
- 阿里云: redis.master.mid.default
- 腾讯云: S1.MEDIUM2
- AWS: cache.t3.small

# 大规模应用 (> 4GB)
- 阿里云: redis.master.large.default
- 腾讯云: S1.LARGE4
- AWS: cache.t3.medium

9.2 存储优化

1
2
3
4
5
6
7
8
9
# 存储类型选择
# 内存型: 适合缓存场景，性能最佳
# 持久内存型: 适合持久化需求，成本较低

# 数据压缩
redis-cli config set hash-max-ziplist-entries 512
redis-cli config set hash-max-ziplist-value 64
redis-cli config set list-max-ziplist-size -2
redis-cli config set set-max-intset-entries 512

9.3 网络优化

1
2
3
4
5
6
7
8
9
10
# 网络配置优化
# 使用VPC内网访问，降低网络成本
# 配置连接池，减少连接数
# 使用批量操作，减少网络请求

# 连接池配置示例
max_connections=100
min_connections=10
connection_timeout=5000
idle_timeout=300000

10. 故障处理与回滚

10.1 常见故障处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#!/bin/bash
# fault-handling.sh

# 连接超时处理
handle_connection_timeout() {
    echo "处理连接超时..."
    
    # 检查网络连通性
    ping -c 3 cloud-redis-host
    
    # 检查Redis服务状态
    redis-cli -h cloud-redis-host -p 6379 -a password ping
    
    # 重启应用服务
    systemctl restart application-service
}

# 内存不足处理
handle_memory_shortage() {
    echo "处理内存不足..."
    
    # 清理过期key
    redis-cli -h cloud-redis-host -p 6379 -a password --scan --pattern "*" | xargs redis-cli -h cloud-redis-host -p 6379 -a password expire 1
    
    # 触发内存清理
    redis-cli -h cloud-redis-host -p 6379 -a password memory purge
    
    # 考虑扩容
    echo "考虑扩容实例..."
}

# 数据不一致处理
handle_data_inconsistency() {
    echo "处理数据不一致..."
    
    # 停止应用服务
    systemctl stop application-service
    
    # 重新同步数据
    redis-cli -h cloud-redis-host -p 6379 -a password replicaof source-host 6379
    
    # 等待同步完成
    while [ $(redis-cli -h cloud-redis-host -p 6379 -a password info replication | grep master_repl_offset | cut -d: -f2) != "0" ]; do
        sleep 10
    done
    
    # 启动应用服务
    systemctl start application-service
}

10.2 回滚方案

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#!/bin/bash
# rollback-plan.sh

# 紧急回滚
emergency_rollback() {
    echo "执行紧急回滚..."
    
    # 1. 停止应用服务
    systemctl stop application-service
    
    # 2. 恢复应用配置
    cp /etc/application/config.conf.backup /etc/application/config.conf
    
    # 3. 启动自建Redis
    systemctl start redis
    
    # 4. 启动应用服务
    systemctl start application-service
    
    echo "回滚完成"
}

# 数据回滚
data_rollback() {
    echo "执行数据回滚..."
    
    # 1. 停止应用服务
    systemctl stop application-service
    
    # 2. 恢复数据备份
    cp /opt/redis-backup/latest/dump.rdb /var/lib/redis/
    
    # 3. 重启Redis
    systemctl restart redis
    
    # 4. 启动应用服务
    systemctl start application-service
    
    echo "数据回滚完成"
}

11. 最佳实践总结

11.1 迁移规划原则

  1. 充分评估: 全面评估现有环境和业务需求
  2. 制定计划: 制定详细的迁移计划和时间表
  3. 风险控制: 识别和评估迁移风险
  4. 测试验证: 充分测试迁移方案
  5. 监控运维: 建立完善的监控和运维体系

11.2 迁移执行要点

  • 数据安全: 确保数据不丢失、不损坏
  • 业务连续性: 最小化对业务的影响
  • 性能保障: 确保迁移后性能满足要求
  • 成本控制: 合理控制迁移和运营成本
  • 安全合规: 满足安全和合规要求

11.3 迁移后优化

  • 性能调优: 根据实际使用情况调优配置
  • 成本优化: 持续优化资源使用和成本
  • 监控完善: 建立完善的监控和告警体系
  • 运维自动化: 提高运维效率和自动化水平
  • 安全加固: 加强安全防护和合规管理

通过合理的规划和执行，自建Redis上云迁移可以为企业带来更好的弹性扩展、运维便利性和成本优化效果。