SpringBoot2.0整合Docker_Redis一主二从三哨兵

最新推荐文章于 2024-06-24 21:40:09 发布
最新推荐文章于 2024-06-24 21:40:09 发布
阅读量539 收藏 1
点赞数
分类专栏： Redis Docker SpringCloud 文章标签： redis docker 主从 springBoot 哨兵
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Canueman/article/details/103583569
版权
Docker 同时被 3 个专栏收录
13 篇文章 0 订阅
订阅专栏
SpringCloud
9 篇文章 0 订阅
订阅专栏
Redis
3 篇文章 0 订阅
订阅专栏

Docker_Redis

1. docker pull 拉取redis，并准备相对应版本的配置文件，配置文件不对应的话，可能会出问题。
[root@localhost redis]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
redis               4.0                 8280a2c45ce5        3 weeks ago         89.2MB
2. 修改配置文件
  • 主机配置文件（只列出修改部分）
# bind 127.0.0.1        # 注掉ip绑定
protected-mode yes      # 打开保护模式
port 6379               # 主机默认6379
masterauth 123456       # 从机也有密码，加上验证
requirepass 123456      # 验证密码
  • 从机1配置文件（只列出修改部分）
# bind 127.0.0.1            # 注掉ip绑定
protected-mode yes          # 打开保护模式
port 6380                   # 从机6380端口
slaveof 192.168.0.159 6379  # 加上主机的ip和端口，等会儿docker启动redis的时候，使用的network是host，所以ip可以确定
masterauth 123456           # 从机也有密码，加上验证
requirepass 123456          # 验证密码
  • 从机2配置文件（只列出修改部分）
# bind 127.0.0.1            # 注掉ip绑定
protected-mode yes          # 打开保护模式
port 6381                   # 从机6381端口
slaveof 192.168.0.159 6379  # 加上主机的ip和端口，等会儿docker启动redis的时候，使用的network是host，所以ip可以确定
masterauth 123456           # 从机也有密码，加上验证
requirepass 123456          # 验证密码
3. 启动redis
  • 首先启动主机
docker run \
-v /dockerRedis/redis:/usr/local/etc/redis \        # 绑定数据卷，主机的redis.conf放到本地的/dockerRedis/redis目录中，它会同步到容器中
-v /dockerRedis/data:/data \                        # 持久化数据
--name redis \
--network host \                                    # 使用host
-d redis:4.0 \
redis-server /usr/local/etc/redis/redis.conf \      # 以配置文件方式启动
--appendonly yes
  • 启动从机1
docker run \
-v /dockerRedis80/redis:/usr/local/etc/redis \          # 绑定数据卷，从机1的redis.conf放到本地的/dockerRedis80/redis目录中，它会同步到容器中
-v /dockerRedis80/data:/data \                          # 持久化数据
--name redis80 \
--network host \                                        # 使用host
-d redis:4.0 \
redis-server /usr/local/etc/redis/redis.conf \          # 以配置文件方式启动
--appendonly yes
  • 启动从机2
docker run \
-v /dockerRedis81/redis:/usr/local/etc/redis \          # 绑定数据卷，从机2的redis.conf放到本地的/dockerRedis81/redis目录中，它会同步到容器中
-v /dockerRedis81/data:/data \                          # 持久化数据
--name redis81 \
--network host \                                        # 使用host
-d redis:4.0 \
redis-server /usr/local/etc/redis/redis.conf \          # 以配置文件方式启动
--appendonly yes
  • 查看是否启动成功
[root@localhost redis]# docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS               NAMES
ba3bf2106517        redis:4.0           "docker-entrypoint.s…"   6 hours ago         Up About an hour                        redis81
12974de744bb        redis:4.0           "docker-entrypoint.s…"   6 hours ago         Up 27 minutes                           redis80
889f5f75d2a8        redis:4.0           "docker-entrypoint.s…"   6 hours ago         Up 34 minutes                           redis

  • 登陆redis客户端查看主从是否成功

    • 主机
    [root@localhost ~]# docker exec -it redis redis-cli
127.0.0.1:6379> auth 123456
OK
127.0.0.1:6379> info replication
# Replication
role:master         # master角色
connected_slaves:2  # 连接的从机数量
slave0:ip=192.168.0.159,port=6381,state=online,offset=792339,lag=1  # 从机6381
slave1:ip=192.168.0.159,port=6380,state=online,offset=792195,lag=1  # 从机6380
master_replid:36b946e492eb817705b37c850bf8556136df22b7
master_replid2:2d958c8ec641afb7144b329ec0ee6d54a9eb389d
master_repl_offset:792497
second_repl_offset:396598
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:333961
repl_backlog_histlen:458537
    • 从机（另一个从机信息差不多）
    127.0.0.1:6380> [root@localhost ~]# docker exec -it redis80 redis-cli -p 6380
127.0.0.1:6380> auth 123456
OK
127.0.0.1:6380> info replication
# Replication
role:slave                  # slave角色
master_host:192.168.0.159   # 主机ip
master_port:6379            # 主机端口
master_link_status:up       # 连接状态
master_last_io_seconds_ago:1
master_sync_in_progress:0
slave_repl_offset:831773
slave_priority:100
slave_read_only:1
connected_slaves:0
master_replid:36b946e492eb817705b37c850bf8556136df22b7
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:831773
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:405043
repl_backlog_histlen:426731
4. 启动哨兵
  • 哨兵 sentinel.conf 配置文件（三个哨兵配置文件都一样，唯一不同的就是上面的端口号，分别为主机的26379和两个从机的26380、26381）
port 26379
sentinel monitor masterRedis 192.168.0.159 6379 2
sentinel auth-pass masterRedis 123456

  • 将三个 sentinel.conf 配置文件分别放在刚才放 redis.conf 的三个文件夹中，它们会自动同步到docker容器内。

  • 启动主机哨兵
    使用命令： docker exec -it redis redis-sentinel /usr/local/etc/redis/sentinel.conf

    • 为了直接看到启动效果，我在前台运行，然后用 Ctrl + P + Q 快捷键，不关闭容器的情况下退出。
    • 这里启动哨兵的方式，是用刚才的Redis主机容器，新开窗口启动，接下开两个从机也是相同的方式。
[root@localhost redis]# docker exec -it redis redis-sentinel /usr/local/etc/redis/sentinel.conf
24:X 17 Dec 07:04:00.734 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
24:X 17 Dec 07:04:00.734 # Redis version=4.0.14, bits=64, commit=00000000, modified=0, pid=24, just started
24:X 17 Dec 07:04:00.734 # Configuration loaded
                _._                                                  
           _.-``__ ''-._                                             
      _.-``    `.  `_.  ''-._           Redis 4.0.14 (00000000/0) 64 bit
  .-`` .-```.  ```\/    _.,_ ''-._                                   
 (    '      ,       .-`  | `,    )     Running in sentinel mode
 |`-._`-...-` __...-.``-._|'` _.-'|     Port: 26379
 |    `-._   `._    /     _.-'    |     PID: 24
  `-._    `-._  `-./  _.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |           http://redis.io        
  `-._    `-._`-.__.-'_.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |                                  
  `-._    `-._`-.__.-'_.-'    _.-'                                   
      `-._    `-.__.-'    _.-'                                       
          `-._        _.-'                                           
              `-.__.-'                                               

24:X 17 Dec 07:04:00.735 # WARNING: The TCP backlog setting of 511 cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of 128.
24:X 17 Dec 07:04:00.736 # Sentinel ID is 0a417519ee7d4f31a2fb2fe6c62e9affdbe8c1c4
24:X 17 Dec 07:04:00.736 # +monitor master masterRedis 192.168.0.159 6379 quorum 2
# 哨兵已经发现两个从机
24:X 17 Dec 07:04:00.737 * +slave slave 192.168.0.159:6380 192.168.0.159 6380 @ masterRedis 192.168.0.159 6379 
24:X 17 Dec 07:04:00.739 * +slave slave 192.168.0.159:6381 192.168.0.159 6381 @ masterRedis 192.168.0.159 6379
  • 80从机哨兵启动
    使用命令： docker exec -it redis80 redis-sentinel /usr/local/etc/redis/sentinel.conf
[root@localhost redis]# docker exec -it redis80 redis-sentinel /usr/local/etc/redis/sentinel.conf
17:X 17 Dec 07:04:17.515 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
17:X 17 Dec 07:04:17.515 # Redis version=4.0.14, bits=64, commit=00000000, modified=0, pid=17, just started
17:X 17 Dec 07:04:17.515 # Configuration loaded
                _._                                                  
           _.-``__ ''-._                                             
      _.-``    `.  `_.  ''-._           Redis 4.0.14 (00000000/0) 64 bit
  .-`` .-```.  ```\/    _.,_ ''-._                                   
 (    '      ,       .-`  | `,    )     Running in sentinel mode
 |`-._`-...-` __...-.``-._|'` _.-'|     Port: 26380
 |    `-._   `._    /     _.-'    |     PID: 17
  `-._    `-._  `-./  _.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |           http://redis.io        
  `-._    `-._`-.__.-'_.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |                                  
  `-._    `-._`-.__.-'_.-'    _.-'                                   
      `-._    `-.__.-'    _.-'                                       
          `-._        _.-'                                           
              `-.__.-'                                               

17:X 17 Dec 07:04:17.516 # WARNING: The TCP backlog setting of 511 cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of 128.
17:X 17 Dec 07:04:17.517 # Sentinel ID is ebde833c6f6ab79f2fd3311c965104a58080b5da
17:X 17 Dec 07:04:17.517 # +monitor master masterRedis 192.168.0.159 6379 quorum 2
17:X 17 Dec 07:04:17.518 * +slave slave 192.168.0.159:6380 192.168.0.159 6380 @ masterRedis 192.168.0.159 6379
17:X 17 Dec 07:04:17.518 * +slave slave 192.168.0.159:6381 192.168.0.159 6381 @ masterRedis 192.168.0.159 6379
 # 哨兵之间也会互相监控
17:X 17 Dec 07:04:19.213 * +sentinel sentinel 0a417519ee7d4f31a2fb2fe6c62e9affdbe8c1c4 192.168.0.159 26379 @ masterRedis 192.168.0.159 6379
  • 81从机哨兵启动
    使用命令： docker exec -it redis81 redis-sentinel /usr/local/etc/redis/sentinel.conf
[root@localhost redis]# docker exec -it redis81 redis-sentinel /usr/local/etc/redis/sentinel.conf
17:X 17 Dec 07:04:27.655 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
17:X 17 Dec 07:04:27.655 # Redis version=4.0.14, bits=64, commit=00000000, modified=0, pid=17, just started
17:X 17 Dec 07:04:27.655 # Configuration loaded
                _._                                                  
           _.-``__ ''-._                                             
      _.-``    `.  `_.  ''-._           Redis 4.0.14 (00000000/0) 64 bit
  .-`` .-```.  ```\/    _.,_ ''-._                                   
 (    '      ,       .-`  | `,    )     Running in sentinel mode
 |`-._`-...-` __...-.``-._|'` _.-'|     Port: 26381
 |    `-._   `._    /     _.-'    |     PID: 17
  `-._    `-._  `-./  _.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |           http://redis.io        
  `-._    `-._`-.__.-'_.-'    _.-'                                   
 |`-._`-._    `-.__.-'    _.-'_.-'|                                  
 |    `-._`-._        _.-'_.-'    |                                  
  `-._    `-._`-.__.-'_.-'    _.-'                                   
      `-._    `-.__.-'    _.-'                                       
          `-._        _.-'                                           
              `-.__.-'                                               

17:X 17 Dec 07:04:27.656 # WARNING: The TCP backlog setting of 511 cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of 128.
17:X 17 Dec 07:04:27.658 # Sentinel ID is 9b9cfdd11bf140aff61e94ec28d54f11b38f7c71
17:X 17 Dec 07:04:27.658 # +monitor master masterRedis 192.168.0.159 6379 quorum 2
17:X 17 Dec 07:04:27.658 * +slave slave 192.168.0.159:6380 192.168.0.159 6380 @ masterRedis 192.168.0.159 6379
17:X 17 Dec 07:04:27.659 * +slave slave 192.168.0.159:6381 192.168.0.159 6381 @ masterRedis 192.168.0.159 6379
# 三个哨兵互相监控
17:X 17 Dec 07:04:27.682 * +sentinel sentinel ebde833c6f6ab79f2fd3311c965104a58080b5da 192.168.0.159 26380 @ masterRedis 192.168.0.159 6379 
17:X 17 Dec 07:04:29.373 * +sentinel sentinel 0a417519ee7d4f31a2fb2fe6c62e9affdbe8c1c4 192.168.0.159 26379 @ masterRedis 192.168.0.159 6379

做完这一步，Redis的一主二从三哨兵已经完成，这个时候可以测试一下，停掉主机，会以投票的方式在两个从机中选出新的主机来，重启启动原来的主机后，它会变为从机。

SpringBoot2.0整合

  • 在RedisAutoConfiguration中，导入了两个连接配置，我在使用的时候，redis没有密码并且关闭保护模式的情况下正常，但是加了密码就不能正常连接，所以我干脆将两个都排除，自己再重新添加jedis依赖，这样就一切正常了
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(RedisOperations.class)
@EnableConfigurationProperties(RedisProperties.class)
@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
public class RedisAutoConfiguration {
  • pom配置文件
 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-data-redis</artifactId>
     <exclusions>
         <exclusion>
             <groupId>redis.clients</groupId>
             <artifactId>jedis</artifactId>
         </exclusion>
         <exclusion>
             <groupId>io.lettuce</groupId>
             <artifactId>lettuce-core</artifactId>
         </exclusion>
     </exclusions>
 </dependency>
 
 <dependency>
     <groupId>redis.clients</groupId>
     <artifactId>jedis</artifactId>
 </dependency>
  • yml配置
spring:
  redis:
    sentinel:
      master: masterRedis       # master哨兵名称
      nodes:                    # 哨兵节点
        - 192.168.0.159:26379
        - 192.168.0.159:26380
        - 192.168.0.159:26381
    password: 123456    # 密码
    database: 0         # 数据库索引
    timeout: 5000ms     # 连接超时时间
    jedis:
      pool:                 # 可以查看api或者源码自己修改，这里只是例子
        max-active: 8       # 最大连接数
        max-wait: -1        # 最大阻塞等待时间(负数表示没限制)
        max-idle: 8         # 最大空闲
        min-idle: 0         # 最小空闲
  • 修改默认的序列化器，这样在客户端查看的时候，就是json字符串

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;

import java.nio.charset.Charset;

/**
 * @Description: 要实现对象的缓存，定义自己的序列化和反序列化器。比如使用阿里的fastjson来实现
 */
public class FastJsonRedisSerializer<T> implements RedisSerializer<T> {
    private static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
    private Class<T> clazz;

    public FastJsonRedisSerializer(Class<T> clazz) {
        super();
        this.clazz = clazz;
    }

    @Override
    public byte[] serialize(T t) throws SerializationException {
        if (null == t) {
            return new byte[0];
        }
        return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
    }

    @Override
    public T deserialize(byte[] bytes) throws SerializationException {
        if (null == bytes || bytes.length <= 0) {
            return null;
        }
        String str = new String(bytes, DEFAULT_CHARSET);
        return (T) JSON.parseObject(str, clazz);
    }
}
  • SpringBoot2.0的redis配置类

/**
 * @Description: Redis配置类
 */
@EnableCaching
@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        //使用fastjson序列化
        FastJsonRedisSerializer<Object> fastJsonRedisSerializer = new FastJsonRedisSerializer<>(Object.class);

        // value值的序列化采用fastJsonRedisSerializer
        template.setValueSerializer(fastJsonRedisSerializer);
        template.setHashValueSerializer(fastJsonRedisSerializer);

        // key的序列化采用StringRedisSerializer
        template.setKeySerializer(new StringRedisSerializer());
        template.setHashKeySerializer(new StringRedisSerializer());

        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }


    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        FastJsonRedisSerializer<Object> fastJsonRedisSerializer = new FastJsonRedisSerializer<>(Object.class);


        // 配置序列化（解决乱码的问题）,这里设置为10天过期
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofSeconds(60L * 60L * 24L * 10L))
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(fastJsonRedisSerializer))
                .disableCachingNullValues();

        // 添加信任，不然会报【com.alibaba.fastjson.JSONException: autoType is not support.】的错误
        ParserConfig.getGlobalInstance().addAccept("com.lgz.redis.");
        return RedisCacheManager.builder(factory)
                .cacheDefaults(config)
                .build();
    }

}
外面在下雷
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
基于Docker搭建Redis一主两从三哨兵的实现
09-09
在本文中，我们将深入探讨如何基于Docker搭建一个Redis集群，包括一主两从和三个哨兵节点。这种配置能够提供高可用性和数据复制，确保即使在主节点故障时，服务也能正常运行。 首先，我们需要了解Docker。Docker是...
docker-compose启动springboot项目-springboot+redis实战案例.zip
08-30
docker-compose启动springboot项目-springboot+redis实战案例。可以参考文章：https://blog.csdn.net/Ber_Bai/article/details/119995240
SpringBoot2.0整合Redis
Java_Chuck的博客
09-03 283
SpringBoot2.0整合Redis 相关知识 Redis 简介 Redis 是一个开源的，基于内存中的，高性能的数据存储系统，它可以用作数据库、缓存和消息中间件。 Redis 支持多种类型的数据结构，如：string、hashes、lists、sets、sortedSets等。 Redis 内置了复制(replication)、LUA脚本(Lua scripting)、事务(transactions)、磁盘持久化(persistence)、LRU驱动事件(LRU eviction)等功能。 Re
Springboot2.x整合Redis以及连接哨兵模式/集群模式
热门推荐
Coding Farmer的博客
04-09 3万+
依赖： <!--spirngboot版本为2.x--> <!-- 加载spring boot redis包,springboot2.0中直接使用jedis或者lettuce配置连接池，默认为lettuce连接池，这里使用jedis连接池 --> <!-- 加载spring boot redis包 --> <dependency> <gro...
Redis基础与使用SpringBoot整合Redis
boo程序员的博客
03-29 1383
Redis基础与使用SpringBoot整合Redis
Spring Boot（十三）：整合Redis哨兵，集群模式实践
半路雨歌
03-26 802
前面的两篇文章（Redis的持久化方案， 一文掌握Redis的三种集群方案）分别介绍了Redis的持久化与集群方案 —— 包括主从复制模式、哨兵模式、Cluster模式，其中主从复制模式由于不能自动做故障转移，当节点出现故障时需要人为干预，不满足生产环境的高可用需求，所以在生产环境一般使用哨兵模式或Cluster模式。那么在Spring Boot项目中，如何访问这两种模式的Redis集群，可能遇到...
【尚硅谷】2021最新版Redis详细教程（基于Redis 6.2.x版本）
Coder Xu
04-28 8084
文章目录一、前言二、NoSQL数据库简介1.技术发展1.1 Web1.0时代1.2 Web2.0时代1.3 解决CPU及内存压力1.4 解决IO压力2.NoSQL数据库2.1 NoSQL数据库概述2.2 NoSQL适用场景2.3 NoSQL不适用场景2.4 常见的NoSQL数据库3.行式存储数据库（大数据时代）3.1 行级数据库3.2 列级数据库4.图关系型数据库5.DB-Engines 数据库排名二、Redis概述及安装1.Redis概述2.应用场景2.1 配合关系型数据库做高速缓存2.2 多样的数据结构
狂神 redis笔记 docker
weixin_46769289的博客
04-21 322
如使用非root用户，则需要在命令前加上sudo命令，否则会报错 docker pull redis 下载redis sudo mkdir -p /mydata/redis/conf sudo touch /mydata/redis/conf/redis.conf 创建redis.conf 配置文件 [root@localhost ~]# docker run -p 6379:6379 --name redis -v /mydata/redis/data:/data -v /mydata/redis/con
Redis冲冲冲——redis数据类型及对应的数据结构
最新发布
2401_85598871的博客
06-24 1585
在Redis中，常见的八种数据类型包括字符串（String）、列表（List）、哈希（Hash）、集合（Set）、有序集合（Sorted Set）、位图（Bitmap）、HyperLogLog、地理位置（GEO）等。redis中数据类型分别介绍一下，以及对应的数据结构和应用场景？Redis冲冲冲——redis数据类型及对应的数据结构。
Redis零基础小白篇
立志成为架构师
05-19 802
注意：这里说的10大类型是value的数据类型，key的数据类型只有字符串单key，单valuestring是redis最基本的类型，一个key对应一个valuestring类型是二进制安全的，意思是redis的string可以包含任何数据，比如jpg图片或者序列化的对象。string类型是Redis最基本的数据类型，一个redis中字符串value最多可以是512M。
redis个人使用文档
m0_52080234的博客
09-11 474
并且如果redis提供主从集群，主从存在延迟，当主宕机时，从同步主中的锁数据，则会出现锁实现。直接返回的是Boolean，我们可以直接返回就行，但是这里可以看出，这是一个自动拆箱的过程，可能出现null。并且spring的事务在处理时使用的是批处理。2.逻辑过期：在热点key中添加一个逻辑过期字段，当查询逻辑时间过期则开启一个新的线程去处理重建缓存的处理，并且加锁，然后将旧数据返回。但是：上述的阻塞是基于jvm的，设置了上限，当达到上限后就会出现异常，其次，这个过程是基于内存的，一旦宕机，就会丢失数据。
使用docker搭建redis一主二从三哨兵集群
01-09
这是本人在工作中搭建集群的实践经验，当时遇到很多问题，困扰了我好久，最后查看了好多文章成功解决所有问题，主从集群，哨兵监听都成功。现在分享出来，我就以一台服务器模拟搭建三台服务器的集群。请务必阅读每一...
springboot + dockerclient +redis +esclient
01-10
标题 "springboot + dockerclient +redis +esclient" 描述了一种基于Spring Boot的应用场景，该应用集成了Docker客户端、Redis和Elasticsearch（ES）客户端，实现了数据计算、日志管理和任务队列功能。这里我们将...
docker安装redis 三主三从集群自动化脚本
06-21
docker安装redis 三主三从集群自动化脚本
Docker_命令
外面在下雷的专栏
11-24 1042
一、 帮助命令 1. docker版本 docker version 2. docker详细信息 docker info 3. docker帮助，列出所有的命令 docker --htlp 二、 镜像命令 1.docker images（列出本地主机上的镜像） [root@localhost ~]# docker images #镜像的仓库源 #镜像的标签 ...
Docker_Dockerfile中ONBUILD指令详解
外面在下雷的专栏
11-25 890
ONBUILD 格式：ONBUILD <其它指令> ONBUILD 它后面跟的是其它指令，比如 RUN, ADD 等，这些指令在当前镜像构建时并不会被执行，只有以当前镜像为基础镜像，去构建下一级镜像的时候才会被执行。 验证 首先写一个Dockerfile文件，里面写上ONBUILD指令 FROM centos:7 CMD /bin/bash ONBUILD RUN echo "--...
Docker_安装Nginx并运行
外面在下雷的专栏
11-26 571
首先从远程拉取Nginx [root@localhost dockerNginx]# docker pull nginx:1.17.6 1.17.6: Pulling from library/nginx 000eee12ec04: Already exists eb22865337de: Pull complete bee5d581ef8b: Pull complete Digest: s...
Docker_Dockerfile中保留字指令CMD和ENTRYPOINT区别
外面在下雷的专栏
11-25 347
CMD 指定一个容器启动时要运行的命令 Dockerfile中可以有多个CMD指令,但只有最后一个生效,CMD会被 docker run之后的参数替换 ENTRYPOINT 指定一个容器启动时要运行的命令 ENTRYPOINT的目的和CMD一样,都是在指定容器启动程序及参数 验证 验证中使用的命令为curl 首先编写Dockerfile文件，内容如下： FROM centos:7 RUN ...
docker安装redis一主两从
09-09
要在Docker中安装Redis一主两从的配置，可以按照以下步骤进行操作： 1. 首先，准备好Docker环境，并安装docker-compose工具。你可以使用以下命令在Linux上安装docker-compose 1.29.2版本： ``` curl -L https://get.daocloud.io/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m) > /usr/local/bin/docker-compose chmod +x /usr/local/bin/docker-compose ``` 2. 创建一个名为docker-compose.yml的文件，并在其中定义Redis的主从配置。你可以参考中提供的示例配置。 3. 在终端中切换到docker-compose.yml文件所在的目录，并使用以下命令启动Redis容器： ``` cd /path/to/docker-compose.yml docker-compose up -d ``` 4. 使用以下命令检查Redis容器是否正常启动： ``` docker ps ``` 5. 进入主Redis容器的内部： ``` docker exec -it redis-master bash ``` 6. 执行以下命令进入Redis命令行界面： ``` redis-cli ``` 7. 输入密码，根据步骤一中配置的密码进行认证。 8. 输入以下命令查看主从复制的状态： ``` info replication ``` 通过按照上述步骤进行操作，你将能够在Docker中成功安装Redis一主两从的配置。引用
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值