狂神说Docker笔记

vdocker version/docker info 获取docker信息
docker run [镜像名]：例如 docker run hello.world 本地如果没有的话，回去dockerhub上下载，dockerhub上没有就报错
docker images:显示docker所有镜像（docker images -a）
docker images -q：显示所有镜像的id
docker version:显示docker版本
docker search mysql：检索mysql
docker search mysql --filter=STARS=3000 ：检索STARS大于3000的
docker pull mysql:会去dockerhub上下载mysql的最后一个
docker pull mysql:5.7:指定docker的下载版本
docker rmi -f [镜像id]：删除某个镜像id
docker rmi -f $(docker images -aq)：删除所有镜像
docker run -it centos /bin/bash：启动centos容器
docker ps：显示当前正在运行的容器
docker ps -a：显示所有运行的容器(包括以前的)
docker ps -a -n=1:显示第一条记录
docker ps -aq:显示当前所有容器的编号
退出容器：

exit:容器停止退出
ctrl+p+q:容器退出当前
删除容器：

docker rm 容器id:删除容器id，不能删除正在运行的
docker rm -f $(docker ps -aq)：删除所有容器
docker ps -a -q|xargs docker rm :删除所有容器
启动和停止容器操作:

docker start 容器id : 启动容器
docker restart 容器id ：重启容器
docker stop 容器id ：停止当前正在运行的容器
docker kill 容器id ：强制停止当前容器

常用其他命令：

后台启动容器：
docker run -d centos
问题：docker ps. 发现 centos停止了
常见的坑：docker 容器使用后台运行，就必须要有一个前台进程，docker发现没有应用，就会自动停止
nginx:容器启动后，发现自己没有提供服务，就会立即停止，就没有运行了

docker run -it centos /bin/bash
查看日志：

docker logs -f -t --tail 10 容器id
如果容器没有日志
“写一段shell脚本” “while true;do echo cxy;sleep 1;done”

查看容器中的进程信息：

docker top 容器id

查看镜像元数据:

docker inspect 容器id
进入当前正在运行的容器：

方式一：
我们容器都是使用后台方式运行的，需要进入容器，修改一些配置
docker exec -it 容器id /bin/bash (这个进入容器后打开新的终端，可以在里面操作)

方式二：
docker attach 容器id （进入容器正在执行的终端，不会启动新的进程）

从容器内拷贝文件到主机上：

docker cp 容器id:容器内路径 目的的主机路径
先进入容器内部 ：docker attach 容器id
在容器内部创建一个文件
然后拷贝到本地上

拷贝是一个手动过程，未来我们使用 -v 卷的技术，可以实现自动同步

docker安装nginx:

1.搜索镜像 search docker search nginx(建议去官网上)
2.下载镜像 docker pull nginx
后台启动：
-d 后台启动 --name 给容器命名 -p 宿主机:容器端口 暴露端口

进入容器：

停止容器:
docker stop 容器id

思考问题∶我们每次改动nginx配置文件，都需要进入容器内部?十分的麻烦，我要是可以在容器外部提供一个映射路径，达到在容器修改文件名，容器内部就可以自动修改?-v 数据卷!

docker安装tomcat:

官方的使用：
docker run -it --rm tomocat:9.0
我们之前启动都是后台，停止容器之后，容器还可以查到，加上-rm之后，
就是用完之后再删掉，一般用来测试

我们下载在启动：
docker run -d -p 3344:8080 --name tomcat01 tomcat
测试访问没有问题，但访问是404
进入容器：docker exec -it tomcat01 /bin/bash
发现，linux命令少了，没有webapps

原因：阿里云镜像的原因。默认是最小的镜像，所有不必要的都剔除了（保证最小可运行）。
思考问题∶我们以后要部署项目，如果每次都要进入容器是不是十分麻烦﹖我要是可以在容器外部提供一个映射路径， webapps ,我们在外部放置项目，就自动同步到内部就好了!

部署es+kibana:

es 暴露的端口很多
es 十分的耗内存
es 的数据一般需要放置到安全目录，挂载
–net somenetwork ? 网络配置
下载启动
docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e “discovery.type=single-node” elasticsearch:7.6.2
启动之后 linux就卡住了 docker stats 查看 cpu的状态

es是十分耗内存的
测试一下es是否成功启动了：

[root@cxy ~]# curl localhost:9200
{
  "name" : "d7beac08826b",
  "cluster_name" : "docker-cluster",
  "cluster_uuid" : "Xs5WdISyTue-hKmSFrTthQ",
  "version" : {
    "number" : "7.6.2",
    "build_flavor" : "default",
    "build_type" : "docker",
    "build_hash" : "ef48eb35cf30adf4db14086e8aabd07ef6fb113f",
    "build_date" : "2020-03-26T06:34:37.794943Z",
    "build_snapshot" : false,
    "lucene_version" : "8.4.0",
    "minimum_wire_compatibility_version" : "6.8.0",
    "minimum_index_compatibility_version" : "6.0.0-beta1"
  },
  "tagline" : "You Know, for Search"
}

​
赶紧关闭，增加内存的限制，修改配置文件 -e 环境配置修改
在启动加上：
最小64m 最大512m

docker run -d --name elasticsearch02 -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPTS="-Xms64m -Xmx512m" elasticsearch:7.6.2

[root@cxy ~]# curl localhost:9200
{
  "name" : "50e9699fc4eb",
  "cluster_name" : "docker-cluster",
  "cluster_uuid" : "Jcgr_NY1QG6TNdw9vgVCOQ",
  "version" : {
    "number" : "7.6.2",
    "build_flavor" : "default",
    "build_type" : "docker",
    "build_hash" : "ef48eb35cf30adf4db14086e8aabd07ef6fb113f",
    "build_date" : "2020-03-26T06:34:37.794943Z",
    "build_snapshot" : false,
    "lucene_version" : "8.4.0",
    "minimum_wire_compatibility_version" : "6.8.0",
    "minimum_index_compatibility_version" : "6.0.0-beta1"
  },
  "tagline" : "You Know, for Search"
}

作业：使用kibana连接es?思考网络如何才能连接过去

可视化：

portainer(先用这个，不是最好)

docker run -d -p 8088:9000 \
--restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer

Rancher(CI/CD再用)
什么是portainer ?
Docker 图形化界面管理工具！ 提供一个后台面板供我们操作！

docker run -d -p 8088:9000 \
--restart=always -v /var/run/docker.sock:/var/run/docker.sock --privileged=true portainer/portainer

访问测试：外网：8088

Docker镜像讲解

镜像是什么：
镜像是一种轻量级、可执行的独立软件包，用来打包软件运行环境和基于运行环境开发的软件，它包含运行某个软件所需的所有内容，包括代码、运行时、库、环境变量和配置文件。
所有的应用，直接打包docker镜像，就可以直接跑起来!
如何得到镜像∶

从远程仓库下载
朋友拷贝给你
自己制作一个镜像DockerFile

Docker镜像加载原理

UnionFS(联合文件系统)
UnionFS( 联合文件系统）:Union文件系统(UnionFS )是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into a single virtualfilesystem)。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, letc等标准目录和文件。rootfs就是各种不同的操作系统发行版，比如Ubuntu , Centos等等。

平时我们安装进虚拟机的CentOS都是好几个G，为什么Docker这里才200M ?

对于一个精简的OS , rootfs 可以很小，只需要包含最基本的命令，工具和程序库就可以了，因为底层直接用Host的kernel,自己只需要提供rootfs就可以了。由此可见对于不同的linux发行版, bootfs基本是一致的, rootfs会有差别,因此不同的发行版可以公用bootfs。
虚拟机是分钟级别的，容器是秒级的

Commit镜像：
docker commit 提交容器成为一个新的副本
命令和git相似：
docker commit -m=“提交的描述信息” -a=“作者” 容器id 目标镜像名:[TAG]

实战测试：
启动默认的tomcat
发现这个默认的tomcat 是没有webapps应用，镜像的原因，官方的镜像默认webapps下是没有镜像的
我自己拷贝去了基本的文件
将我们操作过的容器提供commit提交为一个镜像！我们以后就使用我们修改过的镜像即可

学习方式说明：理解概念，但是一定要实践，最后实践和理论相结合
如果你想保存当前容器的状态，就可以通过commit来提交,获取一个镜像

到了这里入门docker!

容器数据卷

什么是容器数据卷？
docker理念回顾

将应用和环境打包成一个镜像！
数据？如果数据都在容器中，那么我们容器删除，数据就会丢失 需求：数据可以持久化
MYSQL,容器删了，删库跑路！ 需求：MYSQL数据可以存储在本地
容器之间可以有一个数据共享的技术！Docker容器中产生数据，同步到本地
这就是卷技术！ 目录的挂载，将我们容器内的目录，挂载到linux上面！

总结一句话：容器的持久化和同步操作！容器间也可以数据共享

使用数据卷

方式一：直接使用命令挂载 -v
docker run -it -v 主机目录:容器内目录

这样外面的目录就会和centos下的home目录同步到容器内
通过docker inspect 容器id 查看：

容器内创建一个文件，外面同步（同样，外面添加里面也会同步）：

当我们把docker关闭之后，在主机修改test.java文件，再次重启centos 之后发现里面也同步了

好处：我们以后修改只需在本地修改即可，容器内会自动同步

实战：安装MYSQL

思考：MYSQL的持久化问题！
获取镜像：docker pull mysql:5.7
运行容器，需要做数据挂载 安装启动mysql，需要配置密码，这是要注意的
官方测试：docker run --name some-mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:tag

启动我们的：
-d 后台运行
-p 端口映射
-v 卷挂载
-e 环境配置
–name 容器名字
docker run -d -p 3310:3306 -v /usr/docker/mysql/conf:/etc/mysql/conf.d -v /usr/docker/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7

测试是否启动成功：

启动成功之后，我们在本地使用 navicate测试一下
在本地新建个数据库test，在linux上映射上来了：

假设我们将容器删除，发现挂载到本地的数据依旧没有删除

具名和匿名挂载
匿名挂载：
-v 容器内路径！
docker run -d -p --name nginx01 -v /etc/nginx nginx
通过docker volume ls 查看本地所有镜像

这里发现，这种就是匿名挂载，我们在 -v 只写了容器内路径，没写容器外的路径！

具名挂载： 通过 -v 卷名:容器内路径
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx nginx

查看一下这个卷：

所有的docker容器内的卷，没有指定目录的情况下都是在/var/lib/docker/volumes/juming-nginx/_data 下

通过具名挂载可以方便的找到我们的一个卷，大多数情况使用具名挂载

如何确定是具名挂载还是匿名挂载,还是指定路径挂载：
-v 容器内路径 匿名挂载
-v 卷名:容器内路径 具名挂载
-v /宿主机路径::容器内路径 指定路径挂载
拓展：
通过 -v 容器内路径：ro rw 改变独写权限
ro readonly 只读
rw readwrite 可读可写
一旦这个设置了容器权限，容器对我们挂载出来的内容就有限定了！
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx:ro nginx
docker run -d -P --name nginx02 -v juming-nginx:/etc/nginx:rw nginx

ro 只要看的ro就说明这个路径只能通过宿主机来操作，容器内都是无法操作！

初识DockerFile：
DockeFile：就是用来构建docker镜像的构建文件！命令脚本！先体验一下！
创建个dockefile1,通过这个脚本生成镜像，镜像是一层一层的，脚本一个一个的命令，每个命令都是一层
vim dockefile1
dockefile1文件内容 指令(大写) 参数
FROM centos
​
VOLUME [“volume01”,“volume02”]
​
CMD echo “----end----”
CMD /bin/bash
​
#这里的每个镜像，就是dockefile的一层
执行命令：
[root@cxy docker-test-volume]# docker build -f /usr/docker-test-volume/dockerfile1 -t cxy/centos .

启动自己的容器：

这个卷和外部一定有一个同步的目录！

docker inspect 容器id:

这种方式也可以同步出去
这种方式未来使用的非常多，因为我们同城会构建自己的镜像！
假设构建镜像时候没有挂载，要手动镜像挂载 -v 卷名

数据卷容器
多个mysql同步数据！

启动3个容器，通过刚才自己写的镜像启动
启动docker01:

启动docker02:
把docker02挂载在docker01上
docker run -it --name docker02 --volumes-from docker01 cxy/centos

可以发现，在docker01中创建的文件，在docker02中有也会出现

启动一个docker03:

发现数据都在：

我们在docker03中创建一个文件，发现在docker02,docker01上都有出现

测试，可以发现删除docker01，查看一下docker02和docker03都可以访问这个文件
测试依旧可以访问

多个mysql实现数据共享，同用一个数据库
docker run -d -p 3310:3306 -v /etc/mysql/conf.d -v /var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql01 mysql:5.7

docker run -d -p 3310:3306 -e MYSQL_ROOT_PASSWORD=123456 --name mysql02 mysql:5.7
这个时候可以实现两个容器数据同步
结论：
容器之间配置信息的传递，数据卷容器的生命周期一直持久到没有容器使用为止！
但是一旦你持久化到了本地，这个时候，本地的数据是不会被删除的！

DockerFile
DokcerFile介绍

dockerfile是用来构建docker镜像的文件！命令参数脚本！
构建步骤：
1.编写一个dockerfile文件
2.docker build 构建成为一个镜像
3.docker run运行镜像
4.docker push 发布镜像(DockerHub、阿里云镜像仓库)
查看一下官方是如何做的？

很多官方的镜像都是基础包，很多功能没有，我们通常自己搭建自己的镜像！
DockerFile构建过程

基础知识：
1.每个保留关键字(指令)都必须是大写字母
2.执行从上到下顺序执行
3.#表示注释
4.每一个指令都会创建提交一个新的镜像层，并提交

dockerfile是面向开发的，我们以后要发布项目，做镜像，就需要编写dockerfile文件，这个文件十分简单!
Docker镜像 逐渐成为企业交互的标准，必须要掌握！
步骤：开发、部署、运维。。。。缺一不可
DockerFile:构建文件，定义了一切的步骤，源代码
DockerImages:通过DockerFile构建生成的镜像，最终发布和运行的产品（原来是jar war）
Docker容器：容器就是镜像运行起来提供的服务器

DockerFile的指令：
FROM 基础镜像,一切从这里构建 centos unbutu
MAINTAINER 镜像是谁写的，姓名+邮箱
RUN 镜像构建的时候需要运行的命令
ADD 步骤：tomcat容器，这个tomcat压缩包！添加内容
WORKDIR 镜像的工作目录
VOLUME 挂载的目录
EXPOSE 暴露端口配置（和-p类似 ）
CMD 指定容器启动时候要运行的命令，只有最后一个会生效，可被替代
ENTRYPOINT 指定这个容器启动时候要运行的命令，可以追加命令
ONBUILD 当构建一个被继承DockerFile这个时候就会运行ONBUILD的指令！触发命令
COPY 类似ADD，将我们的文件拷贝到镜像中
ENV 构建的时候设置环境变量!

实战测试：
DockerHub中 99%镜像都是从这个基础镜像过了的FROM scratch,然后配置需要的软件和配置来进行构建

创建一个自己的centos:

#1.编写Dockerfile文件
#cat dockerfile-centos
FROM centos
​
MAINTAINER cxy2464051317@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
#2.通过这个文件构建镜像
#命令 docker build -f dockerfile文件路径 -t 镜像名:[tag]

测试运行（对比之前）：

我们增加之后的：

我们可以列出本地的变更历史：

CMD和ENTRYPOINT的区别

CMD 指定容器启动时候要运行的命令，只有最后一个会生效，可被替代
ENTRYPOINT 指定这个容器启动时候要运行的命令，可以追加命令

测试CMD：

build成功之后：

直接执行（run运行，只会运行最后一个CMD）
发先ls -a 运行成功

想追加一个命令 -l ls -al

cmd的情况下 -l 替换了CMD[“ls”,"-a"]命令， -l不是命令所以报错

测试ENTRYPOINT:

我们追加的命令，是直接拼接在ENTRYPOINT 命令的后面，而不是替换
！

Dockfile中很多命令都十分相似，我们需要了解它的区别，最好的学习就是对比学习型

实战:Tomcat镜像
1.准备镜像文件 tomcat,jdk压缩包

2.编写dockefile文件，官方命名 Dockerfile，会自动寻找这个文件，就不需要 -f 指定了

dockfile文件:
FROM centos
MAINTAINER cxy2464051317@qq.com
​
COPY readme.txt /usr/local/readme.txt
​
ADD jdk-8u144-linux-x64.tar.gz /usr/local/
ADD apache-tomcat-8.5.63.tar.gz /usr/local/
​
RUN yum -y install vim
ENV MYPATH /usr/local
WORKDIR $MYPATH
​
ENV JAVA_HOME /usr/local/jdk1.8.0_144
ENV CLASSPATH $JAV{A}_{H}OME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-8.5.63
ENV CATALINA_BASH /usr/local/apache-tomcat-8.5.63
ENV PATH $PATH:$JAVA_HOME/bin:$CATALIN{A}_{H}OME/lib:$CATALINA_HOME/bin
​
EXPOSE 8080
​
CMD /usr/local/apache-tomcat-8.5.63/bin/startup.sh && tail -F /usr/local/apache-tomcat-8.5.63/bin/logs/cat
alina.out
3.构建镜像：

docker build -t diytomcat .

4.查看发现自己定义的

5.启动镜像
docker run -d -p 9090:8080 --name cxytomcat -v /usr/local/bulid/tomcat/test:/usr/local/apache-tomcat-8.5.63/webapps/test -v /usr/local/bulid/tomcat/logs:/usr/local/apache-tomcat-8.5.63/logs diytomcat

6.访问测试

7.发布项目（由于做了挂载卷，我们直接在本地编写项目就可以发布了）

<?xml version="1.0" encoding="UTF-8"?>

<%@ page language=“java” contentType=“text/html; charset=UTF-8”
pageEncoding=“UTF-8”%>

Hello World!
发现启动成功：

发现：项目部署成功，可以直接访问ok

我们以后开发的步骤，需要掌握Dockfile的编写！我们之后的一起都是在dockerfile上运行

发布自己的镜像：
Dockerhub ：
1.地址https://hub.docker.com/r/marszh/cnetos7注册自己的账号！
2.确定这个账号可以登录
3.在我们服务器是提交自己的镜像
先登录：

4.登录完毕后就可以登录，就是一步 docker login -u cxy629

push自己的镜像到服务器上：

出现的错误：

解决，我们给当前的diytomcat加一个版本：
注意，这里面启动名字必须对应登录名称。否则会出现denied:requested…错误

提交的时候也是安装镜像的层级来进行提交的！

阿里云镜像服务上：
1.登录阿里云
2.找到容器镜像服务
3.创建命名空间

4.创建镜像仓库

5.浏览阿里云

阿里云容器镜像就参考官方地址就行了

小节：

Docker网络（铺垫）

理解Docker0

三个网络
问题：docker 是如何处理日期网络访问

测试

查看容器的内部网络地址 ip addr
发现容器启动的时候会得到一个eth0@if103 ip地址 docker分配的

思考：linux 能不能ping通容器内部（发现可以ping通）

原理：
1.我们每安装一个docker容器，docker就会给docker容器分配一个ip,我们只要安装了docker，就会有一个网卡docker0
桥接模式，使用的技术是evth-pair 技术！
查看ip:

查看tomcat01 ip:

查看 tomcat02 ip:

我没发现这个容器带来网卡，都是一对一对的
evth-pair 就是一对的虚拟设备接口，他们都是成对出现的，一端连接协议，一端彼此相连
正因为有这个特性，evth-pair充当一个桥梁，连接各种虚拟网络设备
OpenStac,Docker容器之间的连接，OVS的连接，都是使用evth-pair技术

3.我们来测试下tomcat01和tomcat02之间是否可以ping通

结论：容器之间是可以互相ping通的！
绘制一个图：

结论：tomcat01和tomcat02是公用一个路由器，docker0
所以容器不知道网络的情况下，都是docker0路由的，docker0会给我们分配一个默认可用的ip

Docker使用的是Linux的桥接，宿主机是一个Docker容器的网桥 docker0

Docker中的所有网络接口都是虚拟的。虚拟的转发效率高（内网转递文件！）
只要删除容器，对应网桥一对就没了

–link
思考一个场景，我们编写了一个微服务，database url=ip:，项目不重启，数据库ip换掉了，我们希望可以处理这个问题，可以名字来进行访问容器！

如何可以解决呢？
发现通过 --link就可以解决了
docker run -d -P --name tomcat03 --link tomcat02 tomcat

思考：tomcat02 可以ping通tomcat03吗？

为什么呢？

其实这个tomcat03就是在本地配置了tomcat02的配置
查看hosts配置，在这里原里发现！
docker exec -it tomcat03 cat /etc/hosts

本质探究：
–link 就是我们在hosts配置中增加了一个172.18.0.3 tomcat02 8b52fa8b1199
我们现在玩docker 已经不建议使用 --link了！
自定义网络，不适合docker0
docker0问题：它不支持容器名连接访问!

自定义网络：
查看所有的docker网络：

网络模式：

Bridge: 桥接 docker(默认)
none: 不配置网络
host: 和宿主机共享网络
container: 容器网络连通！（用的少）

测试：
我们直接启动的命令 --net bridge，而这个就是我们docker0
docker run -d -P --name tomcat01 tomcat
docker run -d -P --name tomcat01 --net bridge tomcat

docker0特点：默认，域名不能访问，–link可以打通连接（不建议使用）

我们可以自定义一个网络！
–driver bridge
–subnet 192.168.0.0/16
–gateway 192.168.0.
docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.0.1 mynet

自己的网络就创建好了：

启动tomcat01:
docker run -d -P --name tomcat-net-01 --net mynet tomcat
启动tomcat02:
docker run -d -P --name tomcat-net-02 --net mynet tomcat

发现，现在不使用–link也可以ping名字了
刚才ping不通的，现在可以ping通了
我们自定义的网络docker都已经帮我们维护好了对应的关系，推荐平时我们使用自定义网络！

好处：
redis:不同的集群使用不同的网络，保证集群是安全和健康的
mysql:不同的集群使用不同的网络，保证集群是安全和健康的

网络连通：

不能直接连通

测试打通 tomcat01 到 mynet
将tomcat01连接到mynet上：
docker network connect mynet tomcat01

连通之后就是将tomcat01放到了 mynet的网络下
一个容器两个ip地址
类似于阿里云：公网ip 私网ip

此时tomcat02没有打通，依旧ping不通

结论：假设要跨网络操作别人，就需要使用docker network connect 连通/。。。

实战：部署redis集群

shell脚本
docker network create redis --subnet 172.38.0.0/16
#通过建表创建六个redis配置
for port in KaTeX parse error: Undefined control sequence: \ at position 12: (seq 1 6); \̲ ̲do \ mkdir -p /…{port}/conf
touch /mydata/redis/node-$port/conf/redis.confcat<<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

#可以通过脚本一下一起全部启动
docker run -p 637$port:6379-p1637${port}:16379 --name redis-KaTeX parse error: Undefined control sequence: \ at position 8: {port} \̲ ̲-v /mydata/redi…{port}/data:/data
-v /mydata/redis/node-KaTeX parse error: Undefined control sequence: \ at position 46: …dis/redis.conf \̲ ̲-d --net redis …{port} redis:5.0.9-alpine3.11 redis-server /etc/redis/redis.conf
​
#开启服务node1
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
#开启服务node2
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
#开启服务node3
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
#开启服务node3
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
#开启服务node4
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
#开启服务node5
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
#开启服务node6
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-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 --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
docker exec -it redis-1 /bin/sh

redis-cli -c # -c是集群启动

三主三从：

此时 set a b，发现存入了redis-3中，此时我们关闭redis-3

然后我们get a
然后获取到，发现数据在redis-3的字节点上

使用docker之后，所以的技术都变的简单了起来！

SpringBoot微服务打包Docker镜像！

1.构建springboot项目
2.打包应用
3.编写dockerfile
FROM java:8
​
COPY *.jar /app.jar
​
CMD ["–serve.port=8080"]
​
EXPOSE 8080
​
ENTRYPOINT [“java”,"-jar","/app.jar"]
4.构建镜像

5.发布

企业实战

Docker Compose
1.安装：
curl -L https://get.daocloud.io/docker/compose/releases/download/1.25.5/docker-compose-uname -s-uname -m > /usr/local/bin/docker-compose

2.授权
sudo chmod +x docker-compose

3.体验
地址：https://docs.docker.com/compose/gettingstarted/

1.应用app.py
2.Dockfile 应用打包为镜像
3.Docker-compose.yml文件（定义整个服务，需要的环境，mysql,redis…） 完整的上线服务！
4.启动compose项目（docker-compose up）

流程：
1.创建网络
2.执行Docker-copmose.yaml
3.启动服务
Docker-compose.yaml

Creating composetest_redis_1 … done
Creating composetest_web_1 … done
1.文件名 composetest
2.服务
version: “2.3”
services:
web:
build: .
ports:
- “5000:5000”
redis:
image: “redis:alpine”

然后再docker-compose up,之后docker ps 查看是否启动成功

自动的默认规则？
docker images

默认的服务名 文件名——服务名——num
多个服务器，集群。A、B _num 副本数量
服务redis服务 =》4个副本。
集群状态。服务都不可能只有一个运行实例 实例 10 HA 高并发
kubectl service 负载均衡。

3.网络规则

10个服务 => 项目（项目中的内容都在同个网络下，域名可以访问）

docker inspect composetest_default

如果在同一个网络下，我们可以直接通过域名访问。

停止：docker-compse stop ctrl+c

docker-compose
以前都是单个docker run启动容器
docker-compose.通过docker-compse编写yaml配置文件，通过compose一键启动所有服务，停止！

Docker小节：
1.Docker镜像。 run=>容器
2.DockFile 构建镜像
3.docker-compse启动项目（编排、多个微服务/环境）
4.Docker网络
yaml规则：
docker-compse.yaml核心：
地址：https://docs.docker.com/compose/compose-file/compose-file-v2/

3层：
version: ‘’ #版本
services: #服务
服务1：web
#服务配置 docker
images
build
network
…
服务2：redis
…
服务3：redis
#其他配置 网络/卷、全局规则
volumns:
networks:
configs:

学习，要掌握规律！
多看多写，多看，compose.yaml配置！
1.官方文档
2.开源项目 compose.yaml

实战：开源项目
博客
下载程序、安装数据库、配置…
compose应用 => 一键启动

1.下载项目（docker-compose.yaml）
2.如果需要文件。Dockerfile
3.文件准备齐全(一键启动)
访问：http://8.133.238.116:8000/
注册之后登录：

前台启动：
docker -d
docker-compose up -d

掌握：docker 基础，原理，网络，服务，集群，错误排查，日志
linux docker k8s 12-20k

实战：计数器
1.编写项目微服务
2.dockfile构建镜像
3.docker-compose.yml编排项目
4.丢到服务器 docker-compose up

小节：
未来项目只要有docker-compose文件，按照这个规则，启动编排理解！
公司：docke-compose。直接启动
网上开源项目：docker-compose 一键搞定
假设项目需要重新部署打包：
docker-compose up --build #重新构建

总结：
工程、服务、容器
项目compose:三层
工程 Project
服务 服务
容器 运行实例！ docker k8s 容器 pods kubectl app

Docker Swarm

CI/CD jenkins 流水线