史上最全的docker学习笔记

发表于： 2021年6月6日 2021年6月6日
分类：未分类

安装

1、在新主机上首次安装 Docker Engine-Community 之前，需要设置 Docker 仓库。之后，您可以从仓库安装和更新 Docker。

https://www.cnblogs.com/caoweixiong/p/12186736.html

yum -y install gcc
yum -y install gcc-c++

设置仓库

yum install -y yum-utils \
device-mapper-persistent-data \
lvm2

使用以下命令来设置稳定的仓库

yum-config-manager \
–add-repo \
https://mirrors.tuna.tsinghua.edu.cn/docker-ce/linux/centos/docker-ce.repo

卸载旧版本

yum remove docker \
docker-client \
docker-client-latest \
docker-common \
docker-latest \
docker-latest-logrotate \
docker-logrotate \
docker-engine

安装 Docker Engine-Community

安装最新：yum -y install docker-ce

安装指定版本：
列出并排序您存储库中可用的版本。此示例按版本号（从高到低）对结果进行排序
yum list docker-ce –showduplicates | sort -r
通过其完整的软件包名称安装特定版本，该软件包名称是软件包名称（docker-ce）加上版本字符串（第二列），从第一个冒号（:）一直到第一个连字符，并用连字符（-）分隔。例如：docker-ce-18.09.1。

[root@rocketmq-nameserver1 ~]# yum list docker-ce.x86_64 –showduplicates | sort -r
已加载插件：fastestmirror, langpacks
可安装的软件包
\* updates: http://mirrors.ustc.edu.cn
Loading mirror speeds from cached hostfile
\* extras: http://mirrors.ustc.edu.cn
\* epel: http://ftp.riken.jp
docker-ce.x86_64 3:20.10.5-3.el7 docker-ce-stable
docker-ce.x86_64 3:20.10.4-3.el7 docker-ce-stable
docker-ce.x86_64 3:20.10.3-3.el7 docker-ce-stable

yum install docker-ce-<VERSION_STRING> docker-ce-cli-<VERSION_STRING> containerd.io
yum install docker-ce-20.10.5 docker-ce-cli-20.10.5 http://containerd.io

验证

docker version

启动 Docker

systemctl start/stop/status/restart docker

通过运行 hello-world 映像来验证是否正确安装了 Docker Engine-Community

docker run hello-world

docker架构

镜像

查看镜像：

docker images

搜索镜像：

下载镜像：

docker pull NAME:[TAG]

删除镜像：

docker rmi -f 镜像ID/NAME

容器：

运行容器：

docker run [可选参数] image

-it 进入容器交换模式

-d 后台运行

–name 容器运行的名字

-p 启动容器端口

-p 容器外端口：容器内端口 -p 8080:80

docker run -it ubuntu /bin/bash

docker run -itd –name mysql-test -p 3306:3306 -e MYSQL_ROOT_PASSWORD=123456 mysql

列出运行容器：

docker ps 列出正在运行的容器

docker ps -a 列出所用容器

退出容器：

exit 退出停止

ctrl + P+Q 退出不停止

删除容器：

docker rm 容器ID

容器操作：

docker start/stop/restart/kill 容器ID

查看日志：

进入正在运行的容器：

docker exec -it 容器ID /bin/bash

docker attach 容器ID

docker安装nginx

#搜索镜像 docker search nginx
#拉取镜像 docker pull nginx:latest
#启动镜像 docker run -d –name nginx-test -p 8080:80 nginx
-d 容器在docker后台启动运行
–name 容器的名字
-p 将docker内的80端口映射到宿主机8080端口

docker安装Tomcat

#下载 docker pull tomcat:9.0
#启动 docker run –name tomcat-docker -p 3355:8080 -d tomcat
#进入容器 docker exec -it tomcat-docker /bin/bash
将webapps.dist 改名为webapps

docker安装es

下载: docker pull elasticsearch:6.8.15
docker network create somenetwork
启动: docker run -d –name elasticsearch –net somenetwork -p 9200:9200 -p 9300:9300 -e “discovery.type=single-node” -e ES_JAVA_OPTS=”-Xms64m -Xmx512m” elasticsearch:6.8.15
-e 指定参数
测试: curl localhost:9200
[root@rocketmq-nameserver1 ~]# curl localhost:9200
{
“name” : “D2_EXml”,
“cluster_name” : “docker-cluster”,
“cluster_uuid” : “9VHRwjyVQd-kP1D5lxFvhQ”,
“version” : {
“number” : “6.8.15”,
“build_flavor” : “default”,
“build_type” : “docker”,
“build_hash” : “c9a8c60”,
“build_date” : “2021-03-18T06:33:32.588487Z”,
“build_snapshot” : false,
“lucene_version” : “7.7.3”,
“minimum_wire_compatibility_version” : “5.6.0”,
“minimum_index_compatibility_version” : “5.0.0”
},
“tagline” : “You Know, for Search”
}

查看docker CPU情况

docker stats

可视化

下载： docker pull portainer/portainer:alpine
启动： docker run -d -p 8088:9000 –restart=always -v /var/run/docker.sock:/var/run/docker.sock –privileged=true portainer/portainer:alpine
访问： http://192.168.139.128:8088

docker镜像讲解

什么是镜像？

镜像是一种轻量级、可执行的独立软件包，用来打包软件运行环境基于运行环境的开发软件，它包含运行某个软件需要的所有内容，包含代码运行时、库、环境遍历和配置文件。
所有的应用，直接打包docker镜像，就可以直接跑起来。
如何得到镜像：
从远程仓库下载
从朋友拷贝
自己制作一个镜像DockerFile

镜像加载原理

联合文件系统UnionFS

1617960507235

分层理解

commit镜像

docker commit 提交容器成为一个新的副本
docker commit -m=”描述” -a=”作者” 容器ID 目标镜像名:[TAG]

docker数据卷

docker：应用和环境打包成一个镜像

如果数据都在容器中，那么我们容器删除，数据就会丢失？数据需要持久化

MySQL，容器删除了！MySQL数据可不可以存储在本地

容器之间有个数据共享的技术！docker容器产生的数据同步到本地

这就是卷技术，目录的挂载，将我们容器内的目录挂在到Linux文件系统目录上

使用数据卷

使用方式1

使用命令：docker run -v 容器外的目录:容器内目录

#案列1
docker run -it -v /home/test:/home ubuntu /bin/bash
#扩展查看容器具体信息
docker inspect 容器ID
#案例2
docker run –name mysql-docker -p 3306:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=root -d mysql:8.0
–name 容器运行的名字
-d 后台运行
-p 端口映射
-e 运行参数
-v 数据卷挂载

使用方式2

#匿名挂载
docker run -v 容器内路径
docker run –name nginx-docker -p 80:80 -v /etc/nginx -d nginx:latest

#具名挂载
docker run –name nginx-docker -p 80:80 -v juming-nginx:/etc/nginx -d nginx:latest

#docker的工作目录： /var/lib/docker
[root@rocketmq-nameserver1 docker]# ls -l
总用量 20
drwx–x–x. 4 root root 120 4月 8 21:40 buildkit
drwx—–x. 10 root root 4096 4月 9 21:35 containers
drwx——. 3 root root 22 4月 8 21:40 image
drwxr-x—. 3 root root 19 4月 8 21:40 network
drwx—–x. 62 root root 8192 4月 9 21:35 overlay2
drwx——. 4 root root 32 4月 8 21:40 plugins
drwx——. 2 root root 6 4月 8 21:40 runtimes
drwx——. 2 root root 6 4月 8 21:40 swarm
drwx——. 2 root root 6 4月 9 17:00 tmp
drwx——. 2 root root 6 4月 8 21:40 trust
drwx—–x. 6 root root 4096 4月 9 21:35 volumes

进入volumes/juming-nginx/_data 就可以看到挂载的NGINX目录
#卷的操作
docker volume create/ls/inspect/prune/rm
#查看挂载
docker volume inspect juming-nginx
[root@rocketmq-nameserver1 _data]# docker volume inspect juming-nginx
[
{
“CreatedAt”: “2021-04-09T21:35:54+08:00”,
“Driver”: “local”,
“Labels”: null,
“Mountpoint”: “/var/lib/docker/volumes/juming-nginx/_data”,
“Name”: “juming-nginx”,
“Options”: null,
“Scope”: “local”
}
]

扩展

docker run –name docker-nginx-test -p 80:80 -v juming-nginx:/etc/nginx:ro -d nginx:latest

docker run –name docker-nginx-test -p 80:80 -v juming-nginx:/etc/nginx:rw -d nginx:latest

ro 只读挂载readonly
rw 可度可写挂载

初识dockerfile

dockerfile就是用来构建docker镜像的文件

1、创建一个名为dockerfile的文件

touch dockerfile

2、编辑文件，内容如下：

FROM centos

VOLUME [“volume01″,”volume02”]

CMD echo “—-end—-”
CMD /bin/bash

3、构建

docker build -f /var/lib/docker/docker-volumn-dockfile/dockerfile -t mycentos:1.0 .

扩展

容器间数据卷共享
–volumes-from 容器名
docker run –name docker02 –volumes-from docker01 ubuntu:latest
docker02共享docker01的数据卷

多个MySQL实现数据共享

#mysql3306
docker run -d -p 3306:3306 -v /etc/mysql/conf.d -v /var/lib/mysql -e MYSQL_ROOT_PASSWORD=root –name mysql3306 mysql:8.0
#mysql3307
docker run -d -p 3307:3307 -e MYSQL_ROOT_PASSWORD=root –name mysql3307 –volumes-from mysql3306 mysql:8.0

dockerfile

什么是 Dockerfile？

dockerfile使用来构建docker镜像的文件！命令参数脚本

构建步骤：
1、编写一个dockerfile文件
2、docker build 构建一个镜像
3、docker run 运行镜像
4、docker push 发布镜像（DockerHub、阿里云镜像仓库）

使用 Dockerfile 定制镜像

基础知识

1、每个保留字（指令）都是必须是大写字母
2、执行顺序从上到下执行
3、#表示注释
4、每一个指令都会创建提交一个新的镜像层，并提交

dockerfile指令

实战：构建自己的centos

创建文件：/usr/local/docker/dockerfile/mycentos 文件内容如下

FROM centos
MAINTAINER XIAOMAO<[email protected]>

ENV MYPATH /usr/local
WORKDIR $MYPATH

RUN yum -y install vim
RUN yum -y install net-tools

EXPOSE 80

CMD echo $MYPATH
CMD echo “——end——”
CMD /bin/bash

构建镜像

docker build -f /usr/local/docker/dockerfile/mycentos -t mycentos:v1 .
-f dockerfile文件
-t 镜像名:标签
. 代表本次执行的上下文路径

运行测试：docker run -it mycentos:v1 /bin/bash

扩展:查看镜像构建过程

docker history b72e45a11ad9【镜像ID】

实战：dockerfile构建tomcat镜像

准备jdk tomcat 压缩包

-rw-rw-r–. 1 xiaomao xiaomao 8340063 3月 19 22:20 apache-tomcat-7.0.52.tar.gz
-rw-rw-r–. 1 xiaomao xiaomao 195132576 4月 10 11:04 jdk-8u251-linux-x64.tar.gz

编写dockerfile文件

FROM centos
MAINTAINER XIAOMAO<[email protected]>

COPY readme.txt /usr/local/readme.txt

ADD jdk-8u251-linux-x64.tar.gz /usr/local/
ADD apache-tomcat-7.0.52.tar.gz /usr/local/

RUN yum -y install vim

ENV MYPATH /usr/local
WORKDIR $MYPATH

ENV JAVA_HOME /usr/local/jdk1.8.0_251
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-7.0.52
ENV CATALINA_BASE /usr/local/apache-tomcat-7.0.52
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin

EXPOSE 8080

CMD /usr/local/apache-tomcat-7.0.52/bin/startup.sh && tail -F /usr/local/apache-tomcat-7.0.52/bin/logs/catalina.out

构建镜像

docker build -f /usr/local/docker/dockerfile/mytomcat/dockerfile -t mytomcat:v1 .

运行测试

docker run -it –name mytomcat-docker mytomcat:v1 /bin/bash
docker run -d –name mytomcat-docker -p 8080:8080 mytomcat:v1

#进入容器内启动tomcat
docker exec -it 容器ID /bin/bash

发布镜像到dockerhub

#注册登录
https://hub.docker.com/signup
#登录
docker login -u xiaomao #回车输入密码
#在服务器上提交
docker push 用户名/镜像名:TAG
docker push xiaomao/mytomcat:v1

小结

docker网络

docker0

docker是如何处理网络访问的？

原理

我们启动一个docker容器，docker就会给docker容器分配一个IP，我们只要安装了docker，就会一个网卡docker0,桥接模式，使用技术是evth-pair技术，容器和容器之间的网络是可以凭ping通的！

网络拓扑图

结论：Tomcat01与Tomcat02公用一个路由docker0，容器在不指定IP情况下，docker0都会为容器分配一个IP

–link

说明：容器间通过名字通讯

#–link链接到centos01
docker run -itd –name centos03 –link centos01 centos:7 /bin/bash

docker exec -it centos03 ping centos01
效果：
[root@rocketmq-nameserver1 mytomcat]# docker exec -it centos03 ping centos01
PING centos01 (172.17.0.4) 56(84) bytes of data.
64 bytes from centos01 (172.17.0.4): icmp_seq=1 ttl=64 time=0.124 ms
64 bytes from centos01 (172.17.0.4): icmp_seq=2 ttl=64 time=0.125 ms
64 bytes from centos01 (172.17.0.4): icmp_seq=3 ttl=64 time=0.121 ms

探究原理：
[root@rocketmq-nameserver1 mytomcat]# docker exec -it centos03 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.4 centos01 a60e4e0e3f85
172.17.0.7 d7868f031ca9

docker exec -it centos01 ping centos03 ping的通吗？–不可以

自定义网络

查看所有网络

[root@rocketmq-nameserver1 ~]# docker network ls
NETWORK ID NAME DRIVER SCOPE
757727110f70 bridge bridge local
fde3d0a3f717 host host local
011b819d9b7a none null local
a9a74af7b18d somenetwork bridge local

自定义网络命令

docker network create –driver bridge –subnet 192.168.0.0/16 –gateway 192.168.0.1 mynet
–driver bridge 网络链接方式
–subnet 192.168.0.0/16 子网
–gateway 192.168.0.1 网关
mynet 自己取的名字

效果：
[root@rocketmq-nameserver1 ~]# docker network ls
NETWORK ID NAME DRIVER SCOPE
757727110f70 bridge bridge local
fde3d0a3f717 host host local
0366e43ca5dc mynet bridge local
011b819d9b7a none null local
a9a74af7b18d somenetwork bridge local

查看：
[root@rocketmq-nameserver1 ~]# docker network inspect mynet
[
{
“Name”: “mynet”,
“Id”: “0366e43ca5dce6d063e31dee392150fa2e906533bd405c563d1d259172e69894”,
“Created”: “2021-04-10T19:35:17.090781686+08:00”,
“Scope”: “local”,
“Driver”: “bridge”,
“EnableIPv6”: false,
“IPAM”: {
“Driver”: “default”,
“Options”: {},
“Config”: [
{
“Subnet”: “192.168.0.0/16”,
“Gateway”: “192.168.0.1”
}
]
},
“Internal”: false,
“Attachable”: false,
“Ingress”: false,
“ConfigFrom”: {
“Network”: “”
},
“ConfigOnly”: false,
“Containers”: {},
“Options”: {},
“Labels”: {}
}
]

启动容器指定自定义网络

docker run -d -P –name tomcat-net01 –net mynet tomcat:9.0
docker run -d -P –name tomcat-net02 –net mynet tomcat:9.0
–net mynet 指定网络

查看，多了两个container
[root@rocketmq-nameserver1 ~]# docker network inspect mynet
[
{
“Name”: “mynet”,
“Id”: “0366e43ca5dce6d063e31dee392150fa2e906533bd405c563d1d259172e69894”,
“Created”: “2021-04-10T19:35:17.090781686+08:00”,
“Scope”: “local”,
“Driver”: “bridge”,
“EnableIPv6”: false,
“IPAM”: {
“Driver”: “default”,
“Options”: {},
“Config”: [
{
“Subnet”: “192.168.0.0/16”,
“Gateway”: “192.168.0.1”
}
]
},
“Internal”: false,
“Attachable”: false,
“Ingress”: false,
“ConfigFrom”: {
“Network”: “”
},
“ConfigOnly”: false,
“Containers”: {
“8c2fe224e4b3e1d6dd44e4b1a2e6a4d443339499141e84c7ad26b4a7a8e10430”: {
“Name”: “tomcat-net01”,
“EndpointID”: “d21b1a34f164b8722fd61037b91e151bb883d5eadbadf44146d8111afbcdc499”,
“MacAddress”: “02:42:c0:a8:00:02”,
“IPv4Address”: “192.168.0.2/16”,
“IPv6Address”: “”
},
“a64b99861a42cfa0b16ce0cc3bfd698812700986c8639ddd76bfc47d4c0382c2”: {
“Name”: “tomcat-net02”,
“EndpointID”: “4c2f200b8eea913c036096d1d5277f0e4b4f707982da14ad2a3194fadbf3f038”,
“MacAddress”: “02:42:c0:a8:00:03”,
“IPv4Address”: “192.168.0.3/16”,
“IPv6Address”: “”
}
},
“Options”: {},
“Labels”: {}
}
]

#ping测试
[root@rocketmq-nameserver1 ~]# docker exec -it tomcat-net01 ping tomcat-net02
PING tomcat-net02 (192.168.0.3) 56(84) bytes of data.
64 bytes from tomcat-net02.mynet (192.168.0.3): icmp_seq=1 ttl=64 time=0.144 ms
64 bytes from tomcat-net02.mynet (192.168.0.3): icmp_seq=2 ttl=64 time=0.123 ms

[root@rocketmq-nameserver1 ~]# docker exec -it tomcat-net02 ping tomcat-net01
PING tomcat-net01 (192.168.0.2) 56(84) bytes of data.
64 bytes from tomcat-net01.mynet (192.168.0.2): icmp_seq=1 ttl=64 time=0.040 ms
64 bytes from tomcat-net01.mynet (192.168.0.2): icmp_seq=2 ttl=64 time=0.117 ms

网络连通

连接一个容器到网络

[root@rocketmq-nameserver1 ~]# docker network connect –help

Usage: docker network connect [OPTIONS] NETWORK CONTAINER

Connect a container to a network

Options:
–alias strings Add network-scoped alias for the container
–driver-opt strings driver options for the network
–ip string IPv4 address (e.g., 172.30.100.104)
–ip6 string IPv6 address (e.g., 2001:db8::33)
–link list Add link to another container
–link-local-ip strings Add a link-local address for the container

命令

docker network connect mynet tomcat01
docker network connect mynet tomcat02

# tomcat01，tomcat02加入到mynet中
[root@rocketmq-nameserver1 ~]# docker network inspect mynet
[
{
“Name”: “mynet”,
“Id”: “0366e43ca5dce6d063e31dee392150fa2e906533bd405c563d1d259172e69894”,
“Created”: “2021-04-10T19:35:17.090781686+08:00”,
“Scope”: “local”,
“Driver”: “bridge”,
“EnableIPv6”: false,
“IPAM”: {
“Driver”: “default”,
“Options”: {},
“Config”: [
{
“Subnet”: “192.168.0.0/16”,
“Gateway”: “192.168.0.1”
}
]
},
“Internal”: false,
“Attachable”: false,
“Ingress”: false,
“ConfigFrom”: {
“Network”: “”
},
“ConfigOnly”: false,
“Containers”: {
“81a23b5a50cdf716d94c2eba6e2dad7c2371a56bc1c9c6bb3351041d538c4043”: {
“Name”: “tomcat02”,
“EndpointID”: “acd00d79f587fe12153ef1a03c9313a4c5267b9df52c2b35a4ef292c92b7570b”,
“MacAddress”: “02:42:c0:a8:00:05”,
“IPv4Address”: “192.168.0.5/16”,
“IPv6Address”: “”
},
“8c2fe224e4b3e1d6dd44e4b1a2e6a4d443339499141e84c7ad26b4a7a8e10430”: {
“Name”: “tomcat-net01”,
“EndpointID”: “d21b1a34f164b8722fd61037b91e151bb883d5eadbadf44146d8111afbcdc499”,
“MacAddress”: “02:42:c0:a8:00:02”,
“IPv4Address”: “192.168.0.2/16”,
“IPv6Address”: “”
},
“a64b99861a42cfa0b16ce0cc3bfd698812700986c8639ddd76bfc47d4c0382c2”: {
“Name”: “tomcat-net02”,
“EndpointID”: “4c2f200b8eea913c036096d1d5277f0e4b4f707982da14ad2a3194fadbf3f038”,
“MacAddress”: “02:42:c0:a8:00:03”,
“IPv4Address”: “192.168.0.3/16”,
“IPv6Address”: “”
},
“f178421a32c960467146bc527b01772d8b60cc4ae41cc50510487496114abdd1”: {
“Name”: “tomcat01”,
“EndpointID”: “c62afddf7689d5ddd95ecb05c3ac00592f718a3dfdce1f220e25645e64789bdf”,
“MacAddress”: “02:42:c0:a8:00:04”,
“IPv4Address”: “192.168.0.4/16”,
“IPv6Address”: “”
}
},
“Options”: {},
“Labels”: {}
}
]

#测试
[root@rocketmq-nameserver1 ~]# docker exec -it tomcat01 ping tomcat-net01
PING tomcat-net01 (192.168.0.2) 56(84) bytes of data.
64 bytes from tomcat-net01.mynet (192.168.0.2): icmp_seq=1 ttl=64 time=0.064 ms
64 bytes from tomcat-net01.mynet (192.168.0.2): icmp_seq=2 ttl=64 time=0.137 ms

[root@rocketmq-nameserver1 ~]# docker exec -it tomcat01 ping tomcat02
PING tomcat02 (192.168.0.5) 56(84) bytes of data.
64 bytes from tomcat02.mynet (192.168.0.5): icmp_seq=1 ttl=64 time=0.041 ms
64 bytes from tomcat02.mynet (192.168.0.5): icmp_seq=2 ttl=64 time=0.126 ms

实战：Redis集群

创建网络

docker network create –driver bridge –subnet 192.169.0.0/16 –gateway 192.169.0.1 redis

通过脚本创建6个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-announce-ip 192.169.0.1${port}
cluster-announce-port 6379
cluster-announce-bus-port 16379
appendonly yes
EOF
done

启动6个Redis

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 192.169.0.11 \
redis:latest redis-server /etc/redis/redis.conf

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 192.169.0.12 \
redis:latest redis-server /etc/redis/redis.conf

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 192.169.0.13 \
redis:latest redis-server /etc/redis/redis.conf

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 192.169.0.14 \
redis:latest redis-server /etc/redis/redis.conf

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 192.169.0.15 \
redis:latest redis-server /etc/redis/redis.conf

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 192.169.0.16 \
redis:latest redis-server /etc/redis/redis.conf

创建集群，进入任意一个节点创建

docker exec -it 容器ID /bin/sh

redis-cli –cluster create 192.169.0.11:6379 192.169.0.12:6379 192.169.0.13:6379 192.169.0.14:6379 192.169.0.15:6379 192.169.0.16:6379 –cluster-replicas 1

查看集群

cluster info
cluster nodes

实战：springboot微服务打包docker镜像

步骤

1、构建springboot项目
2、打包应用
3、编写dockerfile
FROM openjdk:8u282-slim-buster

COPY *.jar /app.jar

CMD [“–server.port=8080”]

EXPOSE 8080

ENTRYPOINT [“java”,”-jar”,”/app.jar”]
4、构建镜像
docker build -t springboot-docker-web:1.0.0 .
5、发布运行
docker run -d –name springboot-docker -p 8080:8080 springboot-docker-web:1.0.0
6、测试
curl http://localhost:8080/sayHello

docker Compose

简介

微服务服务太多，手动build，run麻烦
docker compose来轻松管理容器，定义运行多个容器
官方简介：
Compose 是用于定义和运行多容器 Docker 应用程序的工具。通过 Compose，您可以使用 YML 文件来配置应用程序需要的所有服务。然后，使用一个命令，就可以从 YML 文件配置中创建并启动所有服务。

Compose 使用的三个步骤：

使用 Dockerfile 定义应用程序的环境。
使用 docker-compose.yml 定义构成应用程序的服务，这样它们可以在隔离环境中一起运行。
最后，执行 docker-compose up 命令来启动并运行整个应用程序。

Compose 安装

1、Linux 上我们可以从 Github 上下载它的二进制包来使用，最新发行的版本地址：https://github.com/docker/compose/releases。
运行以下命令以下载 Docker Compose 的当前稳定版本：
curl -L “https://github.com/docker/compose/releases/download/1.24.1/docker-compose-$(uname -s)-$(uname -m)” -o /usr/local/bin/docker-compose
要安装其他版本的 Compose，请替换 1.24.1。
2、将可执行权限应用于二进制文件：
chmod +x /usr/local/bin/docker-compose
3、创建软链：
ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose
4、测试是否安装成功：
docker-compose –version

使用

1、准备，创建一个测试目录：
mkdir composetest
cd composetest
在测试目录中创建一个名为 app.py 的文件，并复制粘贴以下内容：
//———–
import time

import redis
from flask import Flask

app = Flask(__name__)
cache = redis.Redis(host=’redis’, port=6379)

def get_hit_count():
retries = 5
while True:
try:
return cache.incr(‘hits’)
except redis.exceptions.ConnectionError as exc:
if retries == 0:
raise exc
retries -= 1
time.sleep(0.5)

@app.route(‘/’)
def hello():
count = get_hit_count()
return ‘Hello World! I have been seen {} times.\n’.format(count)
//———–
在此示例中，redis 是应用程序网络上的 redis 容器的主机名，该主机使用的端口为 6379。
在 composetest 目录中创建另一个名为 requirements.txt 的文件，内容如下：
//———–
flask
redis
//———–

2、创建 Dockerfile 文件，在 composetest 目录中，创建一个名为的文件 Dockerfile，内容如下：
//————
FROM python:3.7-alpine
WORKDIR /code
ENV FLASK_APP app.py
ENV FLASK_RUN_HOST 0.0.0.0
RUN apk add –no-cache gcc musl-dev linux-headers
COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt
COPY . .
CMD [“flask”, “run”]
//————

3、创建 docker-compose.yml,在测试目录中创建一个名为 docker-compose.yml 的文件，然后粘贴以下内容：
//————
# yaml 配置
version: ‘3’
services:
web:
build: .
ports:
– “5000:5000”
redis:
image: “redis:alpine”
//————
该 Compose 文件定义了两个服务：web 和 redis。
web：该 web 服务使用从 Dockerfile 当前目录中构建的镜像。然后，它将容器和主机绑定到暴露的端口 5000。此示例服务使用 Flask Web 服务器的默认端口 5000 。
redis：该 redis 服务使用 Docker Hub 的公共 Redis 映像。

4、使用 Compose 命令构建和运行您的应用，在测试目录中，执行以下命令来启动应用程序：
docker-compose up
如果你想在后台执行该服务可以加上 -d 参数：
docker-compose up -d

yaml配置指令参考：https://www.runoob.com/docker/docker-compose.html

搭建博客：https://docs.docker.com/compose/wordpress/

version: ‘3’

services:
db:
image: mysql:5.7
volumes:
– db_data:/var/lib/mysql
restart: always
environment:
MYSQL_ROOT_PASSWORD: somewordpress
MYSQL_DATABASE: wordpress
MYSQL_USER: wordpress
MYSQL_PASSWORD: wordpress

wordpress:
depends_on:
– db
image: wordpress:latest
ports:
– “8000:80”
restart: always
environment:
WORDPRESS_DB_HOST: db:3306
WORDPRESS_DB_USER: wordpress
WORDPRESS_DB_PASSWORD: wordpress
WORDPRESS_DB_NAME: wordpress
volumes:
db_data: {}

实战：自己编写微服务上线

1、编写项目，加入Redis
2、编写Dockerfile，参考“springboot微服务打包docker镜像”
3、编写docker-compose
4、执行docker-compose up -d

docker Swarm

简介

Docker Swarm 是 Docker 的集群管理工具。它将 Docker 主机池转变为单个虚拟 Docker 主机。 Docker Swarm 提供了标准的 Docker API，所有任何已经与 Docker 守护程序通信的工具都可以使用 Swarm 轻松地扩展到多个主机。
支持的工具包括但不限于以下各项：
Dokku
Docker Compose
Docker Machine
Jenkins

原理

如下图所示，swarm 集群由管理节点（manager）和工作节点（work node）构成。
swarm mananger：负责整个集群的管理工作包括集群配置、服务管理等所有跟集群有关的工作。
work node：即图中的 available node，主要负责运行相应的服务来执行任务（task）。

初始化

[root@iZ7xv2ybh1v2we7h6q4ih9Z ~]# docker swarm init –advertise-addr 172.21.72.136
Swarm initialized: current node (6dzqmqs8ohp8l4o8lxjkh3e24) is now a manager.

To add a worker to this swarm, run the following command:

docker swarm join –token SWMTKN-1-4iwry4d9d7cv20s5oiwggigu6u3k76c2n58bppuu27bsh85hod-11x3ulpevbkw7t9n28ho85y11 172.21.72.136:2377

To add a manager to this swarm, run ‘docker swarm join-token manager’ and follow the instructions.

获取令牌

docker swarm join-token manager #加入管理节点
docker swarm join-token worker #加入工作节点

体会

[root@iZ7xv2ybh1v2we7h6q4ih9Z ~]# docker service –help

Usage: docker service COMMAND

Manage services

Commands:
create Create a new service
inspect Display detailed information on one or more services
logs Fetch the logs of a service or task
ls List services
ps List the tasks of one or more services
rm Remove one or more services
rollback Revert changes to a service’s configuration
scale Scale one or multiple replicated services
update Update a service

docker service create -p 80:80 –name nginx-test nginx:latest #创建服务
docker service update –replicas 3 nginx-test #修改服务

admin

2125