模版文件
```yaml
port 6379
bind 0.0.0.0
protected-mode no
daemonize no
appendonly yes
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 15000
cluster-announce-ip 172.19.0.1${NO}
cluster-announce-port 6379
cluster-announce-bus-port 16379
```

生成脚本
```yaml
for no in `seq 1 6`; do \
  mkdir -p redis-${no}/conf \
  && NO=${no} envsubst < redis-cluster.tmpl > redis-${no}/conf/redis.conf \
  && mkdir -p redis-${no}/data;\
done

```

docker-compose.yaml文件
```yaml
# 描述 Compose 文件的版本信息
version: "3.8"

# 定义服务，可以多个
services:
  redis-cluster:
    image: redis:latest
    networks:
      redis:
        ipv4_address: 172.19.0.2
    command: redis-cli --cluster create 172.19.0.11:6379 172.19.0.12:6379 172.19.0.13:6379 172.19.0.14:6379 172.19.0.15:6379 172.19.0.16:6379 --cluster-replicas 1  --cluster-yes
    depends_on:
      - redis-1
      - redis-2
      - redis-3
      - redis-4
      - redis-5
      - redis-6



  redis-1: # 服务名称
    image: redis:latest # 创建容器时所需的镜像
    container_name: redis-1 # 容器名称
    restart: "no" # 容器总是重新启动
    networks:
      redis:
        ipv4_address: 172.19.0.11
    ports:
      - "6379:6379"
      - "16379:16379"
    volumes: # 数据卷，目录挂载
      - ./etc_rc.local:/etc/rc.local
      - ./redis-1/conf/redis.conf:/etc/redis/redis.conf
      - ./redis-1/data:/data
    command: redis-server /etc/redis/redis.conf # 覆盖容器启动后默认执行的命令
  redis-2:
    image: redis:latest
    container_name: redis-2
    networks:
      redis:
        ipv4_address: 172.19.0.12
    ports:
      - "6380:6379"
      - "16380:16379"
    volumes:
      - ./etc_rc.local:/etc/rc.local
      - ./redis-2/conf/redis.conf:/etc/redis/redis.conf
      - ./redis-2/data:/data
    command: redis-server /etc/redis/redis.conf
  redis-3:
    image: redis:latest
    container_name: redis-3
    networks:
      redis:
        ipv4_address: 172.19.0.13
    ports:
      - "6381:6379"
      - "16381:16379"
    volumes:
      - ./etc_rc.local:/etc/rc.local
      - ./redis-3/conf/redis.conf:/etc/redis/redis.conf
      - ./redis-3/data:/data
    command: redis-server /etc/redis/redis.conf
  redis-4:
    image: redis:latest
    container_name: redis-4
    networks:
      redis:
        ipv4_address: 172.19.0.14
    ports:
      - "6382:6379"
      - "16382:16379"
    volumes:
      - ./etc_rc.local:/etc/rc.local
      - ./redis-4/conf/redis.conf:/etc/redis/redis.conf
      - ./redis-4/data:/data
    command: redis-server /etc/redis/redis.conf
  redis-5:
    image: redis:latest
    container_name: redis-5
    networks:
      redis:
        ipv4_address: 172.19.0.15
    ports:
      - "6383:6379"
      - "16383:16379"
    volumes:
      - ./etc_rc.local:/etc/rc.local
      - ./redis-5/conf/redis.conf:/etc/redis/redis.conf
      - ./redis-5/data:/data
    command: redis-server /etc/redis/redis.conf
  redis-6:
    image: redis:latest
    container_name: redis-6
    networks:
      redis:
        ipv4_address: 172.19.0.16
    ports:
      - "6384:6379"
      - "16384:16379"
    volumes:
      - ./etc_rc.local:/etc/rc.local
      - ./redis-6/conf/redis.conf:/etc/redis/redis.conf
      - ./redis-6/data:/data
    command: redis-server /etc/redis/redis.conf

# 自动创建网络，并手动指定IP网段
networks:
  redis:
    ipam:
      config:
        - subnet: 172.19.0.0/16
```


![image.png](/static/img/ad961b3171c0933c07fb231eaef52465.image.webp)


成功

查看集群信息
![image.png](/static/img/a8a2402ccbfc4e950ca4c78ba9d57114.image.webp)

但是把redis部署到docker并不是一种聪明的做法，而把集群都部署到一台机器也只是玩玩，切勿运用生产环境。

Redis三主三从集群Docker搭建

```xml
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>


```


![image.png](/static/img/e0d06a53401ed3fda279703c81fc3127.image.webp)

SpringBoot集成Redis三主三从集群

There are several reasons why learning Redis can be beneficial:

1. **High Performance**: Redis is an in-memory data store that offers fast read and write operations. It is designed to handle millions of operations per second, making it suitable for use cases that require high-performance data storage and retrieval.



2. **Versatility**: Redis supports a wide range of data structures, including strings, lists, sets, sorted sets, and hashes. This versatility allows you to use Redis for various use cases, such as caching, session management, real-time analytics, messaging, and more.

3. **Ease of Use**: Redis has a simple and intuitive API, making it easy to learn and use. It provides commands for common data operations and supports various programming languages through client libraries. Additionally, Redis offers features like transactions, pub/sub messaging, and Lua scripting, which enhance its functionality and ease of use.

4. **Scalability**: Redis supports horizontal scaling through replication and clustering. You can set up multiple Redis instances to distribute the data and workload across multiple nodes, providing high availability and improved performance as your application grows.

5. **Persistence Options**: Redis allows you to persist data to disk, ensuring data durability even in the event of a system restart or power failure. It provides different persistence options, including snapshotting and append-only file (AOF) persistence, allowing you to choose the option that best suits your requirements.

6. **Integration with Other Technologies**: Redis integrates well with other technologies and can be used as a complementary component in a larger tech stack. For example, it can be used alongside databases like MySQL or PostgreSQL to cache frequently accessed data and reduce database load.

7. **Community and Ecosystem**: Redis has a vibrant community and a rich ecosystem of tools and libraries. This means you can find resources, documentation, and community support easily. Additionally, Redis offers modules that extend its functionality for specific use cases, such as full-text search, time-series data, and graph processing.

Overall, learning Redis can expand your skill set as a developer and provide you with a powerful tool for building high-performance, scalable, and data-intensive applications.

Why we should learn redis?

Redis源码分析 --hashtable

哈希洪水攻击（Hash-Flooding Attack）是一种拒绝服务攻击（Denial of Service），旨在使服务器陷入瘫痪。攻击者利用哈希表数据结构的特性，通过构造大量具有相同哈希值的输入数据，使服务器在处理这些数据时消耗大量的计算资源和内存，导致服务器无法正常响应其他合法请求。

哈希洪水攻击的原理是利用哈希表中的哈希冲突（碰撞）问题。在哈希表中，不同的键（Key）通过哈希函数映射到不同的位置，但由于哈希函数的限制，不同的键可能会映射到相同的位置，即发生哈希冲突。当攻击者构造大量具有相同哈希值的输入数据时，这些数据会被存储在哈希表的同一个位置上，导致哈希表的性能急剧下降，服务器无法正常处理其他请求。



为了防御哈希洪水攻击，可以采取以下措施：
1. 限制参数个数：通过限制每个请求中的参数个数，可以减少攻击者构造大量输入数据的可能性。
2. 验证用户身份：禁止未经身份验证的用户提交数据，可以防止攻击者利用哈希洪水攻击。
3. 使用更安全的哈希算法：设计和使用更安全的哈希算法，减少哈希冲突的发生，提高哈希表的性能和安全性。
4. 监控和限制请求频率：监控服务器的请求频率，及时发现异常请求并限制其访问，防止哈希洪水攻击的发生。

哈希洪水攻击是一种持续演化的攻击方式，攻击者可能会不断改进攻击方法，因此保持对最新攻击技术的了解，并及时更新防御措施是非常重要的。

---
Learn more:
1. [什么是哈希洪水攻击（Hash-FloodingAttack） - PingCode](https://docs.pingcode.com/ask/24937.html)
2. [什么是哈希洪水攻击（Hash-Flooding Attack）？ - 知乎](https://www.zhihu.com/question/286529973)
3. [什么是哈希洪水攻击（Hash-Flooding Attack）？-腾讯云开发者社区-腾讯云](https://cloud.tencent.com/developer/article/1447523)