Docker学习总结
Docker概述
Docker的历史
2010年，几个搞IT的年轻人，在美国成立一家公司dotCloud
做一些pass的云计算服务！LXC有关的容器技术！
他们将自己的技术（容器化技术）命名位Docker！
docker刚刚诞生的时候，没有引起行业的注意！dotcloud，就活不下去！
开源 开放源代码！
2013年，Docker开源！
越来越多的人发现Docker的优点！火了，Docker每个月都会更新一个版本！
2014年4月9日，Docker1.0发布 ！
Docker为什么这么火？十分的轻巧！
在容器技术出来之前，我们都是使用虚拟机技术！
虚拟机：在windos里装一个Vmware，通过这个软件可以虚拟出来一台或者多台电脑！
虚拟机也是属于虚拟化技术，Docker容器技术也是一种虚拟化技术！
vm：linux centos原生镜像（一个电脑） 隔离，需要开启多个虚拟机！
docker：隔离，镜像（最核心的环境4m+jdk+mysql）十分的小巧
到现在，所有开发人员都必须会Docker！
聊聊Docker
Docker是基于Go语言开发的！开源项目！
官网：www.docker.com
文档：https://docs.docker.com Docker的文档是非常详细的！
Docker能干嘛
之前的虚拟机技术
虚拟机技术缺点：
1、资源占用十分多
2、冗余步骤多
3、启动很慢！
容器技术
比较docker和虚拟机技术的不同：
- 传统虚拟机，虚拟出一条硬件，运行一个完整的操作系统，然后这这个操作系统上安装和运行软件
- 容器内的应用直接运行在宿主机的内容，容器时没有自己的内核的，也没有虚拟我们的硬件，所以很轻便！
- 没个容器间相互隔离，没个容器内都有一个属于自己的文件环境，互不影响。
DevOps（开发、运维）
应用更快速的交付和部署
传统：一堆帮助文档，安装程序
Docker：打包镜像发布测试，一键运行
更便捷的升级和扩缩容
使用Docker之后，我们部署应用就像搭积木一样！
项目打包为一个镜像，拓展 服务器A！服务器B
更简单的系统运维
在容器化之后，开发、测试环境高度一致
更高效的计算资源利用
Docker时内核级别的虚拟化，可以在一个物理机上可以运行很多的容器实例！服务器的性能可以运行到极致！
Docker安装
Docker的基本组成
镜像（image）：
docker镜像就好比一个模板，可以通过这个模板来创建容器服务，tomcat镜像-----> run---->tomcat01容器（提供服务器）
容器（container）：
docker利用容器技术，独立运行一个或者一组应用，通过镜像来创建的。
启动，停止、删除、基本命令！
可以把这个理解为一个简易的linux系统
仓库（repository）：
仓库就是存放镜像的地方！
仓库分为公有镜像和私有镜像！
Docker Hub（默认是国外的）
阿里云...都有容器服务器（配置镜像加速！）
安装Docker
环境查看
#系统内核是3.10以上
[root@localhost ~]# uname -r
3.10.0-1127.13.1.el7.x86_64
#系统版本
[root@localhost ~]# 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"
安装
查看帮助文档：
1、清除以前的版本
#卸载以前的Docker
yum -y remove docker docker-common docker-selinux docker-engine
# 官网版本
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、设置stable镜像仓库
# 正确推荐使用国内的
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
4、更新yum软件包索引
yum makecache fast
5、安装Docker CE
yum -y install docker-ce docker-ce-cli containerd.io
6、启动Docker
systemctl start docker
7、测试
docker version
docker run hello-world
docker images
了解：卸载docker
#卸载依赖
yum remove docker-ce docker-ce-cli containerd.io
#删除资源
rm -rf /var/lib/docker
# /var/lib/docker docker的默认工作路径！
阿里云镜像加速
1、登陆阿里云找到容器镜像服务
2、找到镜像加速器
3、配置使用
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
"registry-mirrors": ["https://rmd29y8y.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker
回顾Hello World流程
底层原理
Docker是怎么工作的？
Docker是一个Client - Server结构的系统，Docker的守护进程运行在主机上。通过Socket从客户端访问。
Docker Server接受到docker-client的指令，就会执行这个命令。
Docker为什么比VM快？
1、Docker有着比虚拟机更少的抽象层。
2、Docker利用的是宿主机的内核，VM需要Guest OS。
所以说，新建一个容器的时候iu，dockers不需要像虚拟机一样重新加载一个操作系统内核，避免引导。虚拟机是加载Guest OS，分钟级别的
而docker是利用宿主机的操作系统，省略了复杂的过程，秒级
Docker命令
帮助命令
docker version #显示docker的版本信息
docker info #详细信息
docker 命令 --help #帮助命令
帮助文档地址：https://docs.dochttps😕/docs.docker.com/engine/reference/commandline/ker.com/engine/reference/commandline/
镜像命令
docker images 查看镜像列表
[root@localhost ~]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
hello-world latest bf756fb1ae65 7 months ago 13.3kB
#解释
REPOSITORY 镜像的仓库源
TAG 镜像的标签
IMAGE ID 镜像的ID
CREATED 镜像的创建时间
SIZE 镜像的大小
#可选项
-a #列出所有镜像
-q #只显示镜像的ID
docker search 搜索镜像
[root@localhost ~]# docker search mysql
NAME DESCRIPTION STARS OFFICIAL AUTOMATED
mysql MySQL is a widely used, open-source relation… 9838 [OK]
mariadb MariaDB is a community-developed fork of MyS… 3591 [OK]
mysql/mysql-server Optimized MySQL Server Docker images. Create… 719 [OK]
percona Percona Server is a fork of the MySQL relati… 502 [OK]
#可选项，通过搜索来过滤
--filter=STARS=3000 #搜索出来的镜像就是STARS大于3000的
docker pull 下载镜像
# 下载镜像 docker pull 镜像名[:tag]
[root@localhost ~]# docker pull mysql
Using default tag: latest #如果不写tag，默认就是最新版
latest: Pulling from library/mysql
bf5952930446: Pull complete #分层下载 docker image 的核心 联合文件系统
8254623a9871: Pull complete
938e3e06dac4: Pull complete
ea28ebf28884: Pull complete
f3cef38785c2: Pull complete
894f9792565a: Pull complete
1d8a57523420: Pull complete
6c676912929f: Pull complete
ff39fdb566b4: Pull complete
fff872988aba: Pull complete
4d34e365ae68: Pull complete
7886ee20621e: Pull complete
Digest: sha256:c358e72e100ab493a0304bda35e6f239db2ec8c9bb836d8a427ac34307d074ed #签名
Status: Downloaded newer image for mysql:latest
docker.io/library/mysql:latest #真实地址
docker rmi 删除镜像
[root@localhost ~]docker rmi -f 容器id #删除指定的id
[root@localhost ~]dicker rmi -f 容器id 容器id 容器id #删除多个容器
[root@localhost ~]docker rmi -f $(docker images -aq) #删除全部镜像
容器命令
说明：有了镜像才可以创建容器，下载centos镜像
docker pull centos
新建容器并启动
docker run[可选参数] image
#参数说明
--name="Name" 容器名字 tomcat01 tomcat02，用来区分容器
-d 后台方式运行
-it 使用交互方式运行，进入容器查看内容
-p 指定容器的端口 -p 8080:8080
-p 主机端口：容器端口(常用)
-p 容器端口
容器端口
-P 随机指定端口
#测试，启动并进入容器
[root@localhost ~]# docker run -it centos /bin/bash
[root@2f787f69166a /]# ls #查看容器内centos 基础命令 很多命令都是不完善的
bin dev etc home lib lib64 lost+found media mnt opt proc root run sbin srv sys tmp usr var
exit 退出容器
列出所有的运行中的容器
#docker ps #列出正在运行的容器
-a #显示正在运行的容器+带出历史运行过的容器
-n=？#显示最近创建的容器
-q #只显示容器的编号
退出容器
exit #直接退出容器
ctrl + p + q #不停止容器退出
删除容器
docker rm 容器id #删除指定的容器，不能删除运行中的容器
docker rm -f $(docker ps -aq) #强制删除所有容器
启动和停止容器的操作
docker start 容器id #启动容器
docker restart 容器id #重启容器
docker stop 容器id #停止当前正在运行的容器
docker kill 容器id #强制停止正在运行的容器
常用其他命令
后台启动容器
#命令 docker run -d 镜像名
[root@localhost ~]# docker run -d centos
# 问题docker ps，发现centos停止了
#常见的坑，docker容器使用后台运行，就必须要有一个 前台进程，docker发现没有应用，就会自动停止
#nginx，容器启动后，发现自己没有提供服务，就会立刻停止，就是没有程序了
查看日志命令
docker logs -tf 容器 #查看全部日志
docker logs -tf --tail 条数 容器 #查看指定条数日志
查看容器中进程信息ps
#命令 docker top 容器id # 查看进程信息
查看镜像的元数据
docker inspect 容器id
进入当前正在运行的容器
#我们通常容器都是使用后台方式运行的，需要进入容器，修改一些配置
#命令
docker exex -it 容器id /bin/bash #进入当前运行容器
#方式二
docker attach 容器id
#docker exec #进入容器开启一个新的终端
#docker attach #进入容器正在执行的终端，不会启动新的进程
从容器内拷贝文件到主机上
docker cp 容器id：容器内路径 目的主机路径
#查看镜像
[root@localhost ~]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
centos latest 0d120b6ccaa8 4 days ago 215MB
#进入容器
[root@localhost ~]# docker run -it centos
[root@1c5fa54eea90 /]# cd home
[root@1c5fa54eea90 home]# touch a.java
[root@1c5fa54eea90 home]# [root@localhost ~]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
1c5fa54eea90 centos "/bin/bash" 55 seconds ago Up 54 seconds friendly_mccarthy
#将文件拷贝到主机上
[root@localhost ~]# docker cp 1c5fa54eea90:/home/a.java /home
[root@localhost ~]# cd /home
[root@localhost home]# ls
a.java linux
#拷贝是一个手工过程，将来可以使用 -V卷的技术实现
小结
Docker镜像
镜像是什么
镜像是一种轻量级、可执行的独立软件保，用来打包软件运行环境和基于运行环境开发的软件，他包含运行某个软件所需的所有内容，包括代码、运行时库、环境变量和配置文件
Docker镜像加载原理
UnionFs （联合文件系统）
UnionFs（联合文件系统）：Union文件系统（UnionFs）是一种分层、轻量级并且高性能的文件系统，他支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下（ unite several directories into a single virtual filesystem)。Union文件系统是 Docker镜像的基础。镜像可以通过分层来进行继承，基于基础镜像（没有父镜像），可以制作各种具体的应用镜像
特性：一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统，联合加载会把各层文件系统叠加起来，这样最终的文件系统会包含所有底层的文件和目录
Docker镜像加载原理
docker的镜像实际上由一层一层的文件系统组成，这种层级的文件系统UnionFS。
boots(boot file system）主要包含 bootloader和 Kernel, bootloader主要是引导加 kernel, Linux刚启动时会加bootfs文件系统，在 Docker镜像的最底层是 boots。这一层与我们典型的Linux/Unix系统是一样的，包含boot加載器和内核。当boot加载完成之后整个内核就都在内存中了，此时内存的使用权已由 bootfs转交给内核，此时系统也会卸载bootfs。
rootfs（root file system),在 bootfs之上。包含的就是典型 Linux系统中的/dev,/proc,/bin,/etc等标准目录和文件。 rootfs就是各种不同的操作系统发行版，比如 Ubuntu, Centos等等。
平时我们安装进虚拟机的CentOS都是好几个G，为什么Docker这里才200M？
对于个精简的OS,rootfs可以很小，只需要包合最基本的命令，工具和程序库就可以了，因为底层直接用Host的kernel，自己只需要提供rootfs就可以了。由此可见对于不同的Linux发行版， boots基本是一致的， rootfs会有差別，因此不同的发行版可以公用bootfs.
虚拟机是分钟级别，容器是秒级！
分层理解
分层的镜像
我们可以去下载一个镜像，注意观察下载的日志输出，可以看到是一层层的在下载
思考：为什么Docker镜像要采用这种分层的结构呢？
最大的好处，我觉得莫过于资源共享了！比如有多个镜像都从相同的Base镜像构建而来，那么宿主机只需在磁盘上保留一份base镜像，同时内存中也只需要加载一份base镜像，这样就可以为所有的容器服务了，而且镜像的每一层都可以被共享。
查看镜像分层的方式可以通过docker image inspect 命令
➜ / docker image inspect redis
[
{
"Id": "sha256:f9b9909726890b00d2098081642edf32e5211b7ab53563929a47f250bcdc1d7c",
"RepoTags": [
"redis:latest"
],
"RepoDigests": [
"redis@sha256:399a9b17b8522e24fbe2fd3b42474d4bb668d3994153c4b5d38c3dafd5903e32"
],
"Parent": "",
"Comment": "",
"Created": "2020-05-02T01:40:19.112130797Z",
"Container": "d30c0bcea88561bc5139821227d2199bb027eeba9083f90c701891b4affce3bc",
"ContainerConfig": {
"Hostname": "d30c0bcea885",
"Domainname": "",
"User": "",
"AttachStdin": false,
"AttachStdout": false,
"AttachStderr": false,
"ExposedPorts": {
"6379/tcp": {}
},
"Tty": false,
"OpenStdin": false,
"StdinOnce": false,
"Env": [
"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
"GOSU_VERSION=1.12",
"REDIS_VERSION=6.0.1",
"REDIS_DOWNLOAD_URL=http://download.redis.io/releases/redis-6.0.1.tar.gz",
"REDIS_DOWNLOAD_SHA=b8756e430479edc162ba9c44dc89ac394316cd482f2dc6b91bcd5fe12593f273"
],
"Cmd": [
"/bin/sh",
"-c",
"#(nop) ",
"CMD [\"redis-server\"]"
],
"ArgsEscaped": true,
"Image": "sha256:704c602fa36f41a6d2d08e49bd2319ccd6915418f545c838416318b3c29811e0",
"Volumes": {
"/data": {}
},
"WorkingDir": "/data",
"Entrypoint": [
"docker-entrypoint.sh"
],
"OnBuild": null,
"Labels": {}
},
"DockerVersion": "18.09.7",
"Author": "",
"Config": {
"Hostname": "",
"Domainname": "",
"User": "",
"AttachStdin": false,
"AttachStdout": false,
"AttachStderr": false,
"ExposedPorts": {
"6379/tcp": {}
},
"Tty": false,
"OpenStdin": false,
"StdinOnce": false,
"Env": [
"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
"GOSU_VERSION=1.12",
"REDIS_VERSION=6.0.1",
"REDIS_DOWNLOAD_URL=http://download.redis.io/releases/redis-6.0.1.tar.gz",
"REDIS_DOWNLOAD_SHA=b8756e430479edc162ba9c44dc89ac394316cd482f2dc6b91bcd5fe12593f273"
],
"Cmd": [
"redis-server"
],
"ArgsEscaped": true,
"Image": "sha256:704c602fa36f41a6d2d08e49bd2319ccd6915418f545c838416318b3c29811e0",
"Volumes": {
"/data": {}
},
"WorkingDir": "/data",
"Entrypoint": [
"docker-entrypoint.sh"
],
"OnBuild": null,
"Labels": null
},
"Architecture": "amd64",
"Os": "linux",
"Size": 104101893,
"VirtualSize": 104101893,
"GraphDriver": {
"Data": {
"LowerDir": "/var/lib/docker/overlay2/adea96bbe6518657dc2d4c6331a807eea70567144abda686588ef6c3bb0d778a/diff:/var/lib/docker/overlay2/66abd822d34dc6446e6bebe73721dfd1dc497c2c8063c43ffb8cf8140e2caeb6/diff:/var/lib/docker/overlay2/d19d24fb6a24801c5fa639c1d979d19f3f17196b3c6dde96d3b69cd2ad07ba8a/diff:/var/lib/docker/overlay2/a1e95aae5e09ca6df4f71b542c86c677b884f5280c1d3e3a1111b13644b221f9/diff:/var/lib/docker/overlay2/cd90f7a9cd0227c1db29ea992e889e4e6af057d9ab2835dd18a67a019c18bab4/diff",
"MergedDir": "/var/lib/docker/overlay2/afa1de233453b60686a3847854624ef191d7bc317fb01e015b4f06671139fb11/merged",
"UpperDir": "/var/lib/docker/overlay2/afa1de233453b60686a3847854624ef191d7bc317fb01e015b4f06671139fb11/diff",
"WorkDir": "/var/lib/docker/overlay2/afa1de233453b60686a3847854624ef191d7bc317fb01e015b4f06671139fb11/work"
},
"Name": "overlay2"
},
"RootFS": {
"Type": "layers",
"Layers": [
"sha256:c2adabaecedbda0af72b153c6499a0555f3a769d52370469d8f6bd6328af9b13",
"sha256:744315296a49be711c312dfa1b3a80516116f78c437367ff0bc678da1123e990",
"sha256:379ef5d5cb402a5538413d7285b21aa58a560882d15f1f553f7868dc4b66afa8",
"sha256:d00fd460effb7b066760f97447c071492d471c5176d05b8af1751806a1f905f8",
"sha256:4d0c196331523cfed7bf5bafd616ecb3855256838d850b6f3d5fba911f6c4123",
"sha256:98b4a6242af2536383425ba2d6de033a510e049d9ca07ff501b95052da76e894"
]
},
"Metadata": {
"LastTagTime": "0001-01-01T00:00:00Z"
}
}
]
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118
理解：
所有的 Docker镜像都起始于一个基础镜像层，当进行修改或培加新的内容时，就会在当前镜像层之上，创建新的镜像层。
举一个简单的例子，假如基于 Ubuntu Linux16.04创建一个新的镜像，这就是新镜像的第一层；如果在该镜像中添加 Python包，
就会在基础镜像层之上创建第二个镜像层；如果继续添加一个安全补丁，就会创健第三个镜像层该像当前已经包含3个镜像层，如下图所示（这只是一个用于演示的很简单的例子）。
在添加额外的镜像层的同时，镜像始终保持是当前所有镜像的组合，理解这一点非常重要。下图中举了一个简单的例子，每个镜像层包含3个文件，而镜像包含了来自两个镜像层的6个文件。
上图中的镜像层跟之前图中的略有区別，主要目的是便于展示文件
下图中展示了一个稍微复杂的三层镜像，在外部看来整个镜像只有6个文件，这是因为最上层中的文件7是文件5的一个更新版
文种情況下，上层镜像层中的文件覆盖了底层镜像层中的文件。这样就使得文件的更新版本作为一个新镜像层添加到镜像当中
Docker通过存储引擎（新版本采用快照机制）的方式来实现镜像层堆栈，并保证多镜像层对外展示为统一的文件系统
Linux上可用的存储引撃有AUFS、 Overlay2、 Device Mapper、Btrfs以及ZFS。顾名思义，每种存储引擎都基于 Linux中对应的
件系统或者块设备技术，井且每种存储引擎都有其独有的性能特点。
Docker在 Windows上仅支持 windowsfilter 一种存储引擎，该引擎基于NTFS文件系统之上实现了分层和CoW [1]。
下图展示了与系统显示相同的三层镜像。所有镜像层堆并合井，对外提供统一的视图
特点
Docker 镜像都是只读的，当容器启动时，一个新的可写层加载到镜像的顶部！
这一层就是我们通常说的容器层，容器之下的都叫镜像层！
commit镜像
docker commit 提交容器成为一个新的副本
# 命令和git原理类似
docker commit -m="描述信息" -a="作者" 容器id 目标镜像名:[TAG]
1234
实战测试
# 1、启动一个默认的tomcat
docker run -d -p 8080:8080 tomcat
# 2、发现这个默认的tomcat 是没有webapps应用，官方的镜像默认webapps下面是没有文件的！
docker exec -it 容器id
# 3、拷贝文件进去
# 4、将操作过的容器通过commit调教为一个镜像！我们以后就使用我们修改过的镜像即可，这就是我们自己的一个修改的镜像。
docker commit -m="描述信息" -a="作者" 容器id 目标镜像名:[TAG]
docker commit -a="kuangshen" -m="add webapps app" 容器id tomcat02:1.0
123456789
如果你想要保存当前容器的状态，就可以通过commit来提交，获得一个镜像，就好比我们我们使用虚拟机的快照。
入门成功！！！！
发布自己的镜像
发布到阿里云
1、登陆阿里云
2、找到容器镜像服务
3、创建命名空间
4、创建容器镜像
5、浏览信息
#登陆
[root@localhost tomcat]# sudo docker login --username=tb44500353 registry.cn-chengdu.aliyuncs.com
#设置版本号
[root@localhost tomcat]# docker tag c1388c40775f registry.cn-chengdu.aliyuncs.com/dq-test/dq:1.0
#上传镜像
[root@localhost tomcat]# docker push registry.cn-chengdu.aliyuncs.com/dq-test/dq:1.0
#拉取镜像
[root@localhost tomcat]# docker pull registry.cn-chengdu.aliyuncs.com/dq-test/dq:1.0
阿里云镜像操作参考官方地址
小结
作业练习
Docker 安装 Nginx
# 1、搜索镜像 search
# 2、下载镜像 pull
# 3、运行测试
[root@localhost home]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
nginx latest 4bb46517cac3 34 hours ago 133MB
centos latest 0d120b6ccaa8 4 days ago 215MB
# -d 后台运行
# --name 给容器命名
# -p 宿主机端口:容器内部端口
[root@localhost home]# docker run -d --name nginx01 -p 3344:80 nginx
71e9b522e1b14e3af1d71159151fe0615baf3495bac8884f20fd2fff0e3c0fcb
# 进入容器
[root@localhost home]# docker exec -it nginx01 /bin/bash
root@71e9b522e1b1:/# cd /etc/nginx
root@71e9b522e1b1:/etc/nginx# ls
conf.d koi-utf mime.types nginx.conf uwsgi_params
fastcgi_params koi-win modules scgi_params win-utf
root@71e9b522e1b1:/etc/nginx#
Docker安装tomcat
#下载tomcat
[root@localhost home]# docker pull tomcat
#启动运行
[root@localhost home]# docker run -d -p 3355:8080 --name tomcat01 tomcat
8cd0580424900557bd578972aa82b7f5a629fdad743145f65c8952df78a50e43
#进入容器
docker exec -it tomcat01 /bin/bash
#发现问题：
1、linux命令少了
2、没有webapps。
#保证最小可运行的环境
可视化
- portainer
docker run -p 9000:9000 --name prtainer --restart=always -v /var/run/docker.sock:/var/run/docker.sock -d portainer/portainer
- Rancher(CI/CD再用)
什么是portainer？
Docker图形化界面管理工具！提供一个后台面板提供我们操作！
docker run -p 9000:9000 --name prtainer --restart=always -v /var/run/docker.sock:/var/run/docker.sock -d portainer/portainer
容器数据卷
什么是容器数据卷
docker的理念回顾
将应用和环境打包成一个镜像！
数据？如果数据都在容器中，那么我们容器删除，数据就会丢失！需求：数据可以持久化
Mysql，容器删了，删库跑路需求：Mysql数据可以存储到本地！
容器之间可以有一个数据共享的技术！docker容器中产生的数据，同步到本地！
这就是卷技术！目录的挂载，将我们容器内的目录，挂载到linux上面！
容器的持久化和同步操作！容器间也可以数据共享！
使用数据卷
方式一：直接使用命令来挂载 -v
docker run -it -v 主机目录:容器内目录
#测试
docker run -it -v /home/ceshi:/home centos /bin/bash
好处：修改在本地修改即可，容器内自动同步！
实战：安装Mysql
思考：Mysql的数据持久化的问题
#获取镜像
[root@localhost ~]# docker pull mysql:5.7
#运行容器，需要做数据挂载
#安装启动mysql，需要配置密码！注意！！！
#启动
-d 后台运行
-p 端口映射
-v 卷挂载
-e 环境配置
--name 容器名字
[root@localhost ~]# docker run -d -p 3310: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
#启动成功之后测试成功
具名和匿名挂载
#匿名挂载
-v 容器内路径！
docker run -d -P --name nginx01 -v /etc/nginx nginx
#查看所有的volume 的情况
[root@localhost ~]# docker volume ls
DRIVER VOLUME NAME
local fcfbf49b13df5301ddb3b6be63d0ab039c3326cc7517747061f6f0e7e0f4391d
#如上所示就是匿名挂载 只给定了容器内路径
#具名挂载
[root@localhost ~]# docker run -d -P --name nginx001 -v juming:/etc/nginx nginx
7daaa6abb95d862080c18df3188039df0ead7989105212e092c10ed5470a656f
[root@localhost ~]# docker volume ls
DRIVER VOLUME NAME
local fcfbf49b13df5301ddb3b6be63d0ab039c3326cc7517747061f6f0e7e0f4391d
local juming
#通过 -v 卷名：容器内路径
#查看一下这个卷
[root@localhost ~]# docker volume inspect juming
[
{
"CreatedAt": "2020-08-16T17:26:45+08:00",
"Driver": "local",
"Labels": null,
"Mountpoint": "/var/lib/docker/volumes/juming/_data",
"Name": "juming",
"Options": null,
"Scope": "local"
}
]
所有的docker容器内的卷，没有指定目录的情况下都是在/var/lib/docker/volume/xxx/_data
我们可以通过具名挂载方便的找到我们要查看的卷，大多数情况下使用具名挂载
#如何确定是具名挂载还是匿名挂载，还是指定路径挂载！
-v 容器内路径 #匿名挂载
-v 卷名:宿主机路径 #具名挂载
-v /宿主机路径：容器内路径 #指定路径挂载！
拓展：
#通过 -v 容器内路径:ro rw改变读写权限
ro readonly #只读
rw readwrite #可读写
#一旦设定容器权限，容器对我们挂载出来的内容就有限定了！
docker run -d -P --name nginx2 -v juming:/etc/nginx:ro nginx
docker run -d -P --name nginx2 -v juming:/etc/nginx:rw nginx
#ro 只要看到ro就说明这个路径只能通过宿主机来操作
初始DockerFile
Dockerfile就是用来构建docker镜像的构建文件！命令脚本
通过这个脚本可以生成镜像，镜像是一层一层的，脚本一个个的命令，每一个命令是一层
#创建一个dockerfile文件，
#文件中的内容 指令（大写） 参数
FROM centos
VOLUME ["volume01","volume02"]
CMD echo "----end----"
CMD /bin/bash
#这里的每个命令都是镜像的一层
[root@localhost home]# mkdir docker-test-volume
[root@localhost home]# ls
a.java docker-test-volume linux mysql
[root@localhost home]# cd docker-test-volume/
[root@localhost docker-test-volume]# vim dockerfile
#构建镜像
[root@localhost docker-test-volume]# docker build -f /home/docker-test-volume/dockerfile -t dq/centos:1.0 .
Sending build context to Docker daemon 2.048kB
Step 1/4 : FROM centos
latest: Pulling from library/centos
3c72a8ed6814: Pull complete
Digest: sha256:76d24f3ba3317fa945743bb3746fbaf3a0b752f10b10376960de01da70685fbd
Status: Downloaded newer image for centos:latest
---> 0d120b6ccaa8
Step 2/4 : VOLUME ["volume01","volume02"]
---> Running in d82ce6ba7de8
Removing intermediate container d82ce6ba7de8
---> b9ed978decb5
Step 3/4 : CMD echo "----end----"
---> Running in cad4c70457c5
Removing intermediate container cad4c70457c5
---> 45f89273de39
Step 4/4 : CMD /bin/bash
---> Running in 63fd154ae6eb
Removing intermediate container 63fd154ae6eb
---> 252ec79bb24c
Successfully built 252ec79bb24c
Successfully tagged dq/centos:1.0
启动自己构建的容器
[root@localhost docker-test-volume]# docker run -it 252ec79bb24c /bin/bash
[root@0a61fbc00364 /]# ls
bin dev etc home lib lib64 lost+found media mnt opt proc root run sbin srv sys tmp usr var volume01 volume02
#发现自己挂载的目录 这个卷和外部有一个同步的目录 匿名挂载
查看挂载的路径
[root@0a61fbc00364 /]# [root@localhost docker-test-volume]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
0a61fbc00364 252ec79bb24c "/bin/bash" 5 minutes ago Up 5 minutes magical_haslett
#查看容器信息
[root@localhost docker-test-volume]# docker inspect 0a61fbc00364
数据卷容器
多个Mysql同步数据！
#docker run -it -name docker03 --volumes-from docker01 dq/contos:1.0
此时，两个容器间的数据可以共享，同步！
#删除docker01这个容器，docker03中数据依然存在，其实就是冗余！
多个Mysql实现数据共享
[root@dq ]# 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
[root@dq ]# docker run -d -p 3310:3306 -e MYSQL_ROOT_PASSWORD=123456 --name mysql02 --volumes-from mysql01 mysql:5.7
#这时，可以实现两个容器数据同步！
结论：
容器之间配置信息的传递，数据卷容器的生命周期一直持续到没有容器使用为止。
但是一旦你持久化到本地，这个时候，本地数据是不会删除的。
Dockerfile
Dockerfile介绍
dockerfile是用来构建docker镜像的文件！命令参数脚本！
构建步骤：
-
编写一个dockerfile文件
-
docker build 构建成为一个镜像
-
docker run 运行镜像
-
docker pull 发布镜像
很多官方镜像都是基础包，很多功能没有，我们通常自己搭建自己的镜像！
Dockerfile的构建过程
基础知识：
-
每个保留关键字（指令）都必须是大写字母
-
执行从上到下顺序执行
-
#表示注释
-
每一个指令都会创建提交一个新的镜像层并提交！
-
dockerfile是面向开发的，开发项目，做镜像，就需要编写dockerdile文件，十分简单！
docker镜像逐渐成为企业交付标准，必须掌握！
步骤：开发、部署、上线、运维。
Dockerfile：构建文件，定义了一切的步骤，源代码
Dockerimages:通过dockerfile构建生成的镜像，最终发布和运行的产品！
Docker容器：容器就是镜像运行起来提供服务！
DockerFile的指令
FROM #基础镜像，一切从这里开始构建
MAINTAINER #镜像作者 姓名+邮箱
RUN #镜像构建的时候需要运行的命令
ADD #步骤：tomcat镜像，tomcat压缩包！添加内容
WORKDIR #镜像的工作目录
VOLUME #挂载的目录
EXPOSE #暴露端口配置
CMD #指定这个容器启动的时候运行的命令 只有最后一个会生效
ENTRYPOINT #指定这个容器启动的时候运行的命令 可以追加命令
ONBUILD #当构建一个被继承Dockerfile 这个时候就会运行ONBUILD
COPY #类似ADD，将我们文件拷贝到镜像中
ENV #构建的时候设置环境变量！
实战测试
最基础的镜像FROM scratch
创建一个自己的centos
# 1、编写Dockerfile文件
[root@localhost dockerfile]# cat mydockerfile-centos
FROM centos
MAINTAINER dq
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 镜像名：版本 .
[root@localhost dockerfile]# docker build -f mydockerfile-centos -t my-centos:0.1 .
# 3、测试运行
运行镜像可以使用添加的功能例如：vim、ifconfig
CMD和ENTRYPOINT的区别
CMD #指定这个容器启动的时候运行的命令 只有最后一个会生效
ENTRYPOINT #指定这个容器启动的时候运行的命令 可以追加命令
Docker中很多命令十分相似！需要实际测试理解！
tomcat镜像制作
tomcat镜像制作
1、准备镜像文件tomcat压缩包，jdk压缩包
2、编写dockerfile文件，官方命名Dockerfile构建就会自动寻找，不需要-f去指定路径
#编写Dockerfile文件
FROM centos:7
MAINTAINER dq<dqforgive@163.com>
ADD apache-tomcat-9.0.37.tar.gz /usr/local/
ADD jdk-8u261-linux-i586.tar.gz /usr/local/
ENV JAVA_HOME /usr/local/jdk1.8.0_261
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.37
ENV CATALINA_BASE /usr/local/apache-tomcat-9.0.37
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
EXPOSE 8080
CMD /usr/local/apache-tomcat-9.0.37/bin/catalina.sh run
3、构建镜像
[root@localhost tomcat]# docker build -t diytomcat .
4、启动镜像
[root@localhost tomcat]# docker run -d --name mytomcat01 -v /server/webapps:/usr/local/apache-tomcat-9.0.37/webapps/ -p 8080:8080 diytomcat
Docker网络
理解Docker0
清空所有环境
测试
三个网络
# 问题，docker 是如何处理网络访问的？
[root@localhost tomcat]# docker run -d -P --name tomcat01 tomcat
#查看容器内部网络地址 ip addr
[root@localhost tomcat]# docker exec -it tomcat01 ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> 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
12: eth0@if13: <BROADCAST,MULTICAST,UP,LOWER_UP> 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
# linux可以ping通容器内部
原理
1、我们每启动一个容器，docker就会给docker分配一个ip，只要安装了docker，就会有一个docker0桥接模式，使用的技术是evth-pair
2、每启动一个容器，就会多出一个网卡
# 容器所带来的网卡，都是一对一对的
# evth-pair就是一对的虚拟设备接口，它们都是成对出现的
# 正因为有这个特性，evrh-pair充当一个桥梁
# Openstack，Docker容器之间的连接，都是使用evth-pair技术
3、测试tomcat01和tomcat02是都可以ping通
[root@localhost]# docker exex -it tomcat02 ping 172.18.0.2
#结论：容器和容器之间是可以相互ping通的！
tomcat01和tomcat02共用一个路由器，docker0.
所有的容器不指定网络的情况下，都是docker0路由的，docker会给我们的容器分配一个可用的ip
255.255.0.1/16 域 局域网
小结
Docker使用的是Linux的桥接，宿主机中是一个Docker容器的网桥Docker0.
Docker中所有的网络接口都是虚拟的。转发效率高。（内网删除文件）
只要删除容器，对应网桥就没了！
--link
思考一个场景，我们编写了一个微服务，database url=ip，项目不重启，数据库ip改变，处理这个问题，可以用名字来访问容器？
[root@localhost]# docker run -d -P --name tomcat02 --link tomcat01 tomcat
使用--link只能正向ping通，反向则不行!
本地：--link 就是我们在hosts配置中添加了一条绑定
现在Docker不建议使用
自定义网络！不适用docker0！
自定义网络
查看所有的docker网络
[root@localhost tomcat]# docker network ls
NETWORK ID NAME DRIVER SCOPE
f17ab98c4532 bridge bridge local
27e9636f66ab host host local
437c1c355b72 none null local
网络模式
bridge：桥接docker（默认）
none：不配置网络
host：主机模式（和宿主机共享网络）
container：容器内网络连通（用的少）
测试
# --net bridge 默认网络
docker run -d -P --name tomcat01 tomcat
docker run -d -P --name tomcat01 --net bridge tomcat
#两种相同
#自定义一个网络！
#--driver bridge
#--subnet 192.168.0.0/16
#--gateway 192.168.0.1
[root@localhost tomcat]# docker network create --driver bridge --subnet 192.168.0.0/16 --gateway 192.168.00.1 mynet
37e9d59b9192e727bc92c8f937c739cfe7484aaa1364376ce2060365ea562c15
[root@localhost tomcat]# docker network ls
NETWORK ID NAME DRIVER SCOPE
f17ab98c4532 bridge bridge local
27e9636f66ab host host local
37e9d59b9192 mynet bridge local
437c1c355b72 none null local
#运行自定义网络容器
[root@localhost tomcat]# docker run -d -P --name tomcat001 --net mynet tomcat
0526d1b28abccccb945268d8e0cc77670eceddc9a4c83cc1ae677a57f9197c58
[root@localhost tomcat]# docker run -d -P --name tomcat002 --net mynet tomcat
1aff67037b7a419998b709c9c065755e2834d31619b4cf6731d9c434a56d2372
可以看到其中存在两个刚才创建好的容器
网络连通
测试默认网络与自定义网络连通
#将tomcat01加入到mynet中，实现容器之间联通
[root@localhost tomcat]# docker network connect mynet tomcat01
结论：跨网络操作容器，使用docker network connect连通就可以！
浙公网安备 33010602011771号