Docker 学习笔记 -- kuangshen Docker 视频学习笔记

Docker !

1. Docker的出现

一款产品∶开发–上线两套环境!应用环境,应用配置!

开发–运维。问题︰我在我的电脑上可以运行!版本更新,导致服务不可用!对于运维来说,考验就十分大?

环境配置是十分的麻烦,每一个机器都要部署环境(集群Redis、ES、Hadoop…)!费时费力。

发布一个项目( jar + ( Redis MySQL jdk ES ) )。项目能不能都带上环境安装打包!

之前在服务器配置一个应用的环境Redis MySQL jdk ES Hadoop,配置超麻烦了,

不能够跨平台。Windows 开发,最后发布到Linux !

传统:开发jar,运维来做!

现在∶开发打包部署上线,一套流程做完!

java – apk --发布(应用商店)----张三使用apk —安装即可用!

java - - jar(环境) —打包项目带上环境(镜像.)— ( Docker仓库:商店 )–下载我们发布的镜像—直接运行即可!

Docker 给以上的问题,提出了解决方案!

Docker 的思想就来自于集装箱!

JRE–多个应用(端口冲突)—原来都是交叉的!

隔离:Docker 核心思想!打包装箱!每个箱子是互相隔离的。水果―生化武器

Docker 通过隔离机制,可以将服务器利用到极致!

本质:所有的技术都是因为出现了一些问题,我们需要去解决,才去学习!。

2. Docker的历史

2010年,几个搞 IT 的年轻人,就在美国成立了一家公司 dotcloud

做一些 pass 的云计算服务! LXC 有关的容器技术!

他们将自己的技术(容器化技术)命名就是 Docker !

Docker 刚刚诞生的时候,没有引起行业的注意! dotCloud,就活不下去!

开源

开发源代码!

2013年,Docker 开源!

Docker越来越多的人发现了docker 的优点!火了,Docker 每个月都会更新一个版本!

2014年4月9日,Docker1.0发布!

Docker 为什么这么火?十分的轻巧!

在容器技术出来之前,我们都是使用虚拟机技术!

虚拟机:在 window 中装一个 VMware,通过这个软件我们可以虚拟出来一台或者多台电脑!笨重!虚拟机也是属于虚拟化技术,Docker容器技术,也是一种虚拟化技术!

vm : linux centos原生镜像(一个电脑!)隔离,需要开启多个虚拟机!―几个G几分钟
docker:隔离,镜像(最核心的环境4m + jdk + mysq1)十分的小巧,运行镜像就可以了!
小巧!几个M KB秒级启动!

到现在,所有开发人员都必须要会 Docker !

聊聊Docker

Docker 是基于 Go 语言开发的!开源项目!

官网:https://www.docker.com/

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

3. Docker的用处

之前的虚拟机

image-20211109212434264

虚拟机技术的缺点:

  1. 资源占用十分多
  2. 冗余步骤多
  3. 启动很慢

容器化技术

容器化技术不是模拟的一个完整的操作系统

image-20211109212708191

比较Docker和虚拟机技术的不同:

  • 传统虚拟机,虚拟出一套硬件,运行一个完整的操作系统,然后在这个系统上安装和运行软件
  • 容器内的应用直接运行在宿主机的内容,容器是没有自己的内核的,也没有虚拟我们的硬件,所以就轻便了
  • 每个容器间是互相隔离,每个容器内都有一个属于自己的文件系统,互不影响。

DevOps(开发、运维)

应用更快速的交付和部署

传统: 一堆帮助文档,安装程序

Docker : 打包镜像发布测试,一键运行

更便捷的升级和扩缩容

使用了 Docker 之后,我们部署应用就和搭积木一样!项目打包为一个镜像,扩展服务器A、服务器B

更简单的系统运维

在容器化之后,我们的开发,测试环境都是高度一致的。更高效的计算资源利用∶
Docker 是内核级别的虚拟化,可以再一个物理机上可以运行很多的容器实例!服务器的性能可以被压榨到极致。

4. Docker的安装

4.1 Docker的基本组成

镜像(Image):

镜像就好比一个模板,可以通过模板创建容器服务,通过这个镜像创建很多个容器(最终服务或项目运行就是在容器中)

容器(Container):

Docker 利用容器技术,独立运行一个或者一个组应用,通过镜像来创建的。启动,

停止,删除、基本命令!

目前就可以把这个容器理解为就是一个简易的 Linux 系统

仓库(repository):

仓库就是存放镜像的地方!

仓库分为公有仓库和私有仓库!

Docker Hub(默认是国外的)

阿里云…都有容器服务器(需要配置镜像加速!

4.2 Docker的安装

环境准备

  1. Linux命令基础
  2. CentOS
  3. Xshell远程连接

环境查看

# 系统内核查看
[root@iZbp160rjf7ztq5oshw6m0Z ~]# uname -r
4.18.0-193.14.2.el8_2.x86_64
# 系统版本查看
[root@iZbp160rjf7ztq5oshw6m0Z ~]# cat /etc/os-release
NAME="CentOS Linux"
VERSION="8 (Core)"
ID="centos"
ID_LIKE="rhel fedora"
VERSION_ID="8"
PLATFORM_ID="platform:el8"
PRETTY_NAME="CentOS Linux 8 (Core)"
ANSI_COLOR="0;31"
CPE_NAME="cpe:/o:centos:centos:8"
HOME_URL="https://www.centos.org/"
BUG_REPORT_URL="https://bugs.centos.org/"

CENTOS_MANTISBT_PROJECT="CentOS-8"
CENTOS_MANTISBT_PROJECT_VERSION="8"
REDHAT_SUPPORT_PRODUCT="centos"
REDHAT_SUPPORT_PRODUCT_VERSION="8"

安装

跟着官方的帮助文档

  1. 卸载旧版本
yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine
  1. 安装依赖
yum install -y yum-utils
  1. 设置镜像仓库
yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo
    # 默认是从国外镜像,安装很慢,不推荐使用
    
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
	# 使用阿里云镜像仓库,国内推荐设置阿里云镜像仓库
  1. 安装
yum install docker-ce docker-ce-cli containerd.io
  1. 启动 Docker
systemctl start docker
  1. 查看 Docker 是否启动成功
docker version
  1. 测试 Hello world
docker run hello-world
# Docker 会先查找本机是否有这个镜像,有则直接运行,没有则尝试拉取这个镜像
# 这里就是先拉取为本地镜像,然后启动

image-20211110162653556

  1. 查看下载的hello world 镜像
    docker images
[root@iZbp160rjf7ztq5oshw6m0Z ~]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED       SIZE
hello-world   latest    feb5d9fea6a5   6 weeks ago   13.3kB

了解:卸载docker

# 1. 卸载依赖
yum remove docker-ce docker-ce-cli container.io

# 2. 删除镜像
rm -rf /var/lib/docker

# /var/lib/docker docker的默认工作路径

4.3 配置阿里云镜像加速

  1. 找到阿里云镜像加速

​ 弹性计算 -> 容器镜像服务 ->镜像工具 -> 镜像加速器

  1. 配置使用
    注意:每个人的阿里云账号的加速地址都是不一样的,请使用自己的加速地址
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://xxxxxxxx.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

4.4 HelloWorld流程

在这里插入图片描述

4.5 底层原理

4.5.1 docker 是怎么工作的

Docker 是一个 Client - Server 结构的系统,Docker 的守护进程运行在主机上。通过 Socket 从客户端访问!

Docker Server 接收到 Docker-Client 的指令,就会执行这个命令!

4.5.2 docker 为什么比 VM 快
  1. Docker比虚拟机更少的抽象层

  2. docker 利用宿主机的内核,VM 需要的是 Guest OS( GuestOS:VM(虚拟机)里的的系统(OS))

Docker 新建一个容器的时候,不需要像虚拟机一样重新加载一个操作系统内核,直接利用宿主机的操作系统,而虚拟机是需要加载 Guest OS。

5. Docker的常用命令

5.1 帮助命令

docker version 			# docker 版本信息
docker info			    # docker 系统信息
docker 命令 --help	    # docker 帮助命令

文档查询:https://docs.docker.com/engine/reference/commandline/docker/

5.2 镜像命令

5.2.1 查看本机的所有镜像

docker images

[root@iZbp160rjf7ztq5oshw6m0Z ~]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED       SIZE
hello-world   latest    feb5d9fea6a5   6 weeks ago   13.3kB

# 解释
REPOSITORY    	TAG       IMAGE ID       CREATED    SIZE
镜像的仓库源		镜像的标签  镜像的id		创建时间	镜像大小

# 可选参数
-a / --all 		列出所有镜像
-q / --quite 	只显示镜像id
5.2.2 搜索镜像

docker search

docker search 镜像名

# 可选项 
Options:
  -f, --filter filter   Filter output based on conditions provided
      --format string   Pretty-print search using a Go template
      --limit int       Max number of search results (default 25)
      --no-trunc        Don't truncate output
      

# 搜索STAR数大于3000的镜像
docker search mysql --filter=STARS=3000
5.2.3 下载镜像

docker pull

docker pull 镜像名 [:tag]

[root@iZbp160rjf7ztq5oshw6m0Z ~]# docker pull mysql

Using default tag: latest				# 不指定tag,默认下载最新版
latest: Pulling from library/mysql
b380bbd43752: Pull complete 			# 分层下载,docker image的核心-联合文件系统
f23cbf2ecc5d: Pull complete 
30cfc6c29c0a: Pull complete 
b38609286cbe: Pull complete 
8211d9e66cd6: Pull complete 
2313f9eeca4a: Pull complete 
7eb487d00da0: Pull complete 
4d7421c8152e: Pull complete 
77f3d8811a28: Pull complete 
cce755338cba: Pull complete 
69b753046b9f: Pull complete 
b2e64b0ab53c: Pull complete 
Digest: sha256:6d7d4524463fe6e2b893ffc2b89543c81dec7ef82fb2020a1b27606666464d87 #签名
Status: Downloaded newer image for mysql:latest
docker.io/library/mysql:latest #下载的真实地址

# docker pull mysql
# 等价于
# docker pull docker.io/library/mysql:latest

指定版本下载(版本号必须存在)

[root@iZbp160rjf7ztq5oshw6m0Z ~]# docker pull mysql:5.7 
5.7: Pulling from library/mysql
b380bbd43752: Already exists 
f23cbf2ecc5d: Already exists 
30cfc6c29c0a: Already exists 
b38609286cbe: Already exists 
8211d9e66cd6: Already exists 
2313f9eeca4a: Already exists 
7eb487d00da0: Already exists # 能看出分层的优势,相同的文件公用,只下载不同的文件
a71aacf913e7: Pull complete 
393153c555df: Pull complete 
06628e2290d7: Pull complete 
ff2ab8dac9ac: Pull complete 
Digest: sha256:2db8bfd2656b51ded5d938abcded8d32ec6181a9eae8dfc7ddf87a656ef97e97
Status: Downloaded newer image for mysql:5.7
docker.io/library/mysql:5.7
5.2.4 删除镜像

docker rmi

#1.删除指定的镜像id
docker rmi -f  镜像id
#2.删除多个镜像id
docker rmi -f  镜像id 镜像id 镜像id
#3.删除全部的镜像id
docker rmi -f  $(docker images -aq)

5.3 容器命令

我们有了镜像才能创建容器,这里下载一个 centos 镜像测试学习

5.3.1 拉取镜像

拉取一个CentOS镜像

docker pull centos
5.3.2 启动容器

docker run

docker run [可选参数] 镜像名

# 参数说明
    --name="名字"			   指定容器的名字
    -d						后台运行
    -it						使用交互方式运行,并进入容器
    -p						指定容器的端口(四种方式
    	-p ip:主机端口:容器端口
    	-p 主机端口:容器端口
    	-p 容器端口
    	容器端口
    -P						随机指定容器端口
    
# 测试
docker run -it centos /bin/bash	# 启动并进入容器,使用bash交互
# centos 基础的版本,很多命令不完善

image-20211110230252777

5.3.3 退出容器
exit # 直接退出容器,并停止运行
Ctrl + P + Q # 退出容器,但不停止运行
5.3.4 查看运行的容器

docker ps [options]

docker ps [可选参数]

# 空		列出当前运行的容器
# -a	 	列出所有容器
# -n=?		列出最近创建的n个容器
# -q	 	只列出容器id
[root@iZbp160rjf7ztq5oshw6m0Z ~]# docker ps
CONTAINER ID   IMAGE     COMMAND       CREATED         STATUS         PORTS     NAMES
826f7cbb95ee   centos    "/bin/bash"   6 minutes ago   Up 6 minutes             zen_margulis
5.3.5 删除容器

docker rm [options]

docker rm 容器id                 # 删除指定的容器,不能删除正在运行的容器,强制删除使用 rm -f
docker rm -f $(docker ps -aq)   # 删除所有的容器
docker ps -a -q|xargs docker rm # 删除所有的容器
5.3.6 启动和停止容器
docker start 容器id          #启动容器
docker restart 容器id        #重启容器
docker stop 容器id           #停止当前运行的容器
docker kill 容器id           #强制停止当前容器

5.4 其他常用命令

5.4.1 日志

docker logs

docker logs [可选项] 容器id

# 可选项
-f : 跟踪日志输出

--since :显示某个开始时间的所有日志

-t : 显示时间戳

--tail :仅列出最新N条容器日志
5.4.2 后台启动的坑
# 命令docker run -d 镜像名!

[root@kuangshen/]# docker run -d centos

# 问题docker ps,发现centos停止了

# 常见的坑: docker容器使用后台运行,就必须要有要一个前台进程,docker发现没有应用,就会自动停止

# nginx,容器启动后,发现自己没有对外提供服务,就会立刻停止,就是没有程序了
5.4.3 查看容器中的进程
docker top 容器id
5.4.4 查看容器的元数据
docker inspect [可选项] 容器id | 容器名字

# 可选项
-f :指定返回值的模板文件。

-s :显示总的文件大小。

--type :为指定类型返回JSON。
5.4.5 进入后台运行的容器

我们通常容器都是使用后台方式运行的,需要进入容器,修改一些配置

# docker exec 在运行中的容器执行命令
# 此方法连接后退出不会停止容器的运行

docker exec -it 容器id CAMMAND(分配终端还是执行脚本)

# docker attach 连接到正在运行中的容器
# 连接后退出会停止容器的运行

docker attach 容器id
5.4.6 容器与主机之间拷贝数据
docker cp CONTAINER:SRC_PATH DEST_PATH|-

docker cp SRC_PATH|- CONTAINER:DEST_PATH

# 将主机/www/runoob目录拷贝到容器96f7f14e99ab的/www目录下。
docker cp /www/runoob 96f7f14e99ab:/www/

# 将主机/www/runoob目录拷贝到容器96f7f14e99ab中,目录重命名为www。
docker cp /www/runoob 96f7f14e99ab:/www

# 将容器96f7f14e99ab的/www目录拷贝到主机的/tmp目录中。
docker cp  96f7f14e99ab:/www /tmp/

5.5 小结

img
对于更多的 docker 命令,可以去菜鸟教材查询:
菜鸟命令大全

6. Docker 小练习

6.1 部署Nginx
# 1. 拉取镜像(指定版本需要先去dockerHub搜索查看版本)
docker pull nginx

# 2. 查看镜像是否下载成功
docker images

# 3. 启动容器
# 后台运行,使用2233端口映射nginx的80端口,名为nginx——test
docker run -it -p 2233:80 --name nginx_test nginx

# 4. 本地测试访问
curl localhost:2233 

# 5. 外网测试
http://服务器公网ip:2233

端口暴露的理解:

img

6.2 部署Tomcat
#官方的使用
docker run -it -rm tomcat:9.0

# 我们之前的启动都是后台,停止了容器之后,容器还是可以查到 docker run -it --rm,一般用来测试,用完就删除

# 1. 下载在启动
docker pu1l tomcat
# 启动运行
docker run -d -p 2234:8080 --name tomcat_test tomcat

# 测试访间没有间题

# 进入容器
[root@kuangshen home]# docker exec -it tomcat01 /bin/bash
# 发现问题:
# 1. 1inux命令少了;
# 2. webapps没有东西。阿里云镜像的原因。默认是最小的镜像,所有不必要的都剔除掉。
# 目的是保证最小可运行的环境!

思考问题∶我们以后要部署项目,如果每次都要进入容器是不是十分麻烦?我要是可以在容器外部提供一个映射路径,webapps ,我们在外部放置项目,就自动同步到内部就好了!

6.3 部署 ES + Kibana
# es 暴露的端口很多!
# es十分的耗内存
# es 的数据一般需要放置到安全目录!挂载
# --net somenetwork ?网络配置

# 启动elasticsearch
docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node"elasticsearch:7.6.2

# 启动了1inux就卡住了
# docker stats查看cpu的状态

# 测试一下es是够成功了
[root@kuangshen home]# cur1 localhost: 9200
{
    "name" : "7e2469973535""cluster_name” : "docker-cluster"",
    "cluster_uuid"" : ""eJ1FbVtzs91ERQ71EQjoug",
    "version" :{
        "number":"7.6.2 "",
        "build_flavor” : "defau1t"",
        "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-betal""
    	}"tagline" : "You Know.for Search"
}

# es是十分耗内存的 解决:
# 添加 ’-e ES_JAVA_OPTS="-Xms128m -Xmx512m" ‘ 配置ElasticSearch的虚拟机占用的内存大小。

思考:
image-20211112161734001

7. Docker 的可视化工具

作为了解,一般都不会使用可视化工具

  • portainer
  • Rancher(CI/CD 再用)

7.1 portainer

# 下载 启动
docker run -d -p 8000:8000 -p 9443:9443 --name portainer_test \
    --restart=always \
    -v /var/run/docker.sock:/var/run/docker.sock \
    -v portainer_data:/data \
    portainer/portainer-ce:latest
    
# 连接 注册登录 
http://服务器ip:9443
user: admin
password: asdfghjkl

# 测试 使用

可视化面板平时不会使用,自己测试玩玩!

8. Docker 镜像详解

8.1 镜像是什么

镜像是一种轻量级、可执行的独立软件包,用来打包软件运行环境和基于运行环境开发的软件,它包含运行某个软件所需的所有内容,包括代码、运行时、库、环境变量和配置文件。

所有的应用,直接打包 docker 镜像,就可以直接跑起来!

如何得到镜像︰

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

8.2 镜像加载原理

UnionFS(联合文件系统)

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

为什么虚拟机的 CentOS 镜像高达几个G,Docker 里的才几百M?

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

虚拟机是分钟级别,容器是秒级!

分层理解

所有的 Docker 镜像都起始于一个基础镜像层,当进行修改或增加新的内容时,就会在当前镜像层之上,创建新的镜像层。

举一个简单的例子,假如基于Ubuntu Linux 16.04 创建一个新的镜像,这就是新镜像的第一层; 如果在该镜像中添加 Python包, 就会在基础镜像层之上创建第二个镜像层; 如果继续添加一个安全补丁,就会创建第三个镜像层。

该镜像当前已经包含3个镜像层,如下图所示(这只是一个用于演示的很简单的例子)。

在这里插入图片描述

在添加额外的镜像层的同时,镜像始终保持是当前所有镜像的组合,理解这一点非常重要,下图举例了一个简单的例子,每个镜像层包含 3 个文件,而镜像包含了来自两个镜像层的 6 个文件

在这里插入图片描述

上图中的镜像层跟之前图中的略有区别,主要目的是便于展示文件。

下图中展示了一个稍微复杂的三层镜像,在外部看来整个镜像只有 6 个文件,这是因为最上层中的文件 7 是文件 5 的一个更新版本。

在这里插入图片描述

这种情况下,上层镜像层中的文件覆盖了底层镜像层中的文件。这样就使得文件的更新版本作为一个新镜像层添加到镜像当中。

Docker 通过存储引擎(新版本采用快照机制)的方式来实现镜像层堆栈,并保证多镜像层对外展示为统一的文件系统。

Linux上可用的存储引擎有 AUFS、Overlay2、Device Mapper、Btrfs 以及 ZFS。顾名思义,每种存储引擎都基于Linux中对应的文件系统或者块设备技术,并且每种存储引擎都有其独有的性能特点。

Docker 在 Windows 上仅支持 windowsfiter 一种存储引擎,该引擎基于 NTFS 文件系统之上实现了分层和 CoW[1]。

下图展示了与系统显示相同的三层镜像。所有镜像层堆叠并合并,对外提供统一的视图。

在这里插入图片描述

特点

Docker 镜像都只是可读的,当容器启动时,一个新的可写层被加载到镜像的顶部!

这一层就是我们通常所说的容器层,容器之下的都叫镜像层

在这里插入图片描述

8.3 commit 镜像

docker commit 提交容器为一个新的副本

# 命令和 git 原理类似
docker commit -m="提交的信息" -a="作者" 容器ID 目标镜像名字[:tag]

实战练习

[root@iZbp160rjf7ztq5oshw6m0Z ~]# docker images
REPOSITORY               TAG       IMAGE ID       CREATED       SIZE
nginx                    latest    04661cdce581   4 days ago    141MB
portainer/portainer-ce   latest    a1c22f3d250f   2 weeks ago   252MB
tomcat                   latest    b0e0b0a92cf9   3 weeks ago   680MB
mysql                    5.7       938b57d64674   3 weeks ago   448MB
hello-world              latest    feb5d9fea6a5   7 weeks ago   13.3kB

# 1. 启动一个 tomcat 我就启动之前的一个 tomcat 容器
[root@iZbp160rjf7ztq5oshw6m0Z ~]# docker ps -a
CONTAINER ID   IMAGE                           COMMAND                  CREATED        STATUS                    PORTS     NAMES
0e118541147c   tomcat                          "catalina.sh run"        2 days ago     Exited (143) 2 days ago             tomcat_test
# 2. 新启动的 tomcat 用外网访问的没有内容的,因为 webapps 里没有东西
# 这个容器是我之前测试的时候已经复制东西过来了,所以就直接用这个了
[root@iZbp160rjf7ztq5oshw6m0Z ~]# docker start 0e118541147c

# 3. 提交一个新镜像
[root@iZbp160rjf7ztq5oshw6m0Z ~]# docker commit -a="timmi" -m="add webapps files" 0e118541147c tomcat_commit:1.0
sha256:846c6917d72209b1b196137ac547847bcf133d6edcd21af0ad2531a39458935e

# 4. 查看新提交的镜像
[root@iZbp160rjf7ztq5oshw6m0Z ~]# docker images
REPOSITORY               TAG       IMAGE ID       CREATED         SIZE
tomcat_commit            1.0       846c6917d722   7 seconds ago   684MB
tomcat                   latest    b0e0b0a92cf9   3 weeks ago     680MB

# 5. 启动这个镜像测试
[root@iZbp160rjf7ztq5oshw6m0Z ~]# docker run -d -p 8080:8080 tomcat_commit:1.0
# 这里启动需要带上 Tag, 否则会去 Docker Hub 上搜索 latest(最新版)

9. Docker 的容器数据卷

9.1 什么是容器数据卷

docker的理念回顾
将应用和环境打包成一个镜像!

数据:如果数据都在容器中,那么我们容器删除,数据就会丢失!

需求∶数据可以持久化

MySQL,容器删了,删库跑路!需求:MySQL 数据可以存储在本地!

容器之间可以有一个数据共享的技术!

Docker容器中产生的数据,同步到本地!这就是卷技术! 目录的挂载,将我们容器内的目录,挂载到Linux上面!

总结:容器的持久化和同步操作!容器之间也可以数据共享

9.2 数据卷的使用

9.2.1 直接使用命令挂载
docker run -v 主机目录:容器目录 [][]……

# 测试
docker run -it -v /home/ceshi:/home centos /bin/bash

# 解释:
# 启动成功后使用 docker inspect 容器 id 命令查看是否挂载成功
# 查看 Mounts 对应的 Value
"Mounts": [
        {
            "Type": "bind",
            "Source": "/home/ceshi",
            "Destination": "/home",
            "mode": "",
            "Rw": "",
            "Propagation": "rprivate"
        }
]

挂载成功后,便可以在主机挂载目录上修改,容器目录就会自动同步修改

9.2.2 MySQL的挂载实战

使用 Docker 拉取 MySQL 5.7版本,后续启动

# 1. 启动mysql,注意 mysql 需要配置密码,使用-e 配置
[root@iZbp160rjf7ztq5oshw6m0Z ~]# docker run -d -p 3306:3306 \
-v /home/mysql/conf:/etc/mysqlconf.d -v /home/mysql/data:/var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=123456 --name=mysql_test mysql:5.7

# 解释
-d 后台启动
-p 指定端口
-v 卷挂载,可以挂载多个目录
-e 配置环境
--name 设置容器名字

# 2. 启动成功后,使用第三方数据库连接软件连接测试
# 这里使用 navicat 连接

在这里插入图片描述

这时,我们将 MySQL 容器删除,挂载到本地的数据依旧不会丢失

注意,在主机挂载目录里手动删除的数据,在容器里也会被删除

9.3 具名和匿名挂载

匿名挂载:不指定主机的挂载目录,-v 后面直接就是容器的挂载目录-v /etc/xxxx

具名挂载:不指定主机的挂载目录,但是-v 后面与容器的挂载目录之间给容器挂载目录取一个名字 -v name:/etc/xxxx

查看挂载的卷

docker volume [command]

Commands:
  create      创建一个数据卷
  inspect     查看指定数据卷的详细信息
  ls          查看所有数据卷
  prune       删除所有未使用的数据卷
  rm          删除数据卷
  

[root@iZbp160rjf7ztq5oshw6m0Z ~]# docker volume ls
DRIVER    VOLUME NAME
local     portainer_data

[root@iZbp160rjf7ztq5oshw6m0Z ~]# docker volume inspect portainer_data
[
    {
        "CreatedAt": "2021-11-12T16:44:46+08:00",
        "Driver": "local",
        "Labels": null,
        "Mountpoint": "/var/lib/docker/volumes/portainer_data/_data",
        "Name": "portainer_data",
        "Options": null,
        "Scope": "local"
    }
]

所有的 docker 容器内的卷,没有指定目录的情况下都是在/var/lib/docker/volumes /xxxxx/_data
我们通过具名挂载可以方便的找到我们的一个卷,大多数情况在使用的匿名挂载

拓展:

# 通过 -v 容器内路径:ro、rw ,能够改变读写权限
ro:readonly		# 只读
rw:readwrite		# 可读可写

#一旦这个了设置了容器权限,容器对我们挂载出来的内容就被限定了!
docker run -d -p --name nginx02 -v juming-nginx:/etc/nginx:ro nginxdocker \
run -d -P --name nginx02 -v juming-nginx:/etc/nginx:rw nginx

# ro:只要看到ro就说明这个路径只能通过宿主机来操作,容器内部是无法操作!

10. Docker File

10.1 初识 Docker File

Docker File 就是用来构建 Docker 镜像的构建文件!是一个命令脚本

通过这个命令脚本可以生成镜像,镜像是一层一层的,脚本里一个命令就相当于一层!

# 1. 创建 Docker file 文件,名字可以随意,但是建议取 Dockerfile
# 因为 docker 在构建镜像时会默认寻找这个文件
# 脚本的指令:指令全部大写 参数

FROM centos

VOLUME ["volume01","volume02"]

CMD echo "-----end line-----"

CMD /bin/bash

使用 docker build 命令生成镜像:

docker build -f dockerfile_test -t timmi/centos:1.0 .

# 解释
-f 	dockerfile文件的路径
-t 	指定镜像名字和版本号
. 	表示生成在当前目录

image-20211114202451111

查看镜像:

[root@iZbp160rjf7ztq5oshw6m0Z home]# docker images
REPOSITORY               TAG       IMAGE ID       CREATED          SIZE
timmi/centos             1.0       6cf7aff6e83a   14 minutes ago   231MB
centos                   latest    5d0da3dc9764   8 weeks ago      231MB

启动自己生成的镜像:

docker run -it --rm 6cf7aff6e83a /bin/bash

image-20211114203826876

这两个挂载目录是匿名挂载,通过 docker inspect 命令查看主机挂载的目录

image-20211114204305474

Docker File 文件可以很方便的在进行创建多个容器的时候就进行自动挂载,这种方法十分常用

10.2 数据卷容器

即多个容器共享一个数据卷,具体就是先创建一个容器(可以称为父容器),挂载好数据卷,后面创建的容器直接共享父容器的挂载,这个父容器就叫做数据卷容器

# 1. 创建父容器,利用上面生成自己的镜像
docker run -it --name centos01 timmi/centos:1.0

# 2. 创建子容器
docker run -it --name centos02 --volumes -from centos01 timmi/centos:1.0

# 这样 centos01 和 centos02 就共享同一个数据卷,即时父容器被删除了,只要还有容器仍在使用这个数据卷,这个数据卷就不会失效

所有,可以实现多个 MySQL 实现数据共享

# 
docker run -d -p 3306:3306 -v /etc/mysql/conf.d -v /var/lib/mysql \
-e MYSQL_ROOT_PASSWORD=123456 --name mysql_father mysql:5.7

# 
docker run docker run -d -p 3310:3306 -e MYSQL_ROOT_PASSWORD=123456 \
--volumes -from mysql_father --name mysql_son mysql:5.7

结论︰
容器之间配置信息的传递,数据卷容器的生命周期一直持续到没有容器使用为止。

但是一旦你持久化到了本地,这个时候,本地的数据是不会删除的!

10.3 全面理解 Docker file

10.3.1 docker file 介绍

Docker file 是用来构建 docker 镜像的文件!命令参数脚本!

构建步骤:

  1. 编写一个docker file 文件
  2. docker build 构建成为一个镜像
  3. docker run 运行镜像
  4. docker push 发布镜像( Docker Hub、阿里云镜像仓库!)

很多官方镜像只是基础镜像,很多功能没有,需要自行构建补充!

10.3.2 docker file 构建

基础知识:

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

Docker file 是面向开发的,我们以后要发布项目,做镜像,就需要编写 Docker file 文件,这个文件十分简单!

Docker镜像逐渐成为企业交付的标准,必须要掌握!

步骤:开发,部署,运维……缺一不可!

Docker File : 构建文件,定义了一切的步骤,源代码

Docker images : 通过 Docker File 构建生成的镜像,最终发布和运行的产品!

Docker 容器: 容器就是镜像运行起来提供服务器

Docker File 指令

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

实战 创建自己的centos

# 1. 编写 Docker File 文件
FROM centos
MAINTAINER tiimme<1976214615@qq.com>

ENV MYPATH "/usr/local"
WORKDIR $MYPATH

RUN yum -y install vim

EXPOSE 80

CMD echo $MYPATH
CMD /bin/bash

# 2. 使用 docker file 构建镜像
docker build -f mydockerfile-centos -t mycentos-with-vim:0.1 .

# Successfully built 998fb54b2e49
# Successfully tagged mycentos-with-vim:0.1

# 3. 启动测试

image-20211115152210697

还可以使用 docker history 命令查看镜像的构建历史

image-20211115152817662

CMD 和 ENTRYPOINT 的区别

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

11. Docker 网络

11.1 理解 Dokcer0

查看 Docker0

ifconfig / ip addr

image-20211116192625207

三个网络,Docker0 就是 Docker 创建的默认网卡

思考:docker 是如何处理容器网络访问的?

# 启动一个 tomcat 测试 
docker run -d -P--name tomcat01 tomcat

# 查看容器的 ip 发现容器启动的时候会得到一个eth0@if262 ip地址,docker分配的!
docker exec -it tomcat01 ip addr

1: lo:<L0OPBACK ,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 1o
valid_1ft forever preferred_ift forever
261: eth0@if262:<BROADCAST,MLTICAST,UP ,LOWER_UP> mtu 1500 qdisc noqueue state uP group default
link/ether 02:42:ac:12:00:02 brd ff:ff:ff:ff:ff:ff link-netnsid o
inet 172.18.0.2/16 brd 172.18.255.255 scope global eth0
valid_lft forever preferred_lft forever

# 思考:1iunx 能不能 ping 通容器内部?
ping 172.18.0.2

PING 172.18.0.2 (172.18.0.2) 56(84) bytes of data.
64 bytes from 172.18.0.2: icmp_seq=1 tt1=64 time=0.067 ms
64 bytes from 172.18.0.2: icmp_seq=2 tt1=64 time=0.055 ms

# linux可以ping通docker容器内部

原理

我们每启动一个 docker 容器,docker 就会给 docker 容器分配一个 ip,我们只要安装了docker,就会有一个网卡 docker0 桥接模式,使用的技术是 veth-pair 技术!

再次测试ip addr 发现多了一个网卡,这是前面启动的 tomcat 容器的网卡,我们在启动一个 tomcat 容器,会发现网卡又多了一个

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

最后,测试 tomcat01 能否 ping 通 tomcat02 发现也是可行的

网络模型图如下:

image-20211119211603066

结论: tomcat01 和 tomcat02 是公用的一个路由器, docker0。

所有的容器不指定网络的情况下,都是 docker0 路由的,docker 会给我们的容器分配一个默认的可用IP

小结

Docker 中的所有的网络接口都是虚拟的。虚拟的转发效率高!(内网传递文件!)

只要容器关闭了, 对应网桥一对就没了!

11.2 – link

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

# 能否直接通过容器名 ping 通?
docker exec -it tomcat02 ping tomcat01 
ping: tomcato1: Name or service not known

# 如何可以解决呢?
# 通过--1ink既可以解决了网络连通间题
docker run -d -p --name tomcat03 --1ink tomcat02 tomcat

# 再 ping 一次
docker exec -it tomcat03 ping tomcat02

PING tomcat02 (172.18.0.3) 56(84) bytes of data.
64 bytes from tomcat02 (172.18.0.3): icmp_seq=1 tt1=64 time=0.100 ms64 bytes from tomcat02 (172.18.0.3): icmp_seq=2 ttl=64 time=0.066 ms64 bytes from tomcat02 (172.18.0.3): icmp_seq=3 ttl=64 time=0.067 ms

# 那么反向可以 ping 通吗?
docker exec -it tomcat02 ping tomcat03
ping: tomcat03: Name or service not known
# 显然是不行的

本质探究:

其实这个tomcat03就是在本地配置了tomcat02的配置?

# 查看hosts配置,在这里原理发现!
docker exec -it tomcat03 cat /etc/hosts
127.0.0.1	localhost
::1 		localhost ip6-localhost ip6-1oopback
fe00::0 	ip6-localnet
ff00::0 	ip6-mcastprefix
ff02::1 	ip6-al1nodes
ff02::2	 	ip6-a11routers
172.18.0.3 	tomcat02 312857784cd4
172.18.0.4	5ca72d80ebb0

总结:

  • --link 就是我们在 hosts 配置中增加了一个172.18.0.3 tomcat02 312857784cd4
  • 我们现在玩Docker 已经不建议使用--link了!
  • 自定义网络!不适用 docker0 !
  • docker0 问题:他不支持容器名连接访问!

11.3 自定义网络

11.3.1 查看 docker 网络

docker network

docker network ls

网络模式:

  • bridge:桥接模式( docker0 默认的模式,自定义网络也是使用这种模式)
  • 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.1

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

docker network ls
NETWORKID		NAME					DRIVER	SCOPE
5a008c015cac	bridge					bridge	1ocal	
db44649a9bff	composetest_default		bridge	loca1
ae2b6209c2ab	host					host	local
eb21272b3a35	mynet					bridge	local

至此,我们自己的网络就创建好了

image-20211119232344429

使用我们自己的网络创建容器:

# tomcat01 
docker run -d -P--name tomcat-net-01 --net mynet tomcat
19f243d9c95bd771979a5e0bb3033dbf3f9ceacdd34ce231a5d6982573706ca9

# tomca02
docker run -d -P --name tomcat-net-02 --net mynet tomcat
aff29160a5e2ea5594c4950f34cd7c932c8e8cfae54eec979863ae09947bee73

# 再次查看我们的网络
docker network inspect mynet

image-20211119232917253

再次 ping 测试

# 通过 ip ping 容器
docker exec -it tomcat-net-01 ping 192.168.0.3
PING 192.168.0.3 (192.168.0.3)56(84)bytes of data.
64 bytes from 192.168.0.3: icmp_seq=1 tt1=64 time=0.085 ms
64 bytes from 192.168.0.3: icmp_seq=2 ttl=64 time=0.070 msAc
--- 192.168.0.3 ping statistics ---
2 packets transmitted,2 received,0% packet loss,time 999msrtt min/avg/max/mdev = 0.070/0.077/0.085/0.011 ms

# 通过容器名 ping
# 现在不使用 --1ink 也能 ping 容器名了
docker exec -it tomcat-net-01 ping tomcat-net-02
PING tomcat-net-02 (192.168.0.3)56(84) bytes of data.
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=1 ttl=64 time=0.055ms
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=2 ttl=64 time=0.063 mS

我们自定义的网络docker都已经帮我们维护好了对应的关系,推荐我们平时这样使用网络!

好处︰

  • redis: 不同的集群使用不同的网络,保证集群是安全和健康的
  • MySQL:不同的集群使用不同的网络,保证集群是安全和健康的

11.4 网络连通

image-20211119233919642

如何使 tomcat01 与 tomcat-net-01连通?

docker network connect

image-20211119234119458

测试:

# 使用 docker network connect 命令
docker network connect mynet tomcat01

# 查看 mynet 网络详细信息
docker network inspect mynet

image-20211119234226291

发现mynet 网络里多了一个tomcat01 的容器,连通命令就是把 tomcat01 加入到 mynet 网络中

这就是一个容器,两个 ip 地址

**结论:**假设要跨网络操作容器,就需要使用docker network connect 连通!

再次 ping 测试

# 通过 ip ping 容器
docker exec -it tomcat-net-01 ping 192.168.0.3
PING 192.168.0.3 (192.168.0.3)56(84)bytes of data.
64 bytes from 192.168.0.3: icmp_seq=1 tt1=64 time=0.085 ms
64 bytes from 192.168.0.3: icmp_seq=2 ttl=64 time=0.070 msAc
--- 192.168.0.3 ping statistics ---
2 packets transmitted,2 received,0% packet loss,time 999msrtt min/avg/max/mdev = 0.070/0.077/0.085/0.011 ms

# 通过容器名 ping
# 现在不使用 --1ink 也能 ping 容器名了
docker exec -it tomcat-net-01 ping tomcat-net-02
PING tomcat-net-02 (192.168.0.3)56(84) bytes of data.
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=1 ttl=64 time=0.055ms
64 bytes from tomcat-net-02.mynet (192.168.0.3): icmp_seq=2 ttl=64 time=0.063 mS

我们自定义的网络docker都已经帮我们维护好了对应的关系,推荐我们平时这样使用网络!

好处︰

  • redis: 不同的集群使用不同的网络,保证集群是安全和健康的
  • MySQL:不同的集群使用不同的网络,保证集群是安全和健康的

11.4 网络连通

image-20211119233919642

如何使 tomcat01 与 tomcat-net-01连通?

docker network connect

image-20211119234119458

测试:

# 使用 docker network connect 命令
docker network connect mynet tomcat01

# 查看 mynet 网络详细信息
docker network inspect mynet

image-20211119234226291

发现mynet 网络里多了一个tomcat01 的容器,连通命令就是把 tomcat01 加入到 mynet 网络中

这就是一个容器,两个 ip 地址

**结论:**假设要跨网络操作容器,就需要使用docker network connect 连通!

12. 学习感悟

本来是为了部署Adachi bot才去学习的Docker,学习完 Docker 真香!学完一遍后,使用别人的镜像部署那是顺手拈来,不过对于的如何构建自己的项目的 Docker 镜像还是不太清晰,自己日常使用就没问题,后续应该会继续学习 Docker compose 和 Docker swarm的内容。
原视频学习地址:https://www.bilibili.com/video/BV1og4y1q7M4

  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Tiimmi丶

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值