安装
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: mirrors.ustc.edu.cn
Loading mirror speeds from cached hostfile
\* extras: mirrors.ustc.edu.cn
\* epel: 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 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
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-m6TtDRHy-1622964932314)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1617960239735.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2pjs06Nr-1622964932318)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1617960435428.png)]
分层理解
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<1585748457@QQ.COM>
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<1585748457@QQ.COM>
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 #修改服务
hp8l4o8lxjkh3e24) 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 #修改服务
扫一扫
19万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
