目录
- Docker运行流程
- Docker的基本组成
- Docker安装
- 阿里云镜像加速
- Docker命令
- 容器信息命令
- 镜像命令
- docker images 查看本地的主机上的镜像
- docker search 搜索镜像
- docker pull 镜像下载
- docker rm镜像删除
- 容器命令
- docker run 新建并启动容器
- 退出容器
- 进入当前正在运行的容器
- 列出所有运行的容器
- 删除容器
- 启动和停止容器
- 其他重要命令
- 容器日志
- 容器进程
- 容器元数据
- 从容器内拷贝至主机
- 小结
- Docker可视化工具
- Docker镜像
- UnionFS(联合文件系统)
- Docker 镜像加载原理
- 分层理解
- commit 镜像
- 容器数据卷
- 添加数据卷
- 实战：安装Mysql
- 具名和匿名挂载
- 默认卷所在路径
- DockerFile
- 初识Dockerfile
- 数据卷容器
- 实现多台虚拟机数据共享
- 实现多个mysql数据共享
- Dockerfile构建过程
- Dockerfile基础知识
- dockerfile常用指令
- 实战测试-构建myCentos
- 实战测试-构建Tomcat
- 发布镜像
- 发布到DockerHub
- 发布到阿里云容器服务
- 小结
- Docker网络原理
- 网络原理概述
- 容器互联 --link
- 自定义网络配置
- 配置前环境准备
- 自定义配置
- 在自己配置的网络内启动容器
- 网络连通
- 实战：部署Redis集群
- SpringBoot微服务打包Docker镜像
- Docker Compose
- Docker Swarm
- CI\CD Jenkins
Docker运行流程
1、Java开发项目+运行环境
2、打包项目带上所有环境（redis、mysql、jdk...)
3、Docker仓库
4、下载发布的镜像
5、直接运行
Docker的基本组成
镜像（image）： 就相当于是一个 root 文件系统
容器（container）： 镜像（Image）和容器（Container）的关系，就像是面向对象程序设计中的类和实例一样，镜像是静态的定义，容器是镜像运行时的实体。容器可以被创建、启动、停止、删除、暂停等
仓库（repository）： 仓库可看成一个代码控制中心，用来保存镜像
Docker安装
配置环境
# 系统内核
[root@centos701 /]# uname -r
3.10.0-1127.el7.x86_64
#系统版本
[root@centos701 /]# cat /etc/os-release
NAME="CentOS Linux"
VERSION="7 (Core)"
ID="centos"
ID_LIKE="rhel fedora"
VERSION_ID="7"
PRETTY_NAME="CentOS Linux 7 (Core)"
ANSI_COLOR="0;31"
CPE_NAME="cpe:/o:centos:centos:7"
HOME_URL="https://www.centos.org/"
BUG_REPORT_URL="https://bugs.centos.org/"
CENTOS_MANTISBT_PROJECT="CentOS-7"
CENTOS_MANTISBT_PROJECT_VERSION="7"
REDHAT_SUPPORT_PRODUCT="centos"
REDHAT_SUPPORT_PRODUCT_VERSION="7"
安装：参考官方的帮助文档
docker安装文档
# 1.卸载旧版本
yum remove docker \
docker-client \
docker-client-latest \
docker-common \
docker-latest \
docker-latest-logrotate \
docker-logrotate \
docker-engine
# 2.需要的安装包
yum install -y yum-utils
# 3.设置镜像仓库
sudo yum-config-manager \
--add-repo \
http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
# 更新yum软件包索引
[root@centos701 /]# yum makecache fast
# 4.安装docker 社区版
yum install docker-ce docker-ce-cli containerd.io
# 5.启动docker
sudo systemctl start docker
# 6.检测Docker是否正确安装
docker version
# 7.启动hello world
sudo docker run hello-world
...
# 8.卸载docker依赖
$ sudo yum remove docker-ce docker-ce-cli containerd.io
# 9.删除资源
$ sudo rm -rf /var/lib/docker
阿里云镜像加速
- 登录阿里云-容器镜像服务
- 选择镜像加速器
-
配置使用
sudo mkdir -p /etc/docker sudo tee /etc/docker/daemon.json <<-'EOF' { "registry-mirrors": ["https://dj9u8a83.mirror.aliyuncs.com"] } EOF sudo systemctl daemon-reload sudo systemctl restart docker
Docker命令
容器信息命令
##查看docker容器版本
docker version
##查看docker容器信息
docker info
##查看docker容器帮助
docker --help
帮助文档地址
镜像命令
docker images 查看本地的主机上的镜像
# 列出本地images
docker images
# 可选项
-a, --all # 列出所有的镜像
--digests # 显示镜像摘要信息(DIGEST列)
--no-trunc # 显示镜像完整信息
-q, --quiet # 只显示ID
-aq # 显示所有的镜像ID
docker search 搜索镜像
# 搜索仓库MySQL镜像
docker search mysql
# --filter=stars=600：只显示 starts>=600 的镜像
docker search --filter=stars=600 mysql
docker pull 镜像下载
# 下载 mysql 官方最新镜像，相当于：docker pull mysql:latest(默认下载最新版)
docker pull mysql
# 指定版本下载
docker pull mysql:5.7
docker rm镜像删除
# 单个镜像删除，相当于：docker rmi mysql:latest
docker rm mysql
# 强制删除(针对基于镜像有运行的容器进程)
docker rm -f mysql
#多个镜像删除，不同镜像间以空格间隔
docker rm -f mysql tomcat nginx
#删除本地全部镜像
docker rmi -f $(docker images -q)
容器命令
# 下载centos镜像
docker pull centos
docker run 新建并启动容器
# 新建并启动容器，参数：
--name 为容器指定一个名称
-d 后台启动容器
-it 以交互模式运行容器；
-p 为容器重新分配一个伪输入终端
-p 主机端口:容器端口
-p ip:主机端口:容器端口
-p 容器端口
-P 随机指定端口
# 启动并进入容器
[root@centos701 ~]# docker run -it centos /bin/bash
[root@7cba555266ed /]# ls
bin etc lib lost+found mnt proc run srv tmp var
dev home lib64 media opt root sbin sys usr
[^注意 ]: Docker中必须要保持一个进程的运行，要不然整个容器启动后就会马上kill itself，这样当你使用docker ps 查看启动的容器时，就会发现你刚刚创建的那个容器并不在已启动的容器队列中,命令/bin/bash 就是在容器启动后运行bash
# 后台启动容器，参数：-d 已守护方式启动容器
# 启动nginx 配置主机端口映射
docker run -d --name nginx01 -p 3344:80 nginx
[root@centos701 ~]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
1e400bdaf5a8 nginx "/docker-entrypoint.…" 10 seconds ago Up 8 seconds 0.0.0.0:3344->80/tcp nginx01
a45b98f28f42 centos "/bin/bash" 26 minutes ago Up 26 minutes youthful_bose
# 本机自测端口
[root@centos701 ~]# curl localhost:3344
Welcome to nginx!
Welcome to nginx!
If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.
For online documentation and support please refer to
nginx.org.
Commercial support is available at
nginx.com.
Thank you for using nginx.
# 输入本机IP+端口即可在浏览器中对Nginx进行访问
http://192.168.2.140:3344/
退出容器
exit # 直接停止容器并退出
Ctrl + P + Q # 容器后台运行并退出
进入当前正在运行的容器
# 通常容器都是使用后台运行方式运行的，需要进入容器，修改配置
# 方式一: 进入容器后开启一个新的终端，可以在里面操作（常用）
docker exec -it 容器ID/NAMES /bin/bash
# 方式二: 进入容器正在执行的终端，不会启动新的进程
docker attach 容器ID
列出所有运行的容器
# 列出当前运行的容器信息
[root@centos701 ~]# docker ps
# 列出所有的容器信息: 当前+过去运行过的
[root@centos701 ~]# docker ps -a
# 查看正在运行的容器的ID
[root@centos701 ~]# docker ps -q
#显示运行容器总文件大小
[root@centos701 ~]# docker ps -s
# 显示最近创建容器
[root@centos701 ~]# docker ps -l
# 显示最近创建的3个容器
[root@centos701 ~]# docker ps -n 3
# 不截断输出
[root@centos701 ~]# docker ps --no-trunc
删除容器
# 停止一个运行中的容器
docker stop 容器ID/NAMES
# 杀掉一个运行中的容器
docker kill 容器ID/NAMES
# 删除一个已停止的容器
docker rm 容器ID/NAMES
# 删除一个运行中的容器
docker rm -f 容器ID/NAMES
# 删除多个容器
docker rm -f $(docker ps -a -q)
docker ps -a -q | xargs docker rm
# -l 移除容器间的网络连接，连接名为 db
docker rm -l db
# -v 删除容器，并删除容器挂载的数据卷
docker rm -v 容器ID/NAME
启动和停止容器
docker start 容器ID/NAMES # 启动容器
docker restart 容器ID/NAMES # 重启容器
docker stop 容器ID/NAMES # 停止当前正在运行的容器
docker kill 容器ID/NAMES # 强制停止当前正在运行的容器
其他重要命令
容器日志
# 查看redis容器日志，默认参数
docker logs redis
# 查看redis容器日志，参数：-f 跟踪日志输出；-t 显示时间戳；--tail 仅列出最新N条容器日志；
docker logs -f -t --tail=20 redis
# 查看容器redis从2019年05月21日后的最新10条日志。
docker logs --since="2019-05-21" --tail=10 redis
容器进程
# top支持 ps 命令参数，格式：docker top [OPTIONS] CONTAINER [ps OPTIONS]
# 列出容器中运行进程
docker top 容器ID
容器元数据
# 获取镜像的元信息
docker inspect 容器ID
# 获取正在运行的容器redis的 IP
docker inspect --format='{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' redis
从容器内拷贝至主机
# 将contos容器中的文件copy至本地路径
docker cp 容器ID:/[container_path] [local_path]
# 将主机文件copy至容器
docker cp [local_path] 容器ID:/[container_path]/
# 将主机文件copy至容器，目录重命名为[container_path]（注意与非重命名copy的区别）
docker cp [local_path] 容器ID:/[container_path]
小结
Docker可视化工具
- protainer
docker run -d -p 9000:9000 \
--restart=always \
-v /var/run/docker.sock:/var/run/docker.sock \
--name prtainer-test \
docker.io/portainer/portainer
http://192.168.2.140:9000/ 通过本地IP加端口号9000访问 密码8位：12341234
Docker镜像
镜像是一种轻量级、可执行的独立软件包，用来打包软件运行环境和基于运行环境的开发软件，它包含运行某个软件所需的所有内容，包括代码、运行时、库、环境变量和配置文件
UnionFS(联合文件系统)
Union文件系统(UnionFS) 是一种分层、轻量级并且高性能的文件系统，他支持对文件系统的修改作为一次提交来层层的叠加，
同时可以将不同目录挂载到同一个虚拟文件系统下（unite several directories into a single virtual filesystem）。Union文件系统是Docker镜像的基础。镜像可以通过分层来进行集成，基于基础镜像（没有父镜像），可以制作各种具体的应用镜像。
特性：一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统你那个，联合加载会把各层文件系统叠加起来，这样最终的文件系统会包含所有底层文件和目录。
Docker 镜像加载原理
docker 的镜像实际上由一层一层的文件系统组成，这种层级的文件系统UnionFS
bootfs ( boot file system ) 主要包含 bootloader 和kernel，bootloader 主要是引导加载 kernel，Linux刚启动时会加载bootfs文件系统，在Docker镜像的最底层是bootfs。这一层与我们典型的Linux/Unix系统是一样的，包含boot加载器和内核。当boot加载完成之后整个内核就存在内存中了，此时内存的使用权已由bootfs转交给内核，此时系统也会卸载bootfs
rootfs （root file system），在bootfs之上。包含的就是典型Linux系统中的 /dev ，/proc，/bin ，/etx 等标准的目录和文件。rootfs就是各种不同的操作系统发行版。比如Ubuntu，Centos等等。
对于一个精简的OS，rootfs可以很小，只需要包括最基本的命令、工具和程序库就可以了，因为底层直接用Host（宿主机）的kernel，自己只需要提供rootfs就行了，由此可见对于不同的Linux发行版，bootfs基本是一致的，rootfs会有差别，因此不同的发行版可以公用bootfs
分层理解
所有docker镜像都是起始于一个基础镜像，当镜像修改或增加内容时，就会在当前镜像层之上，创建新的镜像层容器数据卷
分层时有文件更新直接替换，基础镜像一样时直接拿过来复用
如redis下载时，第一层相同，直接复用，其他几层分层下载
afb6ec6fdc1c: Already exists
608641ee4c3f: Pull complete
668ab9e1f4bc: Pull complete
78a12698914e: Pull complete
d056855f4300: Pull complete
618fdf7d0dec: Pull complete
特点： docker镜像是只读的，容器启动时，一个新的可写层被加载到镜像顶部，这一层就是容器层，容器之下为镜像层
例如： tomcat镜像层+WEB项目容器层====>打包发布
commit 镜像
docker commit 提交容器为一个新副本
docker commit -m="提交的描述信息“ -a="作者" 容器id 目标镜像名
[root@centos701 ~]# docker commit -m="firt commit" -a="duckbb" f6782bec938a tomcat02
sha256:b318ebe32790ae04a980a54717a6f45ef6a1c6dbf186d9644f6707e3789eaf06
[root@centos701 ~]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
tomcat02 latest b318ebe32790 8 seconds ago 652MB
nginx latest 4392e5dad77d 4 days ago 132MB
portainer/portainer latest cd645f5a4769 5 days ago 79.1MB
mysql 5.7 a4fdfd462add 2 weeks ago 448MB
tomcat 9.0 1b6b1fe7261e 3 weeks ago 647MB
tomcat latest 1b6b1fe7261e 3 weeks ago 647MB
centos latest 470671670cac 4 months ago 237MB
hello-world latest bf756fb1ae65 5 months ago 13.3kB
容器数据卷
当我们在使用docker容器的时候，会产生一系列的数据文件，这些数据文件在我们关闭docker容器时是会消失的，但是其中产生的部分内容我们是希望能够把它给保存起来另作用途的，Docker将应用与运行环境打包成容器发布，我们希望在运行过程钟产生的部分数据是可以持久化的的，而且容器之间我们希望能够实现数据共享
docker容器数据卷可以看成使我们生活中常用的u盘，它存在于一个或多个的容器中，由docker挂载到容器，但不属于联合文件系统，Docker不会在容器删除时删除其挂载的数据卷
- 特点
- 数据卷可以在容器之间共享或重用数据
- 数据卷中的更改可以直接生效
- 数据卷中的更改不会包含在镜像的更新中
- 数据卷的生命周期一直持续到没有容器使用它为止
添加数据卷
方式一：直接使用命令进行挂载 -v
docker run -it -v /宿主机绝对路径目录: /容器内目录 镜像名
# 将主机的home下test文件夹同docker镜像centos中的home目录进行挂载
[root@centos701 home]# docker run -it -v /home/test:/home centos /bin/bash
# 通过元数据进行查看是否挂载成功
docker inspect 容器ID
# 其中返回的数据中 Mounts > Source和Destination 会显示挂载信息
方式二：通过DockerFile添加
实战：安装Mysql
# 获取镜像
docker pull mysql:5.7
# 启动mysql，需要配置密码
# 官方的命令
docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag
# 实现myslq配置文件和mysql数据的挂载，配置mysql密码
docker run -d -p 3306:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7
- 启动完成后 在win下mysql进行连接：即可访问
- 在win系统下新建数据库 db_docker_test 同时也会出现在centos 中 /home/mysql/data 中
[root@centos701 db_docker_test]# pwd
/home/mysql/data/db_docker_test
具名和匿名挂载
# 匿名挂载
- v 容器内的路径
docker run -d -P --name nginx02 -v /ect/nginx nginx
# 查看所有的Volume
docker volume ls
DRIVER VOLUME NAME (匿名)
local 7cba9dbf7d218ed32223f3601454e170ebccd62c05fbb35a72592b2fe98200ba
local 44211afca55e7f26514fb02f7084908666125f8359b993005f032365af062b90
# 具名挂载: -v 卷名:容器内路径
docker run -d -P --name nginx03 -v juming-nginx:/ect/nginx nginx
DRIVER VOLUME NAME
local 7cba9dbf7d218ed32223f3601454e170ebccd62c05fbb35a72592b2fe98200ba
local 44211afca55e7f26514fb02f7084908666125f8359b993005f032365af062b90
local juming-nginx
# 查看具名卷的信息---所有的卷所在在默认目录 Mountpoint
[root@centos701 home]# docker volume inspect juming-nginx
[
{
"CreatedAt": "2020-06-07T21:01:50+08:00",
"Driver": "local",
"Labels": null,
"Mountpoint": "/var/lib/docker/volumes/juming-nginx/_data",
"Name": "juming-nginx",
"Options": null,
"Scope": "local"
}
]
默认卷所在路径
/var/lib/docker/volumes/
# 挂载方式总结
-v 容器内路径 # 匿名挂载
-v 卷名:容器内路径 # 具名挂载
-v /宿主主机路径:容器路径 # 指定路径挂载
拓展
# 通过 -v 容器内路径:ro/rw 改变读写权限
# ro readonly 只读---只能通过宿主机操作，容器内部无法操作
# rw readwrite 可读可写
# 一旦设置了容器权限，容器对我们挂载出来的内容就有了限定
docker run -d -P --name nginx03 -v juming-nginx:/ect/nginx:ro nginx
docker run -d -P --name nginx03 -v juming-nginx:/ect/nginx:rw nginx
DockerFile
Dockerfile是一个Docker镜像的描述文件，我们可以理解成火箭发射的A、B、C、D…的步骤。Dockerfile其内部包含了一条条的指令，每一条指令构建一个新的镜像层，因此每一条指令的内容，就是描述该层应当如何构建，最终生成DockerImages镜像
初识Dockerfile
# 创建一个Dockerfile文件路径
[root@centos701 home]# mkdir docker-test-volume
# 创建一个Dockerfile文件
[root@centos701 docker-test-volume]# touch dockerfile
# 文件中的内容
FROM centos
VOLUME ["volume01","volume02"]
CMD echo "--------end--------"
CMD /bin/bash
# 生成镜像
[root@centos701 docker-test-volume]# docker build -f /home/docker-test-volume/dockerfile -t dockbb-centos:1.0 .
Sending build context to Docker daemon 2.048kB
Step 1/4 : FROM centos
---> 470671670cac
Step 2/4 : VOLUME ["volume01","volume02"]
---> Running in b493ccdd7ff8
Removing intermediate container b493ccdd7ff8
---> 0656198c3da6
Step 3/4 : CMD echo "--------end--------"
---> Running in 23ac87925ed9
Removing intermediate container 23ac87925ed9
---> f6647595f953
Step 4/4 : CMD /bin/bash
---> Running in ed45d3051994
Removing intermediate container ed45d3051994
---> b684b199402a
Successfully built b684b199402a
Successfully tagged dockbb-centos:1.0
# 查看镜像
[root@centos701 docker-test-volume]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
dockbb-centos 1.0 b684b199402a 3 minutes ago 237MB
# 启动镜像
[root@centos701 docker-test-volume]# docker run -it dockbb-centos:1.0 /bin/bash
# 查看容器内卷的路径
[root@59d13517539c /]# ls -l
total 0
lrwxrwxrwx. 1 root root 7 May 11 2019 bin -> usr/bin
drwxr-xr-x. 5 root root 360 Jun 8 02:12 dev
drwxr-xr-x. 1 root root 66 Jun 8 02:12 etc
drwxr-xr-x. 2 root root 6 May 11 2019 home
lrwxrwxrwx. 1 root root 7 May 11 2019 lib -> usr/lib
lrwxrwxrwx. 1 root root 9 May 11 2019 lib64 -> usr/lib64
drwx------. 2 root root 6 Jan 13 21:48 lost+found
drwxr-xr-x. 2 root root 6 May 11 2019 media
drwxr-xr-x. 2 root root 6 May 11 2019 mnt
drwxr-xr-x. 2 root root 6 May 11 2019 opt
dr-xr-xr-x. 135 root root 0 Jun 8 02:12 proc
dr-xr-x---. 2 root root 162 Jan 13 21:49 root
drwxr-xr-x. 11 root root 163 Jan 13 21:49 run
lrwxrwxrwx. 1 root root 8 May 11 2019 sbin -> usr/sbin
drwxr-xr-x. 2 root root 6 May 11 2019 srv
dr-xr-xr-x. 13 root root 0 Jun 7 06:21 sys
drwxrwxrwt. 7 root root 145 Jan 13 21:49 tmp
drwxr-xr-x. 12 root root 144 Jan 13 21:49 usr
drwxr-xr-x. 20 root root 262 Jan 13 21:49 var
drwxr-xr-x. 2 root root 6 Jun 8 02:12 volume01
drwxr-xr-x. 2 root root 6 Jun 8 02:12 volume02
# 查看宿主机卷挂载路径
[root@centos701 db_docker_test]# docker inspect 59d13517539c
# 外部路径Source
"Mounts": [
{
"Type": "volume",
"Name": "3831f6630d6abe9ca353bbe8de8b7aa16b198e61b9834135fd555233b872cc75",
"Source": "/var/lib/docker/volumes/3831f6630d6abe9ca353bbe8de8b7aa16b198e61b9834135fd555233b872cc75/_data",
"Destination": "volume01",
"Driver": "local",
"Mode": "",
"RW": true,
"Propagation": ""
},
{
"Type": "volume",
"Name": "233d54a1ba32fcb93fe5664f0acba7e642cc6d255a02233a1188ee142dba083e",
"Source": "/var/lib/docker/volumes/233d54a1ba32fcb93fe5664f0acba7e642cc6d255a02233a1188ee142dba083e/_data",
"Destination": "volume02",
"Driver": "local",
"Mode": "",
"RW": true,
"Propagation": ""
}
],
数据卷容器
我们经常需要多个容器之间进行数据共享我们需要用到命令 “--volumes-from”
实现多台虚拟机数据共享
核心思想：使第一个启动的容器变为数据卷容器，让其他的容器进行第一个容器进行挂载即可，被挂载的为父容器
# 启动容器
[root@centos701 /]# docker run -it --name docker01 dockbb-centos:1.0
# 查看数据卷
[root@86c9fe745884 /]# ls -l
total 0
lrwxrwxrwx. 1 root root 7 May 11 2019 bin -> usr/bin
drwxr-xr-x. 5 root root 360 Jun 8 02:36 dev
drwxr-xr-x. 1 root root 66 Jun 8 02:36 etc
drwxr-xr-x. 2 root root 6 May 11 2019 home
lrwxrwxrwx. 1 root root 7 May 11 2019 lib -> usr/lib
lrwxrwxrwx. 1 root root 9 May 11 2019 lib64 -> usr/lib64
drwx------. 2 root root 6 Jan 13 21:48 lost+found
drwxr-xr-x. 2 root root 6 May 11 2019 media
drwxr-xr-x. 2 root root 6 May 11 2019 mnt
drwxr-xr-x. 2 root root 6 May 11 2019 opt
dr-xr-xr-x. 116 root root 0 Jun 8 02:36 proc
dr-xr-x---. 2 root root 162 Jan 13 21:49 root
drwxr-xr-x. 11 root root 163 Jan 13 21:49 run
lrwxrwxrwx. 1 root root 8 May 11 2019 sbin -> usr/sbin
drwxr-xr-x. 2 root root 6 May 11 2019 srv
dr-xr-xr-x. 13 root root 0 Jun 7 06:21 sys
drwxrwxrwt. 7 root root 145 Jan 13 21:49 tmp
drwxr-xr-x. 12 root root 144 Jan 13 21:49 usr
drwxr-xr-x. 20 root root 262 Jan 13 21:49 var
drwxr-xr-x. 2 root root 6 Jun 8 02:36 volume01
drwxr-xr-x. 2 root root 6 Jun 8 02:36 volume02
# 启动第二个容器 并 同步第一个容器的数据卷
[root@centos701 /]# docker run -it --name docker02 --volumes-from docker01 dockbb-centos:1.0
# 查看数据卷 - 此时volume01和volume02同第一个容器的volume01和volume02同步
[root@ce6f8c6fa0ad /]# ls -l
total 0
lrwxrwxrwx. 1 root root 7 May 11 2019 bin -> usr/bin
drwxr-xr-x. 5 root root 360 Jun 8 02:39 dev
drwxr-xr-x. 1 root root 66 Jun 8 02:39 etc
drwxr-xr-x. 2 root root 6 May 11 2019 home
lrwxrwxrwx. 1 root root 7 May 11 2019 lib -> usr/lib
lrwxrwxrwx. 1 root root 9 May 11 2019 lib64 -> usr/lib64
drwx------. 2 root root 6 Jan 13 21:48 lost+found
drwxr-xr-x. 2 root root 6 May 11 2019 media
drwxr-xr-x. 2 root root 6 May 11 2019 mnt
drwxr-xr-x. 2 root root 6 May 11 2019 opt
dr-xr-xr-x. 117 root root 0 Jun 8 02:39 proc
dr-xr-x---. 2 root root 162 Jan 13 21:49 root
drwxr-xr-x. 11 root root 163 Jan 13 21:49 run
lrwxrwxrwx. 1 root root 8 May 11 2019 sbin -> usr/sbin
drwxr-xr-x. 2 root root 6 May 11 2019 srv
dr-xr-xr-x. 13 root root 0 Jun 7 06:21 sys
drwxrwxrwt. 7 root root 145 Jan 13 21:49 tmp
drwxr-xr-x. 12 root root 144 Jan 13 21:49 usr
drwxr-xr-x. 20 root root 262 Jan 13 21:49 var
drwxr-xr-x. 2 root root 6 Jun 8 02:36 volume01
drwxr-xr-x. 2 root root 6 Jun 8 02:36 volume02
# 在第二容器的volume02数据卷中创建文件，
[root@ce6f8c6fa0ad volume02]# touch test.txt
# 在第一容器的volume02数据卷查看
[root@86c9fe745884 /]# cd volume02
[root@86c9fe745884 volume02]# ls
test.txt
# 由于第一个容器在宿主机进行了数据卷挂载，那么也会进行数据同步
# 查看第一个容器的元信息，查看挂载路径
[root@centos701 _data]# docker inspect ce6f8c6fa0ad
[root@centos701 _data]# cd /var/lib/docker/volumes/076967d5ed3b8e5d311996a3103bfed8903da1af109239800fd088f433737b61/_data
[root@centos701 _data]# ls
test.txt
实现多个mysql数据共享
# 实现myslq配置文件和mysql数据的挂载，配置mysql密码
docker run -d -p 3306:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7
# mysql01 同步 mysql02 的数据
docker run -d -p 3306:3306 -e MYSQL_ROOT_PASSWORD=123456 --name mysql02 --volumes-from mysql01 mysql:5.7
Dockerfile构建过程
- 编写一个dockerfile文件
- docker build构建成为一个镜像
- docker run 运行镜像
- docker push发布镜像（DockerHub、阿里云镜像仓库）
Dockerfile基础知识
- 每一个保留关键字（指令）都必须是大写字母
- 执行从上到下顺序执行
- # 表示注释
- 每一个指令都会创建提交一个新的镜像层，并提交
dockerfile常用指令
FROM # 基础镜像
MAINTAINER # 镜像的维护者信息：姓名+邮箱
RUN # 镜像构建的时候需要运行的命令
ADD # 步骤：tomcat镜像，添加tomcat压缩包，会自动解压
WORKDIR # 镜像的工作目录
VOLUME # 挂载目录
EXPOSE # 保留端口配置
CMD # 指定容器启动时运行的命令，只有最后一条CMD指令会生效，之前的命令将被替换掉：
# CMD ["ls","-a"],如果启动编写CMD的镜像并追加命令 -l， 则 ls -a 会被 -l直接替换
ENTRYPOINT # 指定容器启动时运行的命令，可以追加命令：以CMD为例 追加命令 -l，最终命令为变为 ls -a -l
ONBUILD # 当构建一个被继承的Dockerfile，此时就会运行OBUILED指令
COPY # 类似ADD，将文件拷贝至镜像中
ENV # 构建时设置环境变量
实战测试-构建myCentos
DockerHub中99%的镜像都是从基础镜像FROM scratch，然后配置需要的软件
[root@centos701 home]# mkdir dockerfile
[root@centos701 dockerfile]# vi dockerfile-myCentos
# 编写Dockerfile的文件
FROM centos
MAINTAINER duckbb<[email protected]>
ENV MYPATH /usr/local
WORKDIR $MYPATH
RUN yum -y install yum
RUN yum -y install net-tools
EXPOSE 80
CMD echo $MYPATH
CMD echo "-----end-----"
CMD /bin/bash
[root@centos701 dockerfile]# docker build -f /home/dockerfile/dockerfile-myCentos -t mycentos:1.0 .
实战测试-构建Tomcat
- 首先上传jdk-8u251-linux-x64.tar.gz，apache-tomcat-9.0.35.tar.gz包
# 创建readme.txt文本
[root@centos701 app]# ll
总用量 201488
-rw-r--r--. 1 root root 11188192 6月 8 13:12 apache-tomcat-9.0.35.tar.gz
-rw-r--r--. 1 root root 195132576 6月 8 13:19 jdk-8u251-linux-x64.tar.gz
-rw-r--r--. 1 root root 0 6月 8 13:29 readme.txt
- 编写dockerfile文件，官方命令Dockerfile， build会自动寻找这个文件，就不需要 -f
FROM centos
MAINTAINER duckbb<[email protected]>
COPY readme.txt /usr/local/readme.txt
ADD jdk-8u251-linux-x64.tar.gz /usr/local
ADD apache-tomcat-9.0.35.tar.gz /usr/local
RUN yum -y install vim
ENV MYPATH /usr/local
WORKDIR $MYPATH
# 配置JDK和Tomcat的环境
ENV JAVA_HOME /usr/local/jdk1.8.0_251
ENV CLAAPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.35
ENV CATALINA_BASE /usr/local/apache-tomcat-9.0.35
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
EXPOSE 8080
CMD /usr/local/apache-tomcat-9.0.35/bin/startup.sh && tail -F /usr/lcoal/apache-tomcat-9.0.35/bin/logs/catalina.out
- 构建镜像：docker build
[root@centos701 app]# docker build -t mytomcat .
Sending build context to Docker daemon 206.3MB
Step 1/15 : FROM centos
---> 470671670cac
Step 2/15 : MAINTAINER duckbb<[email protected]>
---> Running in 3ec9c80d01bf
Removing intermediate container 3ec9c80d01bf
---> b3cc78786c6c
Step 3/15 : COPY readme.txt /usr/local/readme.txt
---> b6bf650ad46b
Step 4/15 : ADD jdk-8u251-linux-x64.tar.gz /usr/local
---> 5d7c81f64e23
Step 5/15 : ADD apache-tomcat-9.0.35.tar.gz /usr/local
---> 6c26fb96193f
Step 6/15 : RUN yum -y install vim
---> Running in af25667d0234
...
Step 15/15 : CMD /usr/local/apache-tomcat-9.0.35/bin/startup.sh && tail -F /usr/lcoal/apache-tomcat-9.0.35/bin/logs/catalina.out
---> Running in 02712520f11c
Removing intermediate container 02712520f11c
---> c2be9b3d98d2
Successfully built c2be9b3d98d2
Successfully tagged mytomcat:latest
- 启动镜像：对制作好的Tomcat镜像实现挂载
# 创建主机挂载文件夹
[root@centos701 home]# mkdir tomcat
# 启动并挂在webapps和logs文件夹
[root@centos701 tomcat]# docker run -d -p 3380:8080 --name my_tomcat01 -v /home/tomcat/webapps/test:/usr/local/apache-tomcat-9.0.35/webapps/test -v /home/tomcat/tomcat_logs:/usr/local/apache-tomcat-9.0.35/logs mytomcat
# 完成挂载
[root@centos701 tomcat]# ll
总用量 0
drwxr-xr-x. 2 root root 197 6月 8 14:06 tomcat_logs
drwxr-xr-x. 3 root root 18 6月 8 14:35 webapps
- 访问测试
[root@centos701 tomcat]# curl localhost:3380
- 在宿主机编写JSP文件，同步到Tomcat运行
[root@centos701 tomcat]# cd webapps/test/
[root@centos701 test]# mkdir WEB-INF
[root@centos701 test]# vi web.xml
[root@centos701 test]# vi index.jsp
<%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8"%>
hello world
Hello Docker
<%
System.out.println("------------test logs------------");
%>
- win浏览器中进行测试访问
http://192.168.2.140:3380/test/index.jsp
- 查看日志
[root@centos701 test]# cat /home/tomcat/tomcat_logs/cat catalina.out
...
08-Jun-2020 06:37:15.816 INFO [main] org.apache.coyote.AbstractProtocol.start Starting ProtocolHandler ["http-nio-8080"]
08-Jun-2020 06:37:15.850 INFO [main] org.apache.catalina.startup.Catalina.start Server startup in [522] milliseconds
------------test logs------------
------------test logs------------
发布镜像
发布到DockerHub
# 登录DockerHub
[root@centos701 tomcat_logs]# docker login -u duckbb
Password:
WARNING! Your password will be stored unencrypted in /root/.docker/config.json.
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store
Login Succeeded
# 查看镜像
[root@centos701 tomcat_logs]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
mytomcat latest c2be9b3d98d2 About an hour ago 718MB
...
# 更改镜像名称和版本：c2be9b3d98d2(IMAGE ID)
[root@centos701 tomcat_logs]# docker tag c2be9b3d98d2 mytomcat:1.0
# 推送镜像
[root@centos701 tomcat_logs]# docker push mytomcat:1.0
发布到阿里云容器服务
- 登录阿里云
- 进入容器镜像服务
- 命名空间----->创建命名空间
- 镜像仓库----->创建镜像仓库----->选择本地仓库
# 登录阿里云
[root@centos701 tomcat_logs]# docker login --username=jasonyanc registry.cn-shenzhen.aliyuncs.com
Password:
WARNING! Your password will be stored unencrypted in /root/.docker/config.json.
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store
Login Succeeded
# c2be9b3d98d2为推送镜像的ID
[root@centos701 tomcat_logs]# docker tag c2be9b3d98d2 registry.cn-shenzhen.aliyuncs.com/duckbb-jason/duckbb:1.0
# 推送
[root@centos701 tomcat_logs]# docker push registry.cn-shenzhen.aliyuncs.com/duckbb-jason/duckbb:1.0
# 拉取镜像
$ sudo docker pull registry.cn-shenzhen.aliyuncs.com/duckbb-jason/duckbb:[镜像版本号]
- 在容器镜像服务中查看推送的镜像
小结
Docker网络原理
网络原理概述
参考此文
容器互联 --link
容器间的互联默认是通过主机进行桥接 (相当于主机是一个路由器，连接该路由器的容器可以进行查表，查找想要访问的ip ，然后进行访问) 方式进行访问的
实现容器互联-通过服务名进行连接
这种方法麻烦不常用
# 启动Tomcat01
[root@centos701 tomcat]# docker run -d -P --name=tomcat01 tomcat
# 启动Tomcat02并--linkTomcat01
[root@centos701 tomcat]# docker run -d -P --name=tomcat02 --link tomcat01 tomcat
# 进入Tomcat02 ping Tomcat01
root@38d3052fe9aa:/usr/local# ping tomcat01
PING tomcat01 (172.17.0.2) 56(84) bytes of data.
64 bytes from tomcat01 (172.17.0.2): icmp_seq=1 ttl=64 time=19.1 ms
64 bytes from tomcat01 (172.17.0.2): icmp_seq=2 ttl=64 time=0.046 ms
64 bytes from tomcat01 (172.17.0.2): icmp_seq=3 ttl=64 time=0.044 ms
64 bytes from tomcat01 (172.17.0.2): icmp_seq=4 ttl=64 time=0.117 ms
# 查看tomcat02的hosts配置文件,发现其中包含tomcat01的ip映射地址
root@38d3052fe9aa:/usr/local# cat /etc/hosts
127.0.0.1 localhost
::1 localhost ip6-localhost ip6-loopback
fe00::0 ip6-localnet
ff00::0 ip6-mcastprefix
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters
172.17.0.2 tomcat01 7fda594270bd
172.17.0.3 38d3052fe9aa
# 此时tomcat01并没有--link tomcat02，因此tomcat01 无法 通过容器名进行连接
# 需要关闭tomcat01 并进行 --link
[root@centos701 tomcat]# docker exec -it tomcat01 ip addr
1: lo: mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
inet 127.0.0.1/8 scope host lo
valid_lft forever preferred_lft forever
46: eth0@if47: mtu 1500 qdisc noqueue state UP group default
link/ether 02:42:ac:11:00:02 brd ff:ff:ff:ff:ff:ff link-netnsid 0
inet 172.17.0.2/16 brd 172.17.255.255 scope global eth0
valid_lft forever preferred_lft forever
[root@centos701 tomcat]# docker exec -it tomcat01 cat /etc/hosts
127.0.0.1 localhost
::1 localhost ip6-localhost ip6-loopback
fe00::0 ip6-localnet
ff00::0 ip6-mcastprefix
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters
172.17.0.2 7fda594270bd
自定义网络配置
# 查看所有docker网络
[root@centos701 tomcat]# docker network ls
NETWORK ID NAME DRIVER SCOPE
367d45995479 bridge bridge local
e51dd388364c host host local
2596d1a85fa9 none null local
| 网络模式 | 简介 |
|---|---|
| Host | 容器将不会虚拟出自己的网卡，配置自己的IP等，而是使用宿主机的IP和端口 |
| Bridge | 此模式会为每一个容器分配、设置IP等，并将容器连接到一个docker0虚拟网桥，通过docker0网桥以及Iptables nat表配置与宿主机通信 |
| None | 该模式关闭了容器的网络功能 |
| Container | 创建的容器不会创建自己的网卡，配置自己的IP，而是和一个指定的容器共享IP、端口范围 |
配置前环境准备
# 关闭所有的容器，并查看网卡
[root@centos701 tomcat]# ip addr
1: lo: mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
inet 127.0.0.1/8 scope host lo
valid_lft forever preferred_lft forever
inet6 ::1/128 scope host
valid_lft forever preferred_lft forever
2: ens33: mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
link/ether 00:0c:29:f8:f7:f2 brd ff:ff:ff:ff:ff:ff
inet 192.168.2.140/24 brd 192.168.2.255 scope global noprefixroute ens33
valid_lft forever preferred_lft forever
inet6 fe80::299d:90bc:d3b1:e33e/64 scope link noprefixroute
valid_lft forever preferred_lft forever
3: docker0: mtu 1500 qdisc noqueue state DOWN group default
link/ether 02:42:b1:2a:d1:03 brd ff:ff:ff:ff:ff:ff
inet 172.17.0.1/16 brd 172.17.255.255 scope global docker0
valid_lft forever preferred_lft forever
inet6 fe80::42:b1ff:fe2a:d103/64 scope link
valid_lft forever preferred_lft forever
自定义配置
# 启动容器会默认使用 --net bridge 进行启动，bridge 网络代表docker0所有Docker安装中存在的网络
docker run -d -P --name tomcat01 tomcat
docker run -d -P --name tomcat01 --net bridge tomcat # 自动添加
# 自定义：
# --driver 网络模式
# -subnet 子网
# --gateway 网关
[root@centos701 tomcat]# docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.2.1 mynet
b06f20ded8067eb87fd9f65a28fefb3d4b59f4faa058cbde183a4d4b8c3bd3ca
[root@centos701 tomcat]# docker network ls
NETWORK ID NAME DRIVER SCOPE
367d45995479 bridge bridge local
e51dd388364c host host local
b06f20ded806 mynet bridge local
2596d1a85fa9 none
# 查看mynet网络配置信息
[root@centos701 tomcat]# docker network inspect mynet
[
{
"Name": "mynet",
"Id": "b06f20ded8067eb87fd9f65a28fefb3d4b59f4faa058cbde183a4d4b8c3bd3ca",
"Created": "2020-06-08T17:57:04.573181515+08:00",
"Scope": "local",
"Driver": "bridge",
"EnableIPv6": false,
"IPAM": {
"Driver": "default",
"Options": {},
"Config": [
{
"Subnet": "192.168.0.0/16",
"Gateway": "192.168.2.1"
}
]
},
"Internal": false,
"Attachable": false,
"Ingress": false,
"ConfigFrom": {
"Network": ""
},
"ConfigOnly": false,
"Containers": {},
"Options": {},
"Labels": {}
}
]
在自己配置的网络内启动容器
推荐使用：这样容器之间进行访问就会更加方便，尤其是对集 群非常适合
# 基于自己的配置的网络启动容器
[root@centos701 tomcat]# docker run -d -P --name tomcat-net-01 --net mynet tomcat
828d43498020edd97e1e4f54968d6a2e4766ad476d1afb914edb7530524c6bec
[root@centos701 tomcat]# docker run -d -P --name tomcat-net-02 --net mynet tomcat
5b8472ed30373479f7d91a43dc061280114aa1897f537eb60d849bd06c9b084e
# tomcat-net-01 ping tomcat-net-02成功 ，反之也可以ping通
[root@centos701 tomcat]# docker exec -it tomcat-net-01 /bin/bash
root@828d43498020:/usr/local/tomcat# ping tomcat-net-02
PING tomcat-net-02 (192.168.0.2) 56(84) bytes of data.
64 bytes from tomcat-net-02.mynet (192.168.0.2): icmp_seq=1 ttl=64 time=0.076 ms
64 bytes from tomcat-net-02.mynet (192.168.0.2): icmp_seq=2 ttl=64 time=0.045 ms
64 bytes from tomcat-net-02.mynet (192.168.0.2): icmp_seq=3 ttl=64 time=0.117 ms
64 bytes from tomcat-net-02.mynet (192.168.0.2): icmp_seq=4 ttl=64 time=0.101 ms
网络连通
上一节中 tomcat-net-01和tomcat-net-02 都是基于 自定义mynet网络进行启动的，那就和基于docker0默认网络配置启动的 tomcat01和tomcat02 隔离了
本节实现 不同网络之间容器的连通
- 基于docker0网络启动tomcat01和tomcat02
# 基于docker0网络启动tomcat01和tomcat02
[root@centos701 tomcat]# docker start tomcat01
tomcat01
[root@centos701 tomcat]# docker start tomcat02
tomcat02
[root@centos701 tomcat]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
5b8472ed3037 tomcat "catalina.sh run" 12 minutes ago Up 12 minutes 0.0.0.0:32775->8080/tcp tomcat-net-02
828d43498020 tomcat "catalina.sh run" 21 minutes ago Up 21 minutes 0.0.0.0:32774->8080/tcp tomcat-net-01
38d3052fe9aa tomcat "catalina.sh run" 58 minutes ago Up About a minute 0.0.0.0:32777->8080/tcp tomcat02
7fda594270bd tomcat "catalina.sh run" 58 minutes ago Up About a minute 0.0.0.0:32776->8080/tcp tomcat01
- 在不同网络中，使用容器名称进行 ping 接
# 用tomcat01 ping tomcat-net-01 --net 会连接失败
[root@centos701 tomcat]# docker exec -it tomcat01 ping tomcat-net-01
ping: tomcat-net-01: Name or service not known
- 使用mynet网络连接docker网络中的容器
# 使用mynet网络连接docker0网络上的容器（tomcat01和tomcat02）
[root@centos701 tomcat]# docker network connect mynet tomcat01
# 查看mynet网络配置，会发现tomcat01已经被加入该网络
[root@centos701 tomcat]# docker inspect mynet
[
{
"Name": "mynet",
"Id": "b06f20ded8067eb87fd9f65a28fefb3d4b59f4faa058cbde183a4d4b8c3bd3ca",
"Created": "2020-06-08T17:57:04.573181515+08:00",
"Scope": "local",
"Driver": "bridge",
"EnableIPv6": false,
"IPAM": {
"Driver": "default",
"Options": {},
"Config": [
{
"Subnet": "192.168.0.0/16",
"Gateway": "192.168.2.1"
}
]
},
"Internal": false,
"Attachable": false,
"Ingress": false,
"ConfigFrom": {
"Network": ""
},
"ConfigOnly": false,
"Containers": {
"5b8472ed30373479f7d91a43dc061280114aa1897f537eb60d849bd06c9b084e": {
"Name": "tomcat-net-02",
"EndpointID": "04362f0b7d27eda49100e24f34d7fd69a31867409f9d99dd7d310ddde35c2807",
"MacAddress": "02:42:c0:a8:00:02",
"IPv4Address": "192.168.0.2/16",
"IPv6Address": ""
},
"7fda594270bd8c5a4ca07920b296b5994575539e854c688921e15f28bc98950d": {
"Name": "tomcat01",
"EndpointID": "d38a5ddf12d7d6b2587b843361601034026702385ec0ba1724d42b0a800f7a12",
"MacAddress": "02:42:c0:a8:00:03",
"IPv4Address": "192.168.0.3/16",
"IPv6Address": ""
},
"828d43498020edd97e1e4f54968d6a2e4766ad476d1afb914edb7530524c6bec": {
"Name": "tomcat-net-01",
"EndpointID": "9d36699613b47e15bcb2bf1fc7cca74732e9b94df15dbdca65b4533027fd4e06",
"MacAddress": "02:42:c0:a8:00:01",
"IPv4Address": "192.168.0.1/16",
"IPv6Address": ""
}
},
"Options": {},
"Labels": {}
}
]
- 再次检查ping接
# 检查是否可以 ping 成功
[root@centos701 tomcat]# docker exec -it tomcat01 ping tomcat-net-01
PING tomcat-net-01 (192.168.0.1) 56(84) bytes of data.
64 bytes from tomcat-net-01.mynet (192.168.0.1): icmp_seq=1 ttl=64 time=0.082 ms
64 bytes from tomcat-net-01.mynet (192.168.0.1): icmp_seq=2 ttl=64 time=0.053 ms
64 bytes from tomcat-net-01.mynet (192.168.0.1): icmp_seq=3 ttl=64 time=0.044 ms
64 bytes from tomcat-net-01.mynet (192.168.0.1): icmp_seq=4 ttl=64 time=0.061 ms
64 bytes from tomcat-net-01.mynet (192.168.0.1): icmp_seq=5 ttl=64 time=0.055 ms
64 bytes from tomcat-net-01.mynet (192.168.0.1): icmp_seq=6 ttl=64 time=0.049 ms
64 bytes from tomcat-net-01.mynet (192.168.0.1): icmp_seq=7 ttl=64 time=0.042 ms
实战：部署Redis集群
创建3个master 和 3个slave
# 创建网卡
docker network create redis --subnet 172.38.0.0/16
创建配置脚本
# 创建六个Redis配置
for port in $(seq 1 6); \
do \
mkdir -p /mydata/redis/node-${port}/conf
touch /mydata/redis/node-${port}/conf/redis.conf
cat << EOF >/mydata/redis/node-${port}/conf/redis.conf
port 6379
bind 0.0.0.0
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout 5000
cluster-announce-ip 172.38.0.1${port}
cluster-announce-port 6379
cluster-announce-bus-port 16379
appendonly yes
EOF
done
# 创建好之后，可以进入/mydata/redis中查看配置信息
创建redis集群容器,并启动
# 启动redis-1
docker run -p 6371:6379 -p 16371:16379 --name redis-1 -v /mydata/redis/node-1/data:/data -v /mydata/redis/node-1/conf/redis.conf:/etc/redis/redis.conf -d --net redis --ip 172.38.0.11 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
# 启动 redis-2
docker run -p 6372:6379 -p 16372:16379 --name redis-2 -v /mydata/redis/node-2/data:/data -v /mydata/redis/node-2/conf/redis.conf:/etc/redis/redis.conf -d --net redis --ip 172.38.0.12 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
# 启动 redis-3
docker run -p 6373:6379 -p 16373:16379 --name redis-3 -v /mydata/redis/node-3/data:/data -v /mydata/redis/node-3/conf/redis.conf:/etc/redis/redis.conf -d --net redis --ip 172.38.0.13 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
# 启动 redis-4
docker run -p 6374:6379 -p 16374:16379 --name redis-4 -v /mydata/redis/node-4/data:/data -v /mydata/redis/node-4/conf/redis.conf:/etc/redis/redis.conf -d --net redis --ip 172.38.0.14 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
# 启动 redis-5
docker run -p 6375:6379 -p 16375:16379 --name redis-5 -v /mydata/redis/node-5/data:/data -v /mydata/redis/node-5/conf/redis.conf:/etc/redis/redis.conf -d --net redis --ip 172.38.0.15 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
# 启动 redis-6
docker run -p 6376:6379 -p 16376:16379 --name redis-6 -v /mydata/redis/node-6/data:/data -v /mydata/redis/node-6/conf/redis.conf:/etc/redis/redis.conf -d --net redis --ip 172.38.0.16 redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
配置集群
# 启动好之后进入容器配置集群
$ docker exec -it redis-1 /bin/sh
redis-cli --cluster create 172.38.0.11:6379 172.38.0.12:6379 172.38.0.13:6379 172.38.0.14:6379 172.38.0.15:6379 172.38.0.16:6379 --cluster-replicas 1
# 集群客户端启动
$ redis-cli -c
127.0.0.1:6379> cluster info
cluster_state:ok
cluster_slots_assigned:16384
cluster_slots_ok:16384
cluster_slots_pfail:0
cluster_slots_fail:0
cluster_known_nodes:6
cluster_size:3
cluster_current_epoch:6
cluster_my_epoch:1
cluster_stats_messages_ping_sent:632
cluster_stats_messages_pong_sent:648
cluster_stats_messages_sent:1280
cluster_stats_messages_ping_received:643
cluster_stats_messages_pong_received:632
cluster_stats_messages_meet_received:5
cluster_stats_messages_received:1280
# 节点信息
127.0.0.1:6379> cluster nodes
7bd9860399c5afca1a976fa0f7b3b29c103846b3 172.38.0.15:6379@16379 slave 59232f8bcba54a2aa1bb4ad0d7c2340a09094548 0 1591619949602 5 connected
87ba164120a6a8f32dda413866e892386fc0cd13 172.38.0.12:6379@16379 master - 0 1591619948000 2 connected 5461-10922
ef2c63ed119119e9f2079d093fbc1f465092466a 172.38.0.14:6379@16379 slave c00b25cbe0d35a65c4a6e245a0fc0a7041e7fee7 0 1591619949501 4 connected
1fda7ca221e8ee510b1f49e02201018764523cb9 172.38.0.16:6379@16379 slave 87ba164120a6a8f32dda413866e892386fc0cd13 0 1591619948000 6 connected
c00b25cbe0d35a65c4a6e245a0fc0a7041e7fee7 172.38.0.13:6379@16379 master - 0 1591619949000 3 connected 10923-16383
59232f8bcba54a2aa1bb4ad0d7c2340a09094548 172.38.0.11:6379@16379 myself,master - 0 1591619948000 1 connected 0-5460
# 设置数据
127.0.0.1:6379> set name zhangsan
-> Redirected to slot [5798] located at 172.38.0.12:6379
SpringBoot微服务打包Docker镜像
创建SpringBoot项目
// 创建一个控制器实现跳转
package com.jason.demo.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* @authot jason_yan
* @date 2020/6/8-20:54
*/
@RestController
public class GanController {
@RequestMapping("/gan")
public String gan(){
return "淦";
}
}
访问地址：http://localhost:8080/gan 即可显示 “淦”
maven打包：mvn clean package
在idea中安装Docker插件：settings---->plugins----->下载docker (编写Dockerfile文件会高亮)
在根目录创建Dockerfile
FROM java:8
COPY .*.jar /app.jar
# 提示端口
CMD ["--server.port=8080"]
EXPOSE 8080
# 执行启动命令
ENTRYPOINT ["java", "-jar", "/app.jar"]
在虚拟机中创建/home/idea目录
[root@centos701 app]# mkdir /home/idea
将jar包 和 Dockerfile文件上传至虚拟机/home/idea中
[root@centos701 idea]# ll
总用量 16084
-rw-r--r--. 1 root root 16462350 6月 8 21:02 demo-0.0.1-SNAPSHOT.jar
-rw-r--r--. 1 root root 167 6月 8 21:18 Dockerfile
构建镜像
[root@centos701 idea]# docker build -t gan .
# 查看镜像
[root@centos701 idea]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
gan latest 2d778fd15ac2 11 hours ago 660MB
tomcat latest 1b6b1fe7261e 3 weeks ago 647MB
redis 5.0.9-alpine3.11 3661c84ee9d0 6 weeks ago 29.8MB
java 8 d23bdf5b1b1b 3 years ago 643MB
运行镜像
[root@centos701 idea]# docker run -d -p 8080:8080 --name springboot_pro01 gan
04e9f1ff840cc4c0d3220684782242c872449ae6138d65f30e90c218684bc434
# 测试接口
[root@centos701 idea]# curl localhost:8080/gan
淦
win 浏览器测试
测试地址