Docker 基础配置及搭建 redis 相关案例实战解析

最新推荐文章于 2023-03-30 22:26:41 发布
最新推荐文章于 2023-03-30 22:26:41 发布
阅读量146 收藏
点赞数
分类专栏： CGB课程学习总结练习 文章标签： docker redis linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BOTHOTHJX/article/details/120515890
版权
本文详细介绍了Docker的基础配置、镜像下载与管理、容器的启动与交互，以及如何配置镜像加速、设置容器启动命令和自动重启。还探讨了Docker的端口映射、虚拟网络，展示了如何构建自定义镜像，以及搭建Redis主从和哨兵集群。最后，通过实例展示了Docker中容器互联，以及MySQL和Tomcat的部署。
摘要由CSDN通过智能技术生成

Docker 基础配置和指令

Docker 基本配置

下载

下载 Docker 离线包

https://download.docker.com/linux/static/stable/x86_64/docker-20.10.6.tgz

在这里可以选择自己需要的版本进行下载

https://download.docker.com/linux/static/stable/

离线安装工具

https://github.com/Jrohy/docker-install/

安装

将前面下载的以下文件放入服务器的 /root/docker-install 文件夹下

文件列表:

- [docker-install]
	- docker-20.10.6.tgz
	- install.sh
	- docker.bash

执行安装

# 进入 docker-install 文件夹
cd docker-install

# 为 docker-install 添加执行权限
chmod +x install.sh

# 安装
./install.sh -f docker-20.10.6.tgz

镜像加速

由于国内网络问题，需要配置加速器来加速。修改配置文件 /etc/docker/daemon.json

下面命令直接生成文件 daemon.json

cat <<EOF > /etc/docker/daemon.json
{
  "registry-mirrors": [
    "https://docker.mirrors.ustc.edu.cn",
    "http://hub-mirror.c.163.com"
  ],
  "max-concurrent-downloads": 10,
  "log-driver": "json-file",
  "log-level": "warn",
  "log-opts": {
    "max-size": "10m",
    "max-file": "3"
    },
  "data-root": "/var/lib/docker"
}
EOF

之后重新启动服务

# 重新加载docker配置
sudo systemctl daemon-reload

#重启docker服务
sudo systemctl restart docker

确认安装结果

docker info

docker run hello-world

(图)

环境准备

  1. 克隆 docker-base: docker

  2. 设置 ip 地址

    ./ip-static
ip: 192.168.64.150
ifconfig

    (图)

  3. 上传文件到 /root/

    • DevOps课前资料/docker/docker-images.gz
    • DevOps课前资料/docker/tomcat 文件夹

  4. 导入镜像

    docker load -i docker-images.gz

docker images

    (图)

Docker 镜像

镜像

Docker 镜像是一组静态磁盘文件，可以任意下载、复制、分发。从镜像可以运行启动容器（Docker的虚拟计算机）。

下载镜像

从镜像仓库 https://hub.docker.com 下载镜像

# 下载 redis 镜像， 默认下载 redis:latest
docker pull redis:5.0.12

# 查看镜像列表
docker images

(图)

镜像的名称

镜像的名称由两部分组成：repository:tag，其中的 tag 一般用来表示版本，默认的 tag 是 latest，表示最近的版本。

镜像的名称相当于在镜像上贴的一个标签，在一个镜像上可以贴多个标签：

添加名称

# 镜像可以起另一个名称，名称格式： repository:tag
# 默认的 tag 是 latest
docker tag redis:5.0.12 tedu/redis:v5012

# 查看镜像
# 可以看到同一个镜像（ID相同）可以有多个名称
docker images | grep redis

(图)

删除

镜像的名称可以被删除

docker rmi redis:5.0.12

(图)

# 查看镜像
# 可以看到镜像名称已经被删除
docker images | grep redis

(图)

只有唯一的一个名称时会删除镜像

docker rmi tedu/redis:v5012

(图)

导出和导入镜像

导出镜像并压缩到压缩文件

# 把两个镜像 redis:latest 和 centos:8 导出，并压缩到 imgs.gz
docker save redis centos:8 | gzip > imgs.gz

(图)

导入镜像

docker load -i imgs.gz

(图)

Docker 从镜像运行启动容器

从镜像运行启动容器

从一个镜像可以运行启动一个或多个容器。

所谓容器，我们可以理解为是一个虚拟的计算机，其中运行着操作系统，操作系统中运行着我们部署的应用。

从 tomcat 镜像启动容器

docker run tomcat

(图)

容器启动后在容器中运行了 tomcat 应用。

这样启动会占用命令行，可以用 ctrl+c 退出 tomcat 应用。当容器中没有任何应用运行时，容器也会自动关闭退出。

查看容器

docker ps -a

(图)

容器启动后运行的命令

在镜像中指定的默认运行命令

docker history tomcat

(图)

tomcat 镜像中设置的 CMD 指令指定了容器启动后默认运行的命令： catalina.sh run。

ENTRYPOINT 和 CMD

这两项设置都是用来设置容器中运行的命令

只设置 CMD 来执行 ls -a -l：

CMD ["ls", "-a", "-l"]

只设置 CMD 是常见的用法。

用 ENTRYPOINT 和 CMD 两个一起设置来执行 ls -a -l：

ENTRYPOINT ["ls"]
CMD ["-a", "-l"]

两项一起设置时，会把两项设置的内容连接起来作为一个完整的命令。

启动容器时覆盖 ENTRYPOINT 和 CMD

覆盖 CMD：
以 tomcat 镜像为例，镜像中设置的默认命令是 catalina.sh run，可以任意指定命令覆盖这个默认命令，这里执行 ls -a -l 来测试：

docker run tomcat ls -a -l

覆盖 ENTRYPOINT：
--entrypoint：设置运行的命令，不许写在镜像名称 tomcat 的前面。注意，这里不能添加命令的参数；

镜像名称 tomcat 后面的内容会覆盖 CMD

docker run --entrypoint ls tomcat -a -l

后台运行

-d 代表后台运行

后台运行启动 tomcat 容器

docker run -d tomcat

(图)

查看后台运行的容器

# 只查看运行的容器
docker ps 

# 查看所有容器，包括已停止的容器
docker ps -a

# 仅列出容器的 id
docker ps -aq

查看容器的日志

可以使用容器的名称或 id，使用id是允许至少写三位，能与其他id区分即可

docker logs 4d3

进入容器，运行指定命令

docker exec 代表进入容器

绝大多数情况下一个容器中只运行一个应用。

容器中也允许运行启动多个应用，可以进入已经启动的容器， 在里面运行启动其他应用。

# 进入容器，运行指定的命令
docker exec -it 4d3 pwd
docker exec -it 4d3 touch f1.txt
docker exec -it 4d3 ls -l

# 启动 top 查看进程列表
# ctrl+c 可以退出top
docker exec -it 4d3 top

# 启动bash命令行
# exit 可以退出bash
docker exec -it 4d3 bash

命名和自动启动

--name：
每个启动的容器都可以指定一个名称，方便使用名称来操作容器。

--restart=always：
docker系统服务重启，或者操作系统重启，容器可以随系统自动启动。

# cat1容器可以随系统启动
docker run -d \
--name cat1 \
--restart=always \
tomcat

# cat2系统重启后默认是关闭状态，不会自动启动
docker run -d \
--name cat2 \
tomcat

# 查看容器
docker logs cat1

docker inspect cat1

# 重启docker系统服务
systemctl restart docker

# 查看容器，可以看到 cat1 自动重启了，而 cat2 处于关闭状态
docker ps -a

删除和复制

--rm：
有时候我们会临时使用一个容器之后这个容器就不再使用，添加 --rm 参数可以在容器停止时自动删除容器。

docker cp：
在容器和宿主机之间复制文件。

下面来看一个实际的例子，这个例子中我们从 tomcat 的一个临时容器复制配置文件 server.xml 到宿主机，然后在 server.xml 中修改端口号，把 8080 改成 80。

# 启动一个临时容器
docker run -d \
--rm \
--name tmp \
tomcat

# 把 tomcat 的 server.xml 复制到宿主机的 /root/ 目录下
docker cp tmp:/usr/local/tomcat/conf/server.xml  /root/

# 停止临时容器，会自动删除
docker stop tmp

docker ps -a

# 修改 server.xml 中的8080端口，改成80
vim server.xml

# -v 把宿主机路径挂载到容器的一个路径
# 挂载的路径可以是文件，也可以是文件夹
# 这里把修改过的 server.xml 挂载到新启动的容器中
docker run -d \
--name cat2 \
-v /root/server.xml:/usr/local/tomcat/conf/server.xml \
tomcat

# 查看启动日志，确认使用 80 端口启动
docker logs cat2

Docker 文件挂载

目录挂载

上面例子中用到 -v 参数，他可以将宿主机的路径挂载到容器指定路径，通过 -v 参数可以挂载文件、目录和数据卷。

挂载目录：

# 清理容器
docker rm -f $(docker ps -aq)

# -v 宿主机路径:容器路径
# 挂载的可以是文件，也可以是文件夹
# -v 可以在宿主机自动新建目录
docker run -d \
--name cat1 \
-v /usr/app:/opt/app \
tomcat

# 进入容器，在 /opt/app 下新建文件 f1.txt
docker exec -it cat1 bash

touch /opt/app/f1.txt

# 退出容器的命令行
exit

# 访问宿主机的文件夹
cd /usr/app
ls

数据卷挂载

# 新建数据卷
docker volume create my-vol

# 查看 my-vol 数据卷的信息
docker volume ls

# /var/lib/docker/volumes/my-vol/_data
docker inspect my-vol

# 挂载 my-vol 数据卷到容器的 /opt/app 路径
docker run -d \
--name cat2 \
-v my-vol:/opt/app \
tomcat

# 在容器的 /opt/app 下新建 f2.txt
docker exec -it cat2 bash

touch /opt/app/f2.txt

# 退出容器的命令行
exit

# 进入 my-vol 数据卷的真实目录，查看 f2.txt
cd /var/lib/docker/volumes/my-vol/_data

ls

Docker 虚拟网络

端口映射

客户端要访问宿主机内部运行的容器时，可以在宿主机打开一个端口，当客户单访问这个端口时，可以将访问转发到内部的容器。

-p 参数：
通过 -p 参数设置，可以在宿主机上选择一个端口映射到容器的端口。

# 清理容器
docker rm -f $(docker ps -aq)

# 端口映射
# -p 宿主机端口:容器端口
docker run -d \
--name cat1 \
-p 80:8080 \
tomcat

浏览器访问宿主机映射的端口 80
http://192.168.64.150

看到 tomcat 返回的 404 页，说明已经正常访问到 tomcat 容器

(图)

虚拟网络

容器键互联可以使用 Docker 的虚拟网络来连接。

在 Docker 中可以创建任意多个虚拟网络，容器之间可以通过虚拟网络互联互通。创建虚拟网络时宿主机也会连接到虚拟网络。

# 新建虚拟网络 my-net
docker network create my-net

# 查看虚拟网络
docker network ls

# 查看网络描述信息
docker inspect my-net

# 查看宿主机新建的虚拟网卡
ifconfig

# 清理容器
docker rm -f $(docker ps -aq)

# 新建两个容器 cat1 和 cat2
# 连接到虚拟网络 my-net
docker run -d --name cat1 \
--net my-net \
tomcat

docker run -d --name cat2 \
--net my-net \
tomcat

# 查看两个容器的虚拟网络ip
docker inspect cat1
docker inspect cat2

# 测试网络能否互联互通
# 从宿主机ping两个容器
ping 172.18.0.2
ping 172.18.0.3

# 进入cat1，ping宿主机和cat2
docker exec -it cat1 ping 172.18.0.1
docker exec -it cat1 ping 172.18.0.3
# 从容器访问另一个容器，可以使用容器名称访问，容器内部实现了解析环境
docker exec -it cat1 ping cat2

Docker 构建镜像

文件准备

之前在配置环境中已经将构建镜像所需要的文件已经传到 /root/ 根目录的 tomcat 文件夹中。

构建镜像

构建镜像类似于一台电脑的装机过程，添加文件、安装软件、配置环境…

例如构建一个 tomcat 10 镜像流程，就像在一台电脑上安装配置 tomcat 环境一样：

  • 选择基础镜像 centos:8（相当于一台新电脑，只有操作系统）

  • 添加 jdk 和 tomcat 文件

  • 设置环境变量

  • 设置开机启动 tomcat

下面来演示构建 tomcat 10 镜像的过程：

准备必要的文件

这里我们需要 JDK 和 tomcat10 的压缩文件，将它们放入一个文件夹（tomcat）中，这个文件夹不应该包含其他无关文件。

Dockerfile

Dockerfile 类似于一个批处理文件，用来设置镜像的构建流程

在上一步的 tomcat 文件夹下创建 Dockerfile 文件。

编辑 Dockerfile 文件

cd /root/tomcat

vim Dockerfile

在文件中添加以下内容

# 选择基础镜像
FROM centos:8

# jdk 和 tomcat 文件添加到镜像的 /usr/local/ 目录下
# ADD 指令会自动解压文件
ADD jdk-8u291-linux-x64.tar.gz apache-tomcat-10.0.6.tar.gz /usr/local/

# 切换到镜像中指定的文件夹下
WORKDIR /usr/local/apache-tomcat-10.0.6/

# 设置环境变量
ENV JAVA_HOME=/usr/local/jdk1.8.0_291 \
    CATALINA_HOME=/usr/local/apache-tomcat-10.0.6 \
    PATH=/usr/local/jdk1.8.0_291/bin:/usr/local/apache-tomcat-10.0.6/bin:$PATH

# EXPOSE 8080 只是一个声明，在运行时并不会因为这个声明应用就会开启这个端口的服务
# 这个声明有两个好处：
#   1.帮助镜像使用者理解这个镜像服务的端口，以方便配置映射
#   2.在运行时使用随机端口映射时，也就是 docker run -P时，会自动随机映射 EXPOSE 的端口
EXPOSE 8080

# 设置启动命令
CMD ["catalina.sh", "run"]

Dockerfile 指令参考手册：

https://docs.docker.com/engine/reference/builder/

Docker 案例 - 搭建 redis

防火墙

关闭防火墙，不关闭外界无法访问。

# 关闭防火墙
systemctl stop firewalld.service
# 禁止防火墙开机启动
systemctl disable firewalld.service

启动或重启

# 启动docker
systemctl start docker

# 重启docker
systemctl restart docker

Redis 启动

加载镜像

docker load < redis-docker-image.gz

启动容器

docker run -d --name redis7000 -p 7000:6379 redis

测试 Jedis

  1. 新建空工程 redis

  2. 新建 Maven 模块 redis-api，组名 cn.tedu，存放路径要在空工程下。

  3. pom.xml 添加 redis.clients 依赖。

    <dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.9.0</version>
</dependency>

  4. 创建 test.Test1 测试类

  5. 要完成测试 Jedis 需要完成以下几步：

    • List 保存服务地址列表 ( JedisShardInfo：分片服务器信息 )
    • 配置参数对象 JedisPoolConfig
    • 创建包含三个 redis 服务器地址的连接池（ShardedJedisPool）
    • 从连接池创建一个数据操作工具对象（ShardedJedis）
    • 循环添加 100 条数据

  6. 启动添加数据，并在虚拟机上查看三个 redis 服务的内容（keys *）

  7. 一致性哈希算法、哈希槽问题。

public class Test1 {
    public static void main(String[] args) {
        // 服务地址列表 (分片服务器信息)
        List<JedisShardInfo> list = new ArrayList<>();
        list.add(new JedisShardInfo("192.168.64.150",7000));
        list.add(new JedisShardInfo("192.168.64.150",7001));
        list.add(new JedisShardInfo("192.168.64.150",7002));
        // 配置参数对象
        JedisPoolConfig conf = new JedisPoolConfig();
        // 创建包含三个 redis 服务器地址的连接池
        ShardedJedisPool pool = new ShardedJedisPool(conf,list);
        // 从连接池创建一个数据操作工具对象
        ShardedJedis jedis = pool.getResource();
        // 添加 100 条数据
        for (int i = 0; i < 100; i++) {
            jedis.set("k"+i,"v"+i);
        }
    }
}

启动多个 redis 容器

启动三个redis容器,将端口分别映射到7000,7001和7002端口

# 如果7000已经启动,不必重复启动
docker run -d --name redis7000 -p 7000:6379 redis

docker run -d --name redis7001 -p 7001:6379 redis
docker run -d --name redis7002 -p 7002:6379 redis

# 查看容器
docker ps -a

(图)

启动测试

将之前的项目启动，向 redis 服务器中添加数据。

在容器中查看数据

分别进入三个redis容器,执行 keys *查看结果

docker exec -it redis7000 redis-cli
docker exec -it redis7001 redis-cli
docker exec -it redis7002 redis-cli

Docker 搭建 redis 主从 + 哨兵集群

主要可以用一主两从、多主多从来搭建。这里简化实践采用一主两从。

向主服务器添加的数据会自动复制到从服务器，若主服务器宕机，从服务器会临时顶上作为主服务器运作，这里需要 redis 哨兵来监控主服务器和从服务器的状态。

Redis 哨兵

redis主从复制结构中，当主服务器宕机，哨兵可以监控到服务宕机，在从服务器中选举产生一个新的主服务器。

搭建主从服务器

清理容器

docker rm -f $(docker ps -aq)

启动主服务器

# --net=host 容器直接使用宿主机的端口，不需要做端口映射
docker run -d --name redis6379 --net=host --restart=always redis 

# 进入容器，运行redis客户端
docker exec -it redis6379 redis-cli

# 查看集群信息，默认是主服务器
> info replication

启动两个从服务器

# 启动redis6380容器，作为 redis6379 的从服务器启动
# --port 和 --slaveof 是 redis-server 命令的参数
docker run -d --name redis6380 --net=host --restart=always redis \
redis-server --port 6380 --slaveof 192.168.64.150 6379

# 启动redis6381容器，作为 redis6379 的从服务器启动
docker run -d --name redis6381 --net=host --restart=always redis \
redis-server --port 6381 --slaveof 192.168.64.150 6379

# 查看三个 redis 服务的角色
docker exec -it redis6379 redis-cli
> info replication

docker exec -it redis6380 redis-cli -p 6380
> info replication

docker exec -it redis6381 redis-cli -p 6381
> info replication

启动哨兵

哨兵的配置文件

mkdir /opt/sentinel/
cd /opt/sentinel/

# 配置文件中的 "sentinel monitor mymaster 192.168.64.150 6379 2"
# 末尾的 2 表示两个哨兵投票确认主服务器宕机，哨兵才会认为主服务器宕机
cat <<EOF >5000.conf
port 5000
sentinel monitor mymaster 192.168.64.150 6379 2
sentinel down-after-milliseconds mymaster 5000
sentinel failover-timeout mymaster 60000
sentinel parallel-syncs mymaster 1
EOF

cat <<EOF >5001.conf
port 5001
sentinel monitor mymaster 192.168.64.150 6379 2
sentinel down-after-milliseconds mymaster 5000
sentinel failover-timeout mymaster 60000
sentinel parallel-syncs mymaster 1
EOF

cat <<EOF >5002.conf
port 5002
sentinel monitor mymaster 192.168.64.150 6379 2
sentinel down-after-milliseconds mymaster 5000
sentinel failover-timeout mymaster 60000
sentinel parallel-syncs mymaster 1
EOF

启动三个哨兵

docker run -d --name sentinel5000 \
-v /opt/sentinel/5000.conf:/sentinel.conf \
--restart=always \
--net=host \
redis redis-sentinel /sentinel.conf

docker run -d --name sentinel5001 \
-v /opt/sentinel/5001.conf:/sentinel.conf \
--restart=always \
--net=host \
redis redis-sentinel /sentinel.conf

docker run -d --name sentinel5002 \
-v /opt/sentinel/5002.conf:/sentinel.conf \
--restart=always \
--net=host \
redis redis-sentinel /sentinel.confdocker run -d --name sentinel5002 \
-v /opt/sentinel/5002.conf:/sentinel.conf \
--restart=always \
--net=host \
redis redis-sentinel /sentinel.conf

# 进入一个哨兵容器，查看它监控的主从服务器和其他哨兵
docker exec -it sentinel5000 redis-cli -p 5000
> sentinel master mymaster
> sentinel slaves mymaster
> sentinel sentinels mymaster

停止主服务器，测试主服务器重新选举

# 停止主服务器
docker stop redis6379
# 在哨兵日志中查看服务器切换日志： +switch-master mymaster 192.168.64.150 6379 192.168.64.150 6381
docker logs sentinel5000

# 查看 6380 和 6381 服务器的角色变化
docker exec -it redis6380 redis-cli -p 6380
> info replication

docker exec -it redis6381 redis-cli -p 6381
> info replication

重新启动6379，不会把6379切换成主服务器，而是作为从服务器

docker start redis6379

docker exec -it redis6379 redis-cli
> info replication

客户端 api 连接哨兵存取数据

回到 redis-api 工程

  1. 新建 Test2 测试类

  2. 首先获取哨兵服务器的列表，这里我们用 set 集合来存储 “ip+端口” 的字符串。

    我们这里要保存 5000、5001、5002 三个 sentinel 哨兵端口。

  3. 配置对象，创建 JedisPoolConfig 配置对象

  4. 创建哨兵连接池 （JedisSentinelPool），参数为之前设定的哨兵 master 名（mymaster），哨兵服务器列表（set），配置文件（conf）

  5. 创建数据操作工具（jedis），向 redis 数据库存入数据库测试

  6. 启动测试，返回查看 redis 里面是否都有新存入的数据，有即可。

public class Test2 {
    public static void main(String[] args) {
        // 哨兵服务器的列表
        Set<String> set = new HashSet<>();
        set.add("192.168.64.150:5000");
        set.add("192.168.64.150:5001");
        set.add("192.168.64.150:5002");

        // 配置对象
        JedisPoolConfig conf = new JedisPoolConfig();
        // 哨兵连接池
        JedisSentinelPool p = new JedisSentinelPool("mymaster", set, conf);
        // 数据操作工具
        Jedis jedis = p.getResource();
        jedis.set("kkkk","vvvv");
    }
}

Docker 搭建redis集群

每个主服务器带一个从服务器，我们这里设置三主三从。

准备配置文件

六个Redis实例的配置文件：
redis.conf

port 7000
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes

执行命令，创建文件，写入内容

mkdir /opt/redis
cd /opt/redis
mkdir 7000 7001 7002 7003 7004 7005

cat <<EOF >7000/redis.conf
port 7000
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes
EOF

cat <<EOF >7001/redis.conf
port 7001
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes
EOF

cat <<EOF >7002/redis.conf
port 7002
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes
EOF

cat <<EOF >7003/redis.conf
port 7003
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes
EOF

cat <<EOF >7004/redis.conf
port 7004
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes
EOF

cat <<EOF >7005/redis.conf
port 7005
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
appendonly yes
EOF

启动 redis

先启动6个redis实例

docker run -d --name redis7000 \
-v /opt/redis/7000/redis.conf:/redis.conf \
--net=host \
--restart=always \
redis \
redis-server /redis.conf

docker run -d --name redis7001 \
-v /opt/redis/7001/redis.conf:/redis.conf \
--net=host \
--restart=always \
redis \
redis-server /redis.conf

docker run -d --name redis7002 \
-v /opt/redis/7002/redis.conf:/redis.conf \
--net=host \
--restart=always \
redis \
redis-server /redis.conf

docker run -d --name redis7003 \
-v /opt/redis/7003/redis.conf:/redis.conf \
--net=host \
--restart=always \
redis \
redis-server /redis.conf

docker run -d --name redis7004 \
-v /opt/redis/7004/redis.conf:/redis.conf \
--net=host \
--restart=always \
redis \
redis-server /redis.conf

docker run -d --name redis7005 \
-v /opt/redis/7005/redis.conf:/redis.conf \
--net=host \
--restart=always \
redis \
redis-server /redis.conf

执行命令配置集群

# 进入容器执行集群配置命令

docker exec -it redis7000 \
redis-cli -p 7000 --cluster create \
192.168.64.150:7000 192.168.64.150:7001 \
192.168.64.150:7002 192.168.64.150:7003 \
192.168.64.150:7004 192.168.64.150:7005 \
--cluster-replicas 1

执行后会提示是否接受它给的方案（三主三从），上面会显示 M 和 S 所对应的端口号。

（图）

查看集群信息

docker exec -it redis7000 redis-cli -c -p 7000

cluster info

cluster nodes

存数据

docker exec -it redis7000 redis-cli -c -p 7000
# 7002
set a aaaaaaaaaaaaa
# 7000
set b bbbbbbbbbbb
# 7001
set c cccccccccccccccc

三台服务器轮流存储信息。

Spring 集成 API

  1. 在之间的项目中，创建一个 Spring 项目 redis-spring，依赖添加 Spring Data Redis，目录选择空目录下。

  2. 修改 pom.xml 文件，修改 Spring 版本为 2.3.2.RELEASE。

  3. 修改 application.yml，添加集群服务器配置

spring:
  redis:
    cluster:
      nodes:
        - 192.168.64.150:7000
        - 192.168.64.150:7001
        - 192.168.64.150:7002
        - 192.168.64.150:7003
        - 192.168.64.150:7004
        - 192.168.64.150:7005
  1. 在 test 测试类中添加测试代码：
    • 注入 Redis 连接工厂（RedisConnectionFactory）
    • 添加测试方法 test1，创建 Redis 集群连接（RedisClusterConnection）
    • 向 redis 集群添加数据
    • 启动
  2. 查看 redis 集群是否正确存入数据即可。

Docker 容器互联

准备工作

清理 之前的 redis 服务

docker rm -f $(docker ps -aq)

创建 docker 虚拟网络

docker network create dockernet --subnet=172.18.0.0/24 

docker network ls

ifconfig

MySQL

加载 mariadb 镜像

docker load < mariadb-docker-image.gz

创建数据卷

docker volume create mysql-data

启动 MariaDB 容器，并挂载数据卷

docker run -d --name mysql \
--net dockernet \
--restart=always \
--ip 172.18.0.11 \
-v mysql-data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=root \
-p 3306:3306 \
mariadb

docker ps -a

docker inspect mysql

进入容器，登录mysql测试

docker exec -it mysql bash

mysql -uroot -p

连接数据库，导入数据

启动 SQLyog，新建连接进入。

（图）

找到 课前资料/DevOps课前资料/docker/EasyMall/esaymall.sql 并导入。

（图）

Tomcat

在 /opt/ 目录准备 easymall 文件夹

（图）

将 课前资料/DevOps课前资料/docker/EasyMall/ROOT.war 传入 easymall 文件夹。

（图）

加载 tomcat 镜像

docker load < tomcat7-docker-image.gz

docker image ls

启动 tomcat 容器

docker run -d --name web --restart=always --net=dockernet --ip=172.18.0.12 -v /opt/easymall:/usr/local/tomcat/webapps -p 80:8080 tomcat

访问 http://192.168.64.150 EASYMall 商城。
(图)

0928 除了图以外完结

胖蝶的程序猿生活
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Docker（三）- 从镜像运行启动容器
wanght笔记
06-07 1万+
文章目录从镜像运行启动容器容器启动后运行的命令`ENTRYPOINT` 和 `CMD`启动容器时覆盖 `ENTRYPOINT` 和 `CMD``-d` 后台运行`docker exec` 进入容器，运行指定命令`--name` 和 `--restart=always``--rm` 和 `docker cp` 从镜像运行启动容器 从一个镜像可以运行启动一个或多个容器。 所谓容器，我们可以理解为是一个虚拟的计算机，其中运行着操作系统，操作系统中运行着我们部署的应用。 从 tomcat 镜像启动容器： do
docker镜像与容器的基本操作
weixin_63634809的博客
05-04 1031
文章目录一、docker基本命令1.1 查看镜像--docker images1.2 查看所有状态容器——docker ps -a1.3 docker —— run 指令1.4 查看docker版本命令——docker -v1.5 查看docker信息——docker info1.6 docker帮助命令文档——docker help二、docker 镜像操作2.1 搜索镜像（公共仓库）——docker search2.2 下载镜像——docker pull2.3 查看镜像列表——docker
构建一个Docker镜像
hhj13978064496的博客
06-22 514
springboot运用jar包成docker镜像 1.创建springboot项目 https://gitee.com/JiuLongBingShi/springboot-docker 2.通过maven install构建jar包 .\target目录下获取jar包:springboot-docker-1.0.1-SNAPSHOT.jar 3.创建一个Dockerfile文件 Dockerfile中的内容如下（注：Dockerfile没有后缀名） #--指定基础镜像 FROM .
docker 常用镜像和启动方式_2018_lcf
cbuy888的博客
12-12 1586
一、下面是我这台服务器上已安装的docker镜像 [root@bakserver ~]# docker images REPOSITORY TAG IMAGE ID CREATED SIZE tomcat latest ...
Docker镜像运行
热门推荐
benben的博客
08-27 5万+
有了镜像后，就可以以这个镜像为基础创建一个容器来运行。以上一篇文章Docker获取镜像中的benben-activities:test为例，docker run命令提供了Docker容器的创建到启动的功能，可以使用该命令来创建新容器。格式docker run [OPTIONS] IMAGE [COMMAND] [ARG...]，其中IMAGE可以用镜像名称，也可以使用镜像ID。例如：docker ...
docker-compose一键搭建Redis集群
06-12
1.先运行 createFile.py 输入宿主机IP地址，输入redis密码 2.按照控制台输出执行docker-compose up -d 启动命令 3.启动成功后执行加入集群命令即可
Docker快速搭建Redis集群的方法示例
09-08
主要介绍了Docker快速搭建Redis集群的方法示例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
使用docker搭建redis一主二从三哨兵集群
01-09
这是本人在工作中搭建集群的实践经验，当时遇到很多问题，困扰了我好久，最后查看了好多文章成功解决所有问题，主从集群，哨兵监听都成功。现在分享出来，我就以一台服务器模拟搭建三台服务器的集群。请务必阅读每一...
docker redis 3.2 配置文件
03-21
在这个场景中，我们有一个针对 Redis 3.2 版本的自定义配置文件 `redis.conf`，该文件是为在 Docker 环境下调试 Redis 实例而设计的。下面将详细解释配置文件中的关键设置和它们在 Docker 容器中的作用。 1. **端口...
docker-compose启动springboot项目-springboot+redis实战案例.zip
08-30
docker-compose启动springboot项目-springboot+redis实战案例。可以参考文章：https://blog.csdn.net/Ber_Bai/article/details/119995240
docker-20.10.6离线软件包-安装卸载脚本及docker服务脚本
05-16
docker-20.10.6官网离线软件包。安装、卸载docker的脚本，注册docker服务脚本
【docker快速上手学习笔记】05 深入浅出Dockerfile
冰冻三尺，非一日之寒
11-20 239
《docker快速上手学习笔记》专栏，帮你成为docker老手，6的飞起！
Docker基础教程
最新发布
我有故人折剑去，斩尽春风不曾归
03-30 263
(1）从VM与Docker框架中，直观上VM多了一层Guest OS，同时Hypervisor会对硬件资源进行虚拟化，docker直接使用硬件资源，所以资源利用率相对docker低。（2）openstack能够以10台/min的速度创建虚拟机，在docker面前就弱爆了，因为docker是利用宿主机的系统内核，所以可以做到在几秒钟之内创建大量容器，它们的启动速度是在数量级上的差距。Docker的每个隔离环境是进程级的，每个守护进程共用操作系统内核，在隔离环境中打包运行服务必要的依赖。因此每个容器启动非常快，
这54个docker命令！你必须懂！
架构师小秘圈
06-22 721
Docker是一个不断发展的系统，开发人员积极改进使用和性能。所以命令总是在变化。docker一些老的命令经常被弃用，并被新的或更有效的命令取代。您可以使用帮助选项检查D...
docker的基础命令操作
weixin_41029286的博客
05-24 232
拉取镜像： docker pull mysql 拉取其他版本的镜像： 进入docker hub:https://hub.docker.com/ 搜索要下载的镜像 然后点击tag 找到需要的版本下载 查看镜像 docker images docker image ls 把镜像制作成压缩文件 docker save [repository]:[tag] -o [输出的文件名] docker save mysql:8.0 -o mysql8.tar 多个镜像可以打成一个包 docker save m
docker常见镜像安装启动总结
02-07 3912
docker常见镜像安装总结
docker 拉取镜像、创建并启动容器
weixin_47271830的博客
08-23 9654
获取镜像 默认情况下，使用docker pull命令，会从官方的Docker Hub库中将镜像拉取到本地。 首先介绍这条命令的格式： docker pull [OPTIONS] <仓库名>：<标签> 其中， docker pull：Docker拉取镜像的命令关键词； [OPTIONS]：命令选项； 仓库名：仓库名的格式一般为<用户名>/<软件名>。对于Docker Hub，如果不指定用户名，则默认为library，即官方镜像； 标签：标签是区分镜像不同版本的一
Docker根据名称查询容器ID镜像ID并停止删除
紫眸的博客
06-28 2万+
根据容器名称查询容器ID并删除; 根据镜像名称查询容器ID并删除; 根据镜像名称查询镜像ID并删除; 还可以根据端口号、状态等字段筛选容器 # 第一种写法 docker stop `docker ps -a| grep test-project | awk '{print $1}' ` docker rm `docker ps -a| grep test-project | awk '{print $1}' ` # 第二种写法 docker stop `docker ps -aq
docker离线安装及配置
my_futrue的博客
06-13 2892
docker离线
Docker搭建SpringBoot下的Redis-Cluster实战教程
- 这篇文章为学习者提供了一个实践指导，帮助他们在Docker环境下搭建和配置Redis Cluster，为后续的分布式缓存管理和Spring Boot应用开发打下坚实的基础。实际操作时，需要根据项目需求调整配置细节，并确保安全性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值