docker入门到精通

安装docker

docker 官方文档 https://docs.docker.com/engine/install/

Docker的镜像称为image，容器称为container。对于Docker来说，image是静态的，类似于操作系统快照，而container则是动态的，是image的运行实例。

有了镜像才能创建容器，如果数据在容器里，删除容器会丢失数据，数据持久化请看数据卷

安装gcc

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

卸载旧版本

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

安装所需软件

 sudo yum install -y yum-utils

设置仓库

国外

 sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo

国内

 sudo yum-config-manager \
    --add-repo \
    http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

安装docker

 sudo yum install -y docker-ce docker-ce-cli containerd.io

配置阿里云镜像加速
找到 “容器镜像服务”–>“镜像加速器” 菜单
https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors

设置开机自启动docker

systemctl enable docker

启动docker

service docker start

重启docker

systemctl restart docker

这个命令是将软件包信息提前在本地缓存一份，用来提高搜索安装软件的速度

yum makecache fast

yum 会把下载的软件包和header存储在cache中而不自动删除。如果觉得占用磁盘空间，可以使用yum clean指令清除缓存。

yum clean all

基础命令

选项	选项简写	说明
–detach	-d	在后台运行容器，并且打印容器id。
–interactive	-i	即使没有连接，也要保持标准输入保持打开状态，一般与 -t 连用。【指示 docker 要在容器上打开一个标准的输入接口】
–tty	-t	分配一个伪tty，一般与 -i 连用。【指示 docker 要创建一个伪 tty 终端，连接容器的标准输入接口，之后用户就可以通过终端进行输入】

查看本地镜像 docker images
删除镜像 docker rmi -f（rm代表remove，i代表image，-f代表force强制) 可以通过ID删，也可以通过名称删
通过ID删除镜像 docker rmi -f c8562eaf9d81
通过名称删除镜像 docker rmi -f mysql:latest
删除全部镜像 docker rmi -f $(docker images -aq)
运行容器 docker run -it REPOSITORY(-it交互执行，没加 -it ，进入不了。)
查看运行容器 docker ps
查看所有容器 docker ps -a
重新进入容器 docker attach CONTAINER ID（退出会停止）
重新进入容器 docker exec -it NAMES /bin/bash （退出不会停止）
启动容器 docker start CONTAINER ID
重启容器 docker restart CONTAINER ID
终止容器 docker stop CONTAINER ID
强制终止容器 docker kill CONTAINER ID
删除容器 docker rm CONTAINER ID
强制删除容器（-f 强制删除，包括运行中的） docker rm -f container-name
删除全部容器 docker rm $(docker ps -a)
强制删除所有容器（-f 强制删除，包括运行中的） docker rm -f $(docker ps -a)
创建容器时设置名称 docker run -d --name hadoop_master ubuntu:hadoop
重命名容器 docker rename peaceful_gould hadoop_slave1
退出容器并停止 exit
退出容器不停止 ctrl+p+q
退出输入状态 ctrl+c
拷贝容器文件到主机 docker cp CONTAINER ID 容器路径 主机路径
查看是否挂载成功 docker inspect CONTAINER ID
查看日志 docker logs -f redis
开启挂载权限 --privileged=true

搜索dockerhub

https://hub.docker.com/search?q=mysql&type=image

或用命令 docker search mysql 搜索，得到如下图，两个结果是对应的

安装镜像步骤

安装ubuntu

docker pull ubuntu

进入ubuntu

docker run -it ubuntu

容器备份

docker export 4aa05212492e > abc.tar

导入容器

cat abc.tar | docker import - chen/redis:6.0.8

拷贝容器中根目录的a.txt文件到主机root目录

docker cp 6fbdc256a205:/a.txt /root

运行

docker run -it  e336eff56f01 /bin/bash 

重新进入

docker exec -it sad_kapitsa /bin/bash

给容器中ubuntu安装vim
先更新包管理工具

apt-get update

再安装vim

apt-get -y install vim

挂载容器卷-v宿主:容器（默认可读可写）

docker run -it --privileged=true -v /tmp/host-data:/tmp/docker-data --name=u1 ubuntu

挂载容器卷-v宿主:容器（只读，只限制容器）

docker run -it --privileged=true -v /tmp/host-data:/tmp/docker-data:ro --name=u1 ubuntu

输入hello chen到a.txt

echo 'hello chen' > a.txt

查看容器挂载

docker inspect b298e701ad10

容器继承其他容器规则

docker run -it --privileged=true --volumes-from u1 --name u2 ubuntu

提交容器为新镜像

docker commit -m="add vim" -a="chen" f2f9c4aa4d3e ubuntu-chen:1.0
$ docker login --username=hi3184****@aliyun.com registry.cn-hangzhou.aliyuncs.com
$ docker tag [ImageId] registry.cn-hangzhou.aliyuncs.com/chencxb/ubuntu-chen:[镜像版本号]
$ docker push registry.cn-hangzhou.aliyuncs.com/chencxb/ubuntu-chen:[镜像版本号]

上传到阿里云

进入“容器镜像服务/实例列表”

进入个人实例，创建命名空间，创建镜像仓库，按上面操作指南即可
创建命名空间

创建容器镜像


点击仓库，进去可以看到具体教程

发布镜像到dockerhub(注意：new-repo为dockerhub用户名)

到dockerhub注册账户 https://hub.docker.com/
docker login -u 用户名
再输入密码
docker tag local-image:tagname new-repo:tagname (local-image:tagname为本地镜像和版本号，也可以用ID，new-repo:tagname为dockerhub中的用户名加名称)

docker push new-repo:tagname

部署tomcat

docker pull tomcat:7.0.77

运行

docker run -d -p 8080:8080 --name t1  tomcat:7.0.77

部署mysql:5.7（单机）

docker pull mysql:5.7

指定下载 docker pull 镜像名[:tag]，不写tag默认最新版，版本号一定要在dockerhub里面有，如下图

另外：以下一条一条下载称为分层下载，是docker核心 联合文件系统

# 最后一条docker.io/library/mysql:lates是真实地址
# 所以以下两条命令是等价的
docker pull mysql:5.7
docker pull docker.io/library/mysql:5.7

启动mysql并映射容器数据卷

docker run -d -p 3306:3306 --privileged=true -e MYSQL_ROOT_PASSWORD='123456' -v /data/mysql/log:/var/log/mysql  -v /data/mysql/data:/var/lib/mysql -v /data/mysql/conf:/etc/mysql/conf.d --name mysql mysql:5.7

docker run -d 后台运行
-p 3306:3306 主机端口:容器端口，将容器端口映射到主机端口
-e MYSQL_ROOT_PASSWORD=密码 初始化root用户的密码，-e为配置环境
-v /data/mysql/conf:/etc/mysql/conf.d 主机目录:容器目录，将配置文件夹挂载到主机
-v /data/mysql/log:/var/log/mysql 主机目录:容器目录，将日志文件夹挂载到主机
-v /data/mysql/data:/var/lib/mysql 主机目录:容器目录，将数据文件夹挂载到主机

进入容器

docker exec -it 329e6e559705 /bin/bash

输入密码进入

mysql -uroot -p

查看数据库

 show databases;

创建数据库

create database db01;

使用数据库

use db01;

创建表

create table t1(id int,name varchar(20));

插入数据

insert into t1 value(1,'chen'); 

查看数据

select * from t1;

设置mysql自启动

docker update mysql --restart=always

查看字符集，docker数据库默认拉丁，插入不了中文

show variables like 'character%';

修改配置文件

vim /data/mysql/conf/my.cnf

粘贴如下内容

[client]
default-character-set=utf8
[mysql]
default-character-set=utf8
[mysqld]
init_connect='SET collation_connection = utf8_unicode_ci'
init_connect='SET NAMES utf8'
character-set-server=utf8
collation-server=utf8_unicode_ci
skip-character-set-client-handshake
skip-name-resolve
# wait_timeout= 31536000
# interactive_timeout= 3153600

重启

docker restart 866f95a82cef

部署mysql:5.7（集群）

启动主服务器实例3307

docker run -d -p 3307:3306 --privileged=true -e MYSQL_ROOT_PASSWORD='123456' -v /data/mysql-master/log:/var/log/mysql  -v /data/mysql-master/data:/var/lib/mysql -v /data/mysql-master/conf:/etc/mysql/conf.d --name mysql-master mysql:5.7

master容器实例内创建数据同步用户

create user 'slave'@'%' identified by 'root';

授予权限

grant replication slave,replication client on *.* to 'slave'@'%';

修改配置文件my.cnf

[client]
default-character-set=utf8
[mysql]
default-character-set=utf8
[mysqld]
## 设置server_id，同一局域网需要唯一
server_id=101
## 指定不需要同步的数据库名
binlog-ignore-db=mysql
## 开启二进制日志功能
log-bin=mall-mysql-bin
## 设置二进制日志使用内存大小（事物）
binlog_cache_size=1M
## 设置使用的二进制日志格式（mixed,statement,row）
binlog_format=mixed
## 二进制日志过期清理时间。默认值0，表示不自动清理
expire_logs_days=7
## 1062错误是指一些主键重复，1032错误是因为主从数据库数据不一致。跳过此错误，避免slave端复制中断
slave_skip_errors=1062

init_connect='SET collation_connection = utf8_unicode_ci'
init_connect='SET NAMES utf8'
character-set-server=utf8
collation-server=utf8_unicode_ci
skip-character-set-client-handshake
skip-name-resolve
# wait_timeout= 31536000
# interactive_timeout= 3153600

其他步骤如上单机版

启动主服务器实例3308

docker run -d -p 3308:3306 --privileged=true -e MYSQL_ROOT_PASSWORD='123456' -v /data/mysql-slave/log:/var/log/mysql  -v /data/mysql-slave/data:/var/lib/mysql -v /data/mysql-slave/conf:/etc/mysql/conf.d --name mysql-slave mysql:5.7

修改配置文件my.cnf

[client]
default-character-set=utf8
[mysql]
default-character-set=utf8
[mysqld]
## 设置server_id，同一局域网需要唯一
server_id=102
## 指定不需要同步的数据库名
binlog-ignore-db=mysql
## 开启二进制日志功能
log-bin=mall-mysql-slave1-bin
## 设置二进制日志使用内存大小（事物）
binlog_cache_size=1M
## 设置使用的二进制日志格式（mixed,statement,row）
binlog_format=mixed
## 二进制日志过期清理时间。默认值0，表示不自动清理
expire_logs_days=7
## 1062错误是指一些主键重复，1032错误是因为主从数据库数据不一致。跳过此错误，避免slave端复制中断
slave_skip_errors=1062
## 配置中继日志
relay_log=mall-mysql-relay-bin
## 表示slave将复制事件写进自己的二进制日志
log_save_updates=1
## slave设置为只读（具有super权限的用户除外）
read_only=1

init_connect='SET collation_connection = utf8_unicode_ci'
init_connect='SET NAMES utf8'
character-set-server=utf8
collation-server=utf8_unicode_ci
skip-character-set-client-handshake
skip-name-resolve
# wait_timeout= 31536000
# interactive_timeout= 3153600

部署redis（单机）

docker pull redis:6.0.8

在宿主机先创建redis目录与redis.conf文件（把安装过的redis.conf覆盖上去），防止挂载时把redis.conf当成目录

 mkdir -p /data/redis/conf
 touch /data/redis/conf/redis.conf

从安装包复制redis.conf上传，修改如下参数（注意：每个版本配置文件不一样）

1.bind 127.0.0.1改为 #bind 127.0.0.1（注释掉）
2.protected-mode yes 改为 protected-mode no（关闭保护模式）
3.daemonize注释或改成no，与docker run -d参数冲突
4.开启持久化 appendonly yes 
5.设置密码 requirepass 密码

启动docker并映射容器数据卷

docker run -d  -p 6379:6379 --privileged=true  -v /data/redis/data:/data -v /data/redis/conf/redis.conf:/etc/redis/redis.conf  --name redis  redis:6.0.8 redis-server /etc/redis/redis.conf

如果启动失败，查看日志

docker logs 5833ada729f5

设置redis自启动

docker update redis --restart=always

重新进入redis，如果要进去客户端再输入redis-cli

docker exec -it  redis /bin/bash 

直接进入客户端

docker exec -it  redis redis-cli

输入密码

auth "密码"

退出

exit

redis获取数据库个数

config get databases

查看redis当前所有的key

keys * 

查看redis当前的配置信息

config get *

查看容器日志

docker logs 4ee611467044

部署redis（集群）

docker run -d --name redis-node-1 --net host --privileged=true  -v /data/redis/share/redis-node-1:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6381
docker run -d --name redis-node-2 --net host --privileged=true  -v /data/redis/share/redis-node-2:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6382
docker run -d --name redis-node-3 --net host --privileged=true  -v /data/redis/share/redis-node-3:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6383
docker run -d --name redis-node-4 --net host --privileged=true  -v /data/redis/share/redis-node-4:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6384
docker run -d --name redis-node-5 --net host --privileged=true  -v /data/redis/share/redis-node-5:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6385
docker run -d --name redis-node-6 --net host --privileged=true  -v /data/redis/share/redis-node-6:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6386

查看ip ifconfig 构建集群

redis-cli --cluster create 10.0.20.13:6381 10.0.20.13:6382 10.0.20.13:6383 10.0.20.13:6384 10.0.20.13:6385 10.0.20.13:6386 --cluster-replicas 1

再输入 yes

以6381为切入点

redis-cli -p 6381

查看集群状态

cluster info

查看所有节点，如下可以看到master与slave，还有谁挂在谁下面

cluster nodes

重新进入

docker exec -it redis-node-1 /bin/bash

集群连接加-c

redis-cli -p 6381 -c

检查集群，可以看到哪些key在哪些哈希槽里

redis-cli --cluster check 10.0.20.13:6381

模拟master1停机，查看slave是否上位

docker stop a06e659529ae

从2号进入

docker exec -it  redis-node-2 /bin/bash

以集群的方式进入

redis-cli -p 6382 -c

cluster nodes可以看到如下6386已经变成master

如下数据都还在

扩容

docker run -d --name redis-node-7 --net host --privileged=true  -v /data/redis/share/redis-node-7:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6387

docker run -d --name redis-node-8 --net host --privileged=true  -v /data/redis/share/redis-node-8:/data redis:6.0.8 --cluster-enabled yes --appendonly yes --port 6388

进入7号机

docker exec -it redis-node-7 /bin/bash

加入集群

redis-cli --cluster add-node 10.0.20.13:6387  10.0.20.13:6381

检查集群，如下还没有槽位

redis-cli --cluster check 10.0.20.13:6381

重新分配槽位

redis-cli --cluster reshard 10.0.20.13:6381

4096=16384/4个master
node ID是要分配给以的新节点
再输入all，然后输入yes，重新洗牌

再查看洗牌结果，每个节点匀了一部分给新节点，全部重新分配成本太高


把6388作为slave挂载到6387

redis-cli --cluster add-node 10.0.20.13:6388 10.0.20.13:6387 --cluster-slave --cluster-master-id  b23094aab9ee205533f35aff10d7dbdb0f46e19e

缩容

只能先删除slave，再删master

redis-cli --cluster del-node 10.0.20.13:6388 0469a78d9292aea8cf28ec1017d84d45a6dd9dc2

先把要删除的master节点槽位分配给其他节点

redis-cli --cluster reshard 10.0.20.13:6381

要移动的槽位有4096个，由6382 master 节点接受

移动完后再删除6387节点

redis-cli --cluster del-node 10.0.20.13:6387 b23094aab9ee205533f35aff10d7dbdb0f46e19e

Docker发布 springboot

建一个springboot项目，写个简单的controller 输出hello world

用 Maven package 打包，在target目录可以看jar包，在jar包目录下打开cmd 执行 java -jar demo-0.0.1-SNAPSHOT.jar，测试jar包是否没问题。

新建Dockerfile

FROM  java:8
# author
MAINTAINER chen
# 挂载目录，在主机/var/lib/docker目录下创建一个临时文件并链接到容器/tmp
VOLUME /tmp
# 创建目录
# 将jar包添加到容器中并更名chen_docker.jar
ADD dockerspringboot-0.0.1-SNAPSHOT.jar chen_docker.jar
# 运行jar包
RUN bash -c 'touch /chen_docker.jar'
# 启动网关服务
ENTRYPOINT ["java","-jar","/chen_docker.jar"]
EXPOSE 6001

在home下新建mydocker目录，用FTP上传dockerfile和jar包dockerspringboot-0.0.1-SNAPSHOT.jar，然后把他们打个包

docker build -t  chen_docker:1.0 .

(-t为target目标，. 为当前目录)

查看镜像是否创建成功

docker images 

启动chenxb镜像

docker run -d -p 6001:6001 chen_docker:1.0

访问 IP:6001/hello 返回hello world

部署nginx

docker run -d --name ngnix01 -p 3344:80 nginx【-d 后台运行 --name 命名容器 -p 宿主端口:内部端口（端口暴露）】
主机内部测试 curl localhost:3344

部署portainer

docker pull portainer/portainer-ce
docker run -d -p 8000:8000  -p 9000:9000 --restart always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer-ce

访问地址 http://192.168.56.10:9000/

匿名挂载

docker run -d -P --name nginx01 -v /etc/nginx nginx (P为随机端口)
docker volume ls 查看所有卷的情况，如下图就是匿名卷，匿名挂载（-v 只写容器内路径，没有写容器外路径）

具名挂载

docker run -d -P --name nginx02 -v chen-nginx:/etc/nginx nginx (P为随机端口)
注意：chen-ngin没有加/是名字不是路径
docker volume ls 查看所有卷的情况
docker volume inspect chen-nginx 查看卷路径
没有指定路径的情况 卷都会在/www/server/docker/volumes/chen-nginx/_data
docker run -d -P --name nginx02 -v chen-nginx:/etc/nginx:ro nginx 【ro为readonly设为只读，设置为只读，挂载出来的内容就有相应约束,，ro只能通过宿主机来操作，不能通过容器操作】
docker run -d -P --name nginx02 -v chen-nginx:/etc/nginx:rw nginx 【rw为readwrite设为可读写】

多个数据卷容器数据同步

docker run -it --name centos01 chen/centos 启动第一个容器
docker run -it --name centos02 --volumes-from centos01 chen/centos 通过–volumes-from相当于继承son extend father，绑定上数据同步
ctrl+p+q 退出容器不停止
docker attach fae490bc72b5 进入容器
cd volume01 进入数据卷
touch centos01.txt
ctrl+p+q 退出容器不停止
docker attach 5d13641c890f 进入容器2
cd volume01 进入数据卷
如下图，文件已同步到centos02容器的卷中

删除其中一个容器，并不影响其他容器，数据不会丢失

同步多个mysql

docker run -d -p 3310:3306 -e MYSQL_ROOT_PASSWORD=root -v /etc/mysql/conf.d -v /var/lib/mysql --name mysql01 mysql:5.7

docker run -d -p 3311:3306 -e MYSQL_ROOT_PASSWORD=root -v /etc/mysql/conf.d -v /var/lib/mysql --name mysql02 --volumes-from mysql01 mysql:5.7

dockerhub中99%镜像都是从FROM scratch过来的，然后配置需要的软件

Docker网络

三个网络

查看容器内部网络地址
docker exec -it tomcat01 ip addr

注意：
每启动一个docker容器，就会给docker分配一个ip；
只要安装docker，就会有一个网卡 docker0；
桥接模式，使用的技术是evth-pair。

启动tomcat
docker run -d --name tomcat01 -p 8081:8080 tomcat:9.0
在查看ip
ip addr
如下，多了一个277

再启动一个tomcat
docker run -d --name tomcat02 -P tomcat:9.0 (大写P表示随机端口)
在查看ip
ip addr
如下，又多了一个279

查看linux的ip
ip addr

查看容器内ip
docker exec -it tomcat02 ip addr

如上图，网卡是一对一对，并且宿主主机与容器是对应的。
这就是evth-pair技术，evth-pair就是一对虚拟设备接口，他们都是成对出现的，一端连着协议，一端相互相连。
正因为有这个特性，所以用evth-pair充当桥梁，连接各种虚拟网络设备

容器之间是可以互相ping通的
docker exec -it tomcat02 ping

结论：tomcat01 与 tomcat02 公用一个路由器docker0，所有容器不指定网络，都是docker0路由的，docker会给容器分配一个默认可用 IP 255.255.0.1/16 （16代表前面16位）
二进制 00000000.00000000.00000000.00000000
十进制 255.255.255.255

docker 网络

docker 中所有网络接口都是虚拟的，虚拟的转发效率高
只要删除容器，对应的网桥也没了

–link（实现高可用，通过名称访问，IP换了不影响）

启动tomcat03用–link连接tomcat02
docker run -d -P --name tomcat03 --link tomcat02 tomcat:9.0

用tomcat03 ping tomcat02
docker exec -it tomcat03 ping tomcat02
如下，可ping得通，可以实现高可用，也就是IP换了不影响，用名称直接可以访问

docker exec -it tomcat03 cat /etc/hosts

–link 就是我们在hosts配置中增加了一个tomcat02的映射

docker exec -it tomcat02 cat /etc/hosts 而反过来，查看 tomcat02并没有映射，–link并不是双向绑定

注意：现在已经不使用–link，一般使用自定义网络，docker0不支持容器名访问

自定义网络（容器互联）

docker network ls 查看docker网络

网络模式
bridge: 桥连（默认）
none: 不配置网络
host: 与宿主共享网络
container: 容器内网络连通（用的少，局限性很大）

创建一个网络，名叫mynet
–driver bridge
–subnet 192.168.0.0/16（192.168.0.2 - 192.168.255.255）
–gateway 192.168.0.1（默认的路由网关）

docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet

查看网络 docker network inspect mynet

常规默认启动 bridge
docker run -d -P --name tomcat01 --net bridge tomcat
改为我们自定义的网络启动
docker run -d -P --name tomcat01 --net mynet tomcat
再启动 tomcat02
docker run -d -P --name tomcat02 --net mynet tomcat
再查看网络 docker network inspect mynet ，如下有两个容器

用tomcat01去ping tomcat02的IP，可以ping通
docker exec -it tomcat01 ping 192.168.0.3

PING名字，也可以ping通
docker exec -it tomcat01 ping tomcat02

我们自定义的网络已经帮我们维护好对应的关系，包括双向连接。docker0（–link）并没有，所以推荐自定义网络
优点：
redis mysql 不同的集群使用不同的网络，保证集群安全与健康

连通
再启动一个容器 docker run -d -P --name tomcat03 tomcat
连通 docker network connect mynet tomcat03
查看自定义网络 docker network inspect mynet 已直接加入容器

部署redis集群

创建redis网络
docker network create redis --subnet 172.38.0.0/16
查看是否存在
docker inspect redis

通过shell脚本创建六个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

进入
cd /mydata/redis
可以看到6个节点

进入
cd node-1/conf

查看
cat redis.conf

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

redis只有 /bin/sh 没有 /bin/bash
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

查看集群信息
cluster info

查看节点
cluster nodes

设置一个值
set a b
如下，说明第三台在处理

再查看a
get a

然后停止第三台，再查看a还能不能获取到，判断高可用
docker stop redis-3
ctrl p+q 退出
再进入其中一台
docker exec -it redis-1 /bin/sh
进入集群
redis-cli -c
get a 如下可以看到在第四台出现a

Docker Compose

官网 https://docs.docker.com/compose/gettingstarted/

官网安装地址
curl -L “https://github.com/docker/compose/releases/download/1.28.5/docker-compose-$(uname-s)-$(uname -m)” -o /usr/local/bin/docker-compose

国内安装地址
curl -L https://get.daocloud.io/docker/compose/releases/download/1.25.4/docker-compose-uname -s-uname -m > /usr/local/bin/docker-compose

授权
chmod +x /usr/local/bin/docker-compose

查看版本，能看到版本号说明成功
docker-compose version

跟着官网Getting started一步步做下来
https://docs.docker.com/compose/gettingstarted/

建项目目录，并进入
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)

创建requirements.txt文件，并把以下代码黏贴进去

flask
redis

创建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
EXPOSE 5000
COPY . .
CMD ["flask", "run"]

创建docker-compose.yml文件，并把以下代码黏贴进去（定义两个服务web和redis）
docker-compose.yml 核心就三层，官网 https://docs.docker.com/compose/compose-file/compose-file-v3/
第一层，版本 version
第二层，服务 services
第三层，其他配置 volumes , networks , configs 等等

version: "3"
services:
  web:
    build: .
    ports:
      - "5000:5000"
  redis:
    image: "redis:alpine"

创建启动compose

docker-compose up

获取如下地址时，可能超时
fetch http://dl-cdn.alpinelinux.org/alpine/v3.12/community/x86_64/APKINDEX.tar.gz

解决方案，使用国内的alpine源，在Dockerfile中增加下面两行，cat /etc/apk/repositories 输出资源路径，记得把原来的image都先删掉

FROM alpine:3.7
RUN echo -e http://mirrors.ustc.edu.cn/alpine/v3.7/main/ >> /etc/apk/repositories
RUN cat /etc/apk/repositories

如下，成功


再另外打开客户端docker ps 查看有两个容器

查看网络
docker network ls

查看网络详情，如下同一个网段，所以可以通过上面app.py文件里面定义的host='redis’去访问
docker inspect composetest_default

用docker-compose搭建workpress

官方地址
https://docs.docker.com/compose/wordpress

创建目录
mkdir my_wordpress
cd my_wordpress/
vim docker-compose.yml

编写文件，黏贴如下代码

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: {}

运行

docker-compose up -d

用docker-compose搭建自己项目

1，编写项目

2，dokerfile 构建镜像

FROM adoptopenjdk/openjdk11

COPY *.jar /app.jar

CMD ["--server.port=8080"]

EXPOSE 8080

ENTRYPOINT ["java","-jar","/app.jar"]

3，docker-compose.yml 容器编排

version: "3"
services:
  chenapp:
    build: .
    image: chenapp
    depends_on:
      - redis
    ports:
      - "8080:8080"
  redis:
    image: "redis:alpine"

4，打jar包

5，上传到服务器 docker-compose up -d

6，打开另外窗口 curl 成功

docker-swarm

先查看docker swarm有什么命令

docker swarm --help

再查看init命令

docker swarm init --help

查看ip

ip addr

配置主节点

docker  swarm init --advertise-addr  218.5.81.140

加入节点

docker swarm join --token SWMTKN-1-4mv1b8z97l6i0rtokbxezho9nz85ihhfa6x79ehnygftduwr0u-a6w6sjqwrju1u0zmrxibhwwr3 218.5.81.140:2377

获取令牌

docker swarm join-token manage