Docker基础讲解狂神笔记（1/2）
Docker
- 优势是相对的，有些核心技术一旦开源，就有了相应的培训和从1到无穷的技术复制品落地；所以需要把握科技史，了解每个时期技术发展的痛点，才能有做合理选择的可能；不然，埋头在一个加密的课程培训里，封闭地讲一些陈年老土的技术，还不如自修，野蛮生长。
- 阿里云王坚：大部分的人知识结构是不变的，不自觉地把所有新的东西都纳入到原有的框架中，“那样不痛苦”
- 专注：内容越细致越好，禁止画大饼
L01 课程安排
-
先修课：Linux基础：基础命令，文件系统，启动流程，网络基础
Docker学习：学习老师如何学习；即使再小的帆也能远航
- 概述
- 安装
- 命令
- 镜像命令
- 容器命令
- 操作命令
- …
- 镜像
- Docker容器数据卷
- Dockerfile：制作镜像
- Docker网络原理
- IDEA整合Docker
- Docker Compose：容器编排
- Docker Swarm：集群管理（简化版K8S）
- CI\CD Jenkins：流水线
L02 概述
为什么出现？
- 写项目：开发/上线：两套环境！应用环境，应用配置！->开发人员，运维人员
- 问题：我在我的电脑上可以运行！版本更新，导致服务不可用！对于运维来说考验大；环境配置十分麻烦：每个机器都要部署环境（集群Redis，ES，Hadoop）
- 解决：开发即运维；
| before | after |
|---|---|
| 发布项目jar包（运维需要配置：Redis，mysql，jdk，ES）war包环境； | 运维发布jar包+所需的所有环境，保持一致性，项目可以带上环境安装打包； |
| 之前在服务器配置一个应用环境RediSmysql jdk hs hadoop 配置超麻烦，不能跨平台；项目可以通过java跨平台，但环境不行；开发环境windows，发布到Linux环境配置天壤之别 | Docker提出解决方案 |
| 传统：发个jar包，发给运维；java–apk–发布（应用商店）—张三使用apk–安装即可用 | 现在：打包，部署上线，一套流程做完；java–jar(环境)–打包项目带环境（Docker镜像）–（Docker仓库：商店）–下载我们发布的镜像–直接运行即可 |
| Jre运行环境- 多个应用（端口冲突）–原来都交叉 | 隔离:Docker核心思想！打包装箱！每个箱子互相隔离；并不用考虑环境端口问题 |
| linux：水果+生化武器，服务器未被充分利用 | Doker：水果与生化武器隔离；通过隔离机制：将Linux服务器利用到极致 |
| 运维：tomcat，mysql集群，redis集群自己配置 | 运维：一键部署 |
| 虚拟机：VMware笨重 | 容器非常轻巧 |
- 谁来干：Docker！集装箱
- 本质：所有技术都是因为出现了一些问题，我们需要去解决，才去学习；
历史
2010,4 ITer,美国成立one 公司 dotcloud
做一些pass的云计算服务！Linux相关的容器技术：
将自己的技术（容器化）命名：Docker
诞生时候：没有引起行业的注意，活不下去—>开源：开放源代码
2013年 Docker开源，大家白嫖，越来越多人发现Docker优点；火了
2014+ 每一个月更新一个版本（04月：1.0发布）
虚拟机：windows装VMWare等虚拟机软件，为了完成某个任务和项目需要虚拟出来一台或多台电脑，十分笨重，资源浪费；虚拟机也是虚拟化技术；
vm，linux centos原生镜像（一个pc），隔离：开启多个虚拟机（几个G，几分钟 ）
Docker容器技术：也是虚拟化技术，体量；容器只在乎当前的软件；
docker，隔离，镜像机制（不是完整的系统，是最核心环境 4m足够+[jdk+mysql],十分小巧）=（几个M，秒级启动）运行镜像就可以了
开源精神，开源是一种思想–>结果:所有开发人员必须要会Docker
文档链接
- 基于Go语言开发；开源项目；
- 官网地址+文档地址docs：docker.com
- docker文档超级详细！如何看官方文档？docs.docker.com
- Dockerhub,仓库地址：hub.docker.com
- 百度百科：docker
能干嘛？
| 之前 | 之后 |
|---|---|
| 虚拟机技术：内核->lib->（app app app app）； | 容器化技术：内核->（Lib->App），（Lib->App），（Lib->App），（Lib->App） |
| 缺点：1.资源占用特别多；2.冗余步骤慢；3.启动很慢 | 不是一个模拟的完整的操作系统； |
| 虚拟出一套硬件，运行一个完整的操作系统，然后在这个系统上安装和运行软件 | 容器的应用直接运行在宿主机的内容，容器没有自己的内核，也没有虚拟硬件，所以就轻便了；容器间互相隔离，每个容器内都有一个属于自己的文件系统，互不影响 |
| 最多装3个软件 | 最少装30个 |
DevOps
-
开发+运维
-
应用更快速交付和部署
-
传统运维：根据一堆文档，安装程序
-
Docker：一键运行，打包镜像，发布测试；
-
更便捷地升级和扩容
-
使用Docker之后，部署应用就和搭积木一样；
-
项目打包为一个镜像， 扩展：服务器A，服务器B；虚拟机可以开很多容器，容器之间可以交流；
-
更简单的系统运维
-
容器化之后，开发，测试部署高度一致；
-
更高效的计算资源利用
-
1核2g服务器–>同时运行几十个Tomcat，便于做集群
-
Docker是内核级别的虚拟化，可以在一个物理机上运行很多的容器实例！服务器的性能可以被压榨到极致
容器的本质
- 一种进程隔离技术，通过cgroup和namespace，容器里的应用只使用给定的资源，不同容器之间互不侵犯;
- 从容器里应用的角度来看，它只能看到给定的计算存储资源和为其定制的系统;
- 但从容器外面的系统来看，它运行的是一个一个的进程
- 存在安全隐患：云服务，一台机器里面运行着不同用户的一个个进程
由于：操作系统内核漏洞，Docker组件设计缺陷，以及不当的配置都会导致Docker容器发生逃逸
从而：获取宿主机权限。
由于：频发的安全及逃逸漏洞，在公有云环境容器应用不得不也运行在虚拟机中，从而满足多租户安全隔离要求。
而：分配、管理、运维这些传统虚拟机与容器轻量、灵活、弹性的初衷背道而驰，同时在资源利用率、运行效率上也存浪费。
共享内核之下，有 Namespace 和 Cgroup 还不够，尤其是采用 Docker 的公有云平台；
- 运维新工作的产生与容器技术目前存在的安全问题有极大的相关，开发人员将运维工作简易化，在简易化操作的环境下分摊了大部分运维工作，普通运维人员岗位的存在性存在质疑，开发自然而然成为了私企工作者在这个行业里的必经之路，或者说必备能力。
- 因此，2020+的时代没有脱离开发的运维，python开发因其易操作性：成为了可以选择的开发道路
L03 安装
基本组成
- 客户端，服务器（dockerdaemon通过images运行->通过一个或多个容器运行），仓库；
- 镜像（image）：好比模板，通过这个模板创建容器服务，tomcat容器–>run–>tomcat01容器（提供服务器）,可以创建多个容器（最终服务运行在容器中）
- 容器（container）：利用容器技术，独立运行一个或者一组应用，通过镜像来创建；启动停止删除，基本命令！目前可以理解容器为一个简易的linux系统
- 仓库（repository）：存放镜像的地方，分为公有仓库（Dockerhub 阿里云）和私有仓库
安装
环境准备
1.需要会一点点的Linux的基础
2.Centos 7
3.使用Xshell连接远程服务器进行操作
环境查看
# uname -r
3.10.0-1062.18.1.el7.x86_64
# 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"
安装：参考帮助文档
gcc环境
0. yum -y install gcc gcc-c++
1.卸载旧版本
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.设置镜像的仓库
#阿里云镜像地址（不推荐使用国外镜像）
yum-config-manager \
--add-repo \
http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
4.更新yum软件包索引
yum makecache fast
4.安装docker引擎
yum install docker-ce docker-ce-cli containerd.io
#上面默认安装最新版本
#也可以自定义安装版本
5.启动docker
systemctl start docker
docker version #查看是否安装成功
6.测试 hello world
docker run hello-world
#没有寻找到镜像
Unable to find image 'hello-world:latest' locally
#远程拉取镜像
latest: Pulling from library/hello-world
0e03bdcc26d7: Pull complete
#签名信息->拉取成功
Digest: sha256:8c5aeeb6a5f3ba4883347d3747a7249f491766ca1caa47e5da5dfcf6b9b717c0
Status: Downloaded newer image for hello-world:latest
#docker镜像安装成功，仅此而已
Hello from Docker!
This message shows that your installation appears to be working correctly.
To generate this message, Docker took the following steps:
1. The Docker client contacted the Docker daemon.
2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
(amd64)
3. The Docker daemon created a new container from that image which runs the
executable that produces the output you are currently reading.
4. The Docker daemon streamed that output to the Docker client, which sent it
to your terminal.
To try something more ambitious, you can run an Ubuntu container with:
$ docker run -it ubuntu bash
Share images, automate workflows, and more with a free Docker ID:
https://hub.docker.com/
For more examples and ideas, visit:
https://docs.docker.com/get-started/
7.查看helloworld镜像
[root@VM-8-5-centos ~]# docker images|grep hello
hello-world latest bf756fb1ae65 9 months ago 13.3kB
8.不想玩docker，卸载
- 卸载依赖和软件包
yum remove docker-ce docker-ce-cli containerd.io
- 删除资源，包括仓库镜像，容器和配置文件
rm -rf /var/lib/docker
#docker 默认工作路径 /var/lib/docker
阿里云镜像加速
- 详细了解请移步阿里云官网
配置操作
#针对Docker客户端版本大于 1.10.0 的用户
#您可以通过修改daemon配置文件/etc/docker/daemon.json来使用加速器
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
"registry-mirrors": ["https://gj7w7sc5.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker
Hello-world服务如何执行？
docker run hello-world
开始运行->Docker会在本机寻找镜像？
有，使用这个镜像，创建容器，运行！；
没有镜像，去Docker-Hub（阿里云）上下载镜像->是否可以找到镜像？
可以找到，下载镜像到本地，运行；
找不到，返回错误，找不到镜像
底层原理
docker是怎么工作的？
- Docker是一个CS结构进程，Docker的守护进程Daemon运行在宿主机上。通过Socket从客户端访问（类似Mysql）！
- DockerServer接收到Docker-Client的指令，就会执行这个命令
- 宿主机的端口需要与容器里面的端口进行联通，容器端口才能开放使用
- Docker容器是一个小型虚拟机
Docker为什么比虚拟机快？
- Docker与虚拟机系统的比较是基于两者在同个服务器运行下进行的；
- Docker有比虚拟机更少的抽象层
- docker利用宿主机的内核，vm需要guest os
- 新建docker容器的时候，docker不需要像虚拟机一样重新加载一个操作系统；虚拟机加载GuestOS，分钟级别；docker利用宿主机系统，秒级
-
现在Docker支持大部分OS
-
将所有命令学习完之后，重新回过头看这一段理论！实践。
L04 常用命令与实例
帮助命令
docker version #显示版本信息
docker info #显示docker的系统信息，镜像和容器的数量
docker cmd --help
- 帮助文档地址：文档 ，一边查文档一边了解命令
镜像命令
docker images 查看所有本地主机上的镜像
[root@VM-8-5-centos ~]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
hello-world latest bf756fb1ae65 9 months ago 13.3kB
#解释
repository 镜像仓库源
tag 奖项标签
image id 镜像id
created 镜像创建时间
size 镜像大小
#可选项
-a --all #列出所有镜像
-q --quiet #只显示镜像的id
docker search 搜索镜像
#相当于在hub.docker.com商店里面寻找软件
docker search mysql
docker search --help
--filter=STARS=3000
docker pull 下载镜像
# docker pull mysql [:tag]
# 如果不写tag，默认最新版本
# 分层下载，docker镜像的核心 联合文件系统
# 签名，防伪
# 真实地址
docker pull mysql
#等价写法
docker pull docker.io/library/mysql:latest
#指定版本下载 官方文档要有
docker pull mysql:5.7
#先学会命令再理解命令
[root@VM-8-5-centos ~]# docker pull mysql:5.7
5.7: Pulling from library/mysql
bb79b6b2107f: Already exists
49e22f6fb9f7: Already exists
842b1255668c: Already exists
9f48d1f43000: Already exists
c693f0615bce: Already exists
8a621b9dbed2: Already exists #不需要再重复下载
0807d32aef13: Already exists #直接用之前版本下载过的文件
f15d42f48bd9: Pull complete
098ceecc0c8d: Pull complete
b6fead9737bc: Pull complete
351d223d3d76: Pull complete
Digest: sha256:4d2b34e99c14edb99cdd95ddad4d9aa7ea3f2c4405ff0c3509a29dc40bcb10ef
Status: Downloaded newer image for mysql:5.7
docker.io/library/mysql:5.7
[root@VM-8-5-centos ~]# docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
mysql 5.7 1b12f2e9257b 2 days ago 448MB
mysql latest db2b37ec6181 2 days ago 545MB
hello-world latest bf756fb1ae65 9 months ago 13.3kB
docker rmi 删除镜像
docker rmi -f 镜像id #删除指定镜像
docker rmi -f 镜像id 镜像id 镜像id 镜像id #删除多个镜像
docker rmi -f $(docker images -aq) #批量全删
容器命令
有了镜像才能创建容器，linux，下一个centos镜像来测试学习
docker pull centos
docker run --help
新建容器并启动
docker run [可选参数] image
#参数说明
--name="Name" #容器名字，区分容器
-d #后台方式运行 类似centos的&
-it #使用交互方式运行，进入容器查看内容
-p #指定容器的端口 -p 8080:8080
-p 主机端口：容器端口 （常用）
-p ip:主机端口：容器端口
-p 容器端口
容器端口
-P #随机指定端口
#测试
#启动并进入容器
[root@VM-8-5-centos ~]# docker run -it centos /bin/bash
#root@容器id
[root@0e1bc302ed02 /]# ls
#查看容器内centos的目录，基础镜像，很多命令不完善
bin etc lib lost+found mnt proc run srv tmp var
dev home lib64 media opt root sbin sys usr
#exit 从容器中返回主机
[root@0e1bc302ed02 /]# exit
exit
[root@VM-8-5-centos ~]# ls
列出当前运行的容器
#docker ps
# 列出当前正在运行的容器
# -a 列出当前正在运行的容器+顺带历史运行过的容器
# -n=1 列出最近一个运行的容器
# -q 只显示容器的编号
[root@VM-8-5-centos ~]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
[root@VM-8-5-centos ~]# docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
0e1bc302ed02 centos "/bin/bash" 6 minutes ago Exited (0) 3 minutes ago determined_dijkstra
6c8484431df1 bf756fb1ae65 "/hello" 5 hours ago Exited (0) 5 hours ago funny_newton
1dbbe1da9bcc bf756fb1ae65 "/hello" 5 hours ago Exited (0) 5 hours ago festive_knuth
[root@VM-8-5-centos ~]# docker ps -aq
0e1bc302ed02
6c8484431df1
1dbbe1da9bcc
[root@VM-8-5-centos ~]# docker ps -aqn=1
0e1bc302ed02
退出容器
$ exit # 直接容器停止并退出
ctrl +p +q # 停止不退出
删除容器
- 运行的容器不能直接删除
- 强制删除 rm -f
$ docker rm containerID #删除指定的容器，不能删除正在运行的容器，如果要强制删除 rm -f
$ docker rm -f $(docker ps -aq) #remove all
$ docker ps -a -q |xargs docker rm #删除所有
[root@VM-8-5-centos ~]# docker ps -aq
0e1bc302ed02
6c8484431df1
1dbbe1da9bcc
[root@VM-8-5-centos ~]# docker ps -aq|xargs docker rm
0e1bc302ed02
6c8484431df1
1dbbe1da9bcc
[root@VM-8-5-centos ~]# docker ps -aq
启动和停止容器的操作
$ docker start conID
$ docker restart conID
$ dokcer stop conID
$ docker kill conID
#进入容器
[root@VM-8-5-centos ~]# docker run -it centos /bin/bash
#退出容器
[root@7a33015ccdbd /]# exit
exit
#查看运行过的容器
[root@VM-8-5-centos ~]# docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
7a33015ccdbd centos "/bin/bash" 35 seconds ago Exited (0) 29 seconds ago focused_pike
#启动该容器
[root@VM-8-5-centos ~]# docker start 7a33015ccdbd
7a33015ccdbd
#查看容器状态
[root@VM-8-5-centos ~]# docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
7a33015ccdbd centos "/bin/bash" 55 seconds ago Up 3 seconds focused_pike
#停止该容器
[root@VM-8-5-centos ~]# docker stop 7a33015ccdbd
7a33015ccdbd
#查看容器状态
[root@VM-8-5-centos ~]# docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
7a33015ccdbd centos "/bin/bash" About a minute ago Exited (0) 2 seconds ago focused_pike
#杀死容器
[root@VM-8-5-centos ~]# docker kill 7a33015ccdbd
7a33015ccdbd
[root@VM-8-5-centos ~]# docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
7a33015ccdbd centos "/bin/bash" About a minute ago Exited (137) 2 seconds ago focused_pike
常用其他命令
后台启动容器
$ docker run -d centos
$ docker ps
#centos停止了？
#docker，容器使用后台运行，必须要有一个前台进程
#docker，发现没有应用，就会自动停止
查看日志命令
$ docker logs
$ docker logs --help
$ docker logs --tail 10 containID
$ docker logs -f -t --since="2020-10-18" containID
查看容器中进程的信息
$ docker top --help
$ docker top containID
查看镜像的元数据
docker inspect --help
docker inspect containID
测试：
[root@VM-8-5-centos ~]# docker inspect 67a2e275250e
[
{#全名的容器id
"Id": "67a2e275250eb83f1ead8a4b99fd9edd7396aada54dfebf92cce9c9e883b359a",
#创建时间
"Created": "2020-10-25T14:49:48.466019284Z",
"Path": "/bin/bash",
"Args": [],
"State": {
"Status": "exited",
"Running": false,
"Paused": false,
"Restarting": false,
"OOMKilled": false,
"Dead": false,
"Pid": 0,
"ExitCode": 0,
"Error": "",
"StartedAt": "2020-10-25T14:49:48.752641877Z",
"FinishedAt": "2020-10-25T14:49:51.06143372Z"
},
#镜像id全名
"Image": "sha256:0d120b6ccaa8c5e149176798b3501d4dd1885f961922497cd0abef155c869566",
#配置文件路径
"ResolvConfPath": "/var/lib/docker/containers/67a2e275250eb83f1ead8a4b99fd9edd7396aada54dfebf92cce9c9e883b359a/resolv.conf",
#主机名路径
"HostnamePath": "/var/lib/docker/containers/67a2e275250eb83f1ead8a4b99fd9edd7396aada54dfebf92cce9c9e883b359a/hostname",
#主机文件路径
"HostsPath": "/var/lib/docker/containers/67a2e275250eb83f1ead8a4b99fd9edd7396aada54dfebf92cce9c9e883b359a/hosts",
#日志路径
"LogPath": "/var/lib/docker/containers/67a2e275250eb83f1ead8a4b99fd9edd7396aada54dfebf92cce9c9e883b359a/67a2e275250eb83f1ead8a4b99fd9edd7396aada54dfebf92cce9c9e883b359a-json.log",
"Name": "/suspicious_hypatia",
"RestartCount": 0,
"Driver": "overlay2",
"Platform": "linux",
"MountLabel": "",
"ProcessLabel": "",
"AppArmorProfile": "",
"ExecIDs": null,
"HostConfig": {
"Binds": null,
"ContainerIDFile": "",
"LogConfig": {
"Type": "json-file",
"Config": {}
},
"NetworkMode": "default",
"PortBindings": {},
"RestartPolicy": {
"Name": "no",
"MaximumRetryCount": 0
},
"AutoRemove": false,
"VolumeDriver": "",
"VolumesFrom": null,
"CapAdd": null,
"CapDrop": null,
"Capabilities": null,
"Dns": [],
"DnsOptions": [],
"DnsSearch": [],
"ExtraHosts": null,
"GroupAdd": null,
"IpcMode": "private",
"Cgroup": "",
"Links": null,
"OomScoreAdj": 0,
"PidMode": "",
"Privileged": false,
"PublishAllPorts": false,
"ReadonlyRootfs": false,
"SecurityOpt": null,
"UTSMode": "",
"UsernsMode": "",
"ShmSize": 67108864,
"Runtime": "runc",
"ConsoleSize": [
0,
0
],
"Isolation": "",
"CpuShares": 0,
"Memory": 0,
"NanoCpus": 0,
"CgroupParent": "",
"BlkioWeight": 0,
"BlkioWeightDevice": [],
"BlkioDeviceReadBps": null,
"BlkioDeviceWriteBps": null,
"BlkioDeviceReadIOps": null,
"BlkioDeviceWriteIOps": null,
"CpuPeriod": 0,
"CpuQuota": 0,
"CpuRealtimePeriod": 0,
"CpuRealtimeRuntime": 0,
"CpusetCpus": "",
"CpusetMems": "",
"Devices": [],
"DeviceCgroupRules": null,
"DeviceRequests": null,
"KernelMemory": 0,
"KernelMemoryTCP": 0,
"MemoryReservation": 0,
"MemorySwap": 0,
"MemorySwappiness": null,
"OomKillDisable": false,
"PidsLimit": null,
"Ulimits": null,
"CpuCount": 0,
"CpuPercent": 0,
"IOMaximumIOps": 0,
"IOMaximumBandwidth": 0,
"MaskedPaths": [
"/proc/asound",
"/proc/acpi",
"/proc/kcore",
"/proc/keys",
"/proc/latency_stats",
"/proc/timer_list",
"/proc/timer_stats",
"/proc/sched_debug",
"/proc/scsi",
"/sys/firmware"
],
"ReadonlyPaths": [
"/proc/bus",
"/proc/fs",
"/proc/irq",
"/proc/sys",
"/proc/sysrq-trigger"
]
},
"GraphDriver": {
"Data": {
"LowerDir": "/var/lib/docker/overlay2/f881c1d3c6bc85b40fa40cd191171e3e6129c1bffe6d25904e3a16bc9376956a-init/diff:/var/lib/docker/overlay2/8f29b9bd5d437c085e25dd865f0c615b0493c966e657b7d6066381e6336ffd14/diff",
"MergedDir": "/var/lib/docker/overlay2/f881c1d3c6bc85b40fa40cd191171e3e6129c1bffe6d25904e3a16bc9376956a/merged",
"UpperDir": "/var/lib/docker/overlay2/f881c1d3c6bc85b40fa40cd191171e3e6129c1bffe6d25904e3a16bc9376956a/diff",
"WorkDir": "/var/lib/docker/overlay2/f881c1d3c6bc85b40fa40cd191171e3e6129c1bffe6d25904e3a16bc9376956a/work"
},
"Name": "overlay2"
},
"Mounts": [],
"Config": {
"Hostname": "67a2e275250e",
"Domainname": "",
"User": "",
"AttachStdin": true,
"AttachStdout": true,
"AttachStderr": true,
"Tty": true,
"OpenStdin": true,
"StdinOnce": true,
"Env": [
"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
],
"Cmd": [
"/bin/bash"
],
"Image": "centos",
"Volumes": null,
"WorkingDir": "",
"Entrypoint": null,
"OnBuild": null,
"Labels": {
"org.label-schema.build-date": "20200809",
"org.label-schema.license": "GPLv2",
"org.label-schema.name": "CentOS Base Image",
"org.label-schema.schema-version": "1.0",
"org.label-schema.vendor": "CentOS"
}
},
"NetworkSettings": {
"Bridge": "",
"SandboxID": "bc1aaf2c9670511e1936ab2fd6c1c3ebfe506c2bc6f99da36dc462474719bb18",
"HairpinMode": false,
"LinkLocalIPv6Address": "",
"LinkLocalIPv6PrefixLen": 0,
"Ports": {},
"SandboxKey": "/var/run/docker/netns/bc1aaf2c9670",
"SecondaryIPAddresses": null,
"SecondaryIPv6Addresses": null,
"EndpointID": "",
"Gateway": "",
"GlobalIPv6Address": "",
"GlobalIPv6PrefixLen": 0,
"IPAddress": "",
"IPPrefixLen": 0,
"IPv6Gateway": "",
"MacAddress": "",
"Networks": {
"bridge": {
"IPAMConfig": null,
"Links": null,
"Aliases": null,
"NetworkID": "bb61c238325251213a4024741ff5f896cb0c88e1f3ae125be7ba44a460fa2338",
"EndpointID": "",
"Gateway": "",
"IPAddress": "",
"IPPrefixLen": 0,
"IPv6Gateway": "",
"GlobalIPv6Address": "",
"GlobalIPv6PrefixLen": 0,
"MacAddress": "",
"DriverOpts": null
}
}
}
}
]
进入当前正在运行的容器
#通常容器都是使用后台方式运行，需要进入容器，修改一些配置
#cmd
#exec 进入容器后开启一个新的终端可以在里面操作
eg1:
$ docker exec -it conID /bin/bash
$ ps -ef
#attach 进入容器正在执行的终端，不会启动新的进程
eg2:
$ docker attach --help
$ docker attath conID
正在执行当前的代码...
从容器内拷贝文件到主机上（拷出来）
$ docker cp --help
$ docker cp 容器id:容器内路径 目的主机路径
#1.先进去容器，创建文件
$ docker attach conID
$ cd /home
$ ls
$ touch filename
$ exit
#2.文件拷贝出来到宿主机上
$ docker ps -a #容器在，数据就在，与容器是否运行没有关系
$ docker cp conID:/home/filename /localfilepath
$ ls
#3.拷贝是一个手动过程，可以使用-v卷的技术，实现自动同步
nginx（谈端口映射）
#先部署，测试
$ docker images
$ docker run -d --name nginx01 -p 3344:80 nginx
$ curl localhost 3344:80
$ docker stop conID
$ curl localhost 3344:80
----------------------------
#再具体配置
$ docker exec -it nginx01 /bin/bash
$ whereis nginx
$ cd /etc/nginx
- 端口映射
- 思考：每次修改nginx配置文件，都需要进入容器内部？十分麻烦，有什么方法可以在容器外部提供映射路径，达到在容器修改文件名，容器内部可以自动修改？-v 数据卷技术；
docker run -it -v /usr/share/nginx:/usr/nginx -d --name -p 3344:80 nginx01 nginx
Tomat（谈进入容器测试）
#官方使用
#↓一般用来测试，用完即删
$ docker run -it --rm tomcat:9.0
#之前启动都是后台启动使用，停止之后，容器还是可以查到
#安装镜像
$ docker pull tomcat
#启动容器测试成功性
$ docker run -d -it 3355:8080 --name tomcat0001 tomcat
#测试成功，进入容器
$ docker exec -it tomcat01 /bin/bash
$ ls
#发现问题
1.linux命令少了
2.缺少webapps：阿里云镜像，默认是最小的镜像，所有的不必要文件都被剔除掉了；保证最小可运行环境；
#测试
$ cp -r webapps.dist/* webapps
$ ls webapps
ROOT docs examples host-manager manager
- 注意：防火墙添加规则
- 思考：以后要部署项目，每次都要进入容器是否很麻烦？如何解决？是否可以考虑在容器外部提供一个映射路径，如webapps，我们在外部放置项目，就自动同步到内部就好了？
ES+Kibana（看容器存活状态）
ES：elastic search6
Kibana:ES的可视化操作界面
#es暴露端口很多，十分耗内存，数据一般需要放置到安全目录！
#网络配置
$ docker network create somenetwork
#启动
$ docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:7.6.2
#因为耗内存1.?G，且系统只有2G1核,运行linux命令就卡住了,
$ docker stop conID #关掉不相关的容器
#测试
[root@ /]# curl localhost:9200
{
"name" : "01901361d544",
"cluster_name" : "docker-cluster",
"cluster_uuid" : "ajxYlt8vRYuHqdW2LhjNsw",
"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"
}
#占据内存
^C
$ docker stats
CONTAINER ID NAME CPU % MEM USAGE / LIMIT MEM % NET I/O BLOCK I/O PIDS
01901361d544 elasticsearch 0.20% 1.24GiB / 1.795GiB 69.11% 6.66kB / 7.55kB 202MB / 737kB 43
^C
#关闭服务之后。增加内存的限制,修改 配置文件，-e
$ docker run -d --name elasticsearch01 -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPTS="-Xms64m -Xmx512m" elasticsearch:7.6.2
$ docker stats 445b76e96be7
CONTAINER ID NAME CPU % MEM USAGE / LIMIT MEM % NET I/O BLOCK I/O PIDS
445b76e96be7 elasticsearch 36.17% 361.8MiB / 1.795GiB 19.69% 656B / 0B 108MB / 729kB 43
$ curl localhost:9200
{
"name" : "445b76e96be7",
"cluster_name" : "docker-cluster",
"cluster_uuid" : "Fjhou5OHQxmFs-82lWKe2Q",
"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图形化界面管理工具！提供一个后台面板提供操作
docker run -d -p 8088:9000 \
--restart=always \
-v /var/run/docker.sock:/var/run/docker.sock \
--privileged=true \
portainer/portainer
访问测试：8088；注册；登陆
- Rancher（CI/CD）
总结
- 以下是最常见的容器和镜像的命令，之后还有很多！
L05 镜像讲解
镜像是什么
- 镜像是一种轻量级，可执行的独立软件包，用来打包软件运行环境和基于运行环境开发的软件，它包含运行某个软件所需的所有内容，代码，运行时，库，环境变量，配置文件；
- 所有的应用直接打包docker镜像，就可以直接跑起来！
如何得到镜像
- 远程仓库下载
- 朋友拷贝给自己
- 自己制作镜像Dockerfile
镜像加载原理
UnionFS 联合文件系统
- 新增还是叠加？
Docker镜像加载原理
- 虚拟机是分钟级别，容器是秒级
分层理解
分层的镜像
- 下载层数多；
- 已经下载过的就不用继续下载了；
docker image inspect redis:latest
![2020-10-26_180639](2020-10-26_180639.jpg#分层信息：对应每个步骤
"RootFS": {
"Type": "layers",
"Layers": [
"sha256:d0fe97fa8b8cefdffcef1d62b65aba51a6c87b6679628a2b50fc6a7a579f764c",
"sha256:832f21763c8e6b070314e619ebb9ba62f815580da6d0eaec8a1b080bd01575f7",
"sha256:223b15010c47044b6bab9611c7a322e8da7660a8268949e18edde9c6e3ea3700",
"sha256:a1a4c1d0c191cee2ac3912696fe57cf9ad84cbfaf3d13f314061bd89fe73cabb",
"sha256:e9acf707b7fe3eef2f7c6bd127b3b34b262889cb670013adfb46883a49a4ac8e",
"sha256:b854b24feeee6cbd8fc5d6401f5f1b4a3d40c483444e6c4b06a2b7b31f347b40"
]
},
"Metadata": {
"LastTagTime": "0001-01-01T00:00:00Z"
}
特点
- 分层下载，复用；
- 对容器内部表现为有层级性的文件系统；
- 对容器外的系统表现为无差别的普通文件；
- Docker镜像都是只读，容器启动时候，一个新的可写层被加载到镜像的顶部；
- 这一层就是常说的容器层，容器之下都叫做镜像层；
Tomcat6个层级-pull下来>运行，执行run，在原本六层的镜像层基础上生成了一个可以进行操作的容器层->打包commit，形成七层的镜像层
commit镜像
docker commit #提交容器，成为一个新的副本
#命令与git原理相似
docker commit -m="提交的描述信息" -a="作者" 容器id 目标镜像名，[TAG]
#1.启动一个默认的tomcat
docker run -it -p 8080:8080 tomcat
#2.发现默认的tomcat 是没有webapps应用，官方的镜像是最精简化的
docker exec -it 9d3ae02756de /bin/bash
#3.自己拷贝进去一个基本的app文件，表示在容器层进行了一系列操作
cp ./webapps.dist webapps -r
exit
#4.降自己操作过的容器通过commit选项 提交为一个新的镜像，以后就使用修改过的镜像就可以 ，这就是我们自己的镜像
docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS
9d3ae02756de tomcat "catalina.sh run" 7 minutes ago Up 7 minutes 0.0.0.0:8080->8080/tcp
$ docker commit -a="lpz" -m="add webapps" 9d3ae02756de tomcat_lpz:0.1
sha256:c0b65bb9a417f653fb448a4d3ae27f3137be3ee9d750ec87208955601db
$ docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
tomcat_lpz 0.1 c0b65bb9a417 34 seconds ago 653MB
tomcat 9.0 625b734f984e 3 days ago 648MB
总结：理解概念，接着实践，最后实践和理论相结合；至此docker已经入门，但远远不够！
如果想要保存容器当前的状态，就可以通过commit来提交，获得一个镜像；
好比之前学习过VM，快照！
L06 容器数据卷
- 相对于01-05难度加大
什么是容器数据卷
Docker理念：将应用和环境打包成一个镜像！
程序要保存数据，数据并不能放在容器里面，因为一旦数据放在容器，误操作删除掉容器，数据也随之消失；数据的持久化成为刚需
Eg:Mysql容器->删除容器->删库跑路->需求：Mysql存储在本地
因此容器可以有一个数据共享技术:
Docker中产生的数据，必须同步到本地
这种数据共享技术->卷技术，将容器内的目录挂载到虚拟机上
总结：容器的持久化和同步操作！容器间可以数据共享！
使用数据卷
方式1：直接命令挂载
docker run -it -v 主机目录：容器目录 镜像名 登陆方式
#1.测试文件的同步
[root@ ~]# docker run -it -v /home/cesh:/home centos /bin/bash
[root@670ff121e9cc /]#
#2.再开一个窗口登录到指定服务器
[root@ ~]#docdocker inspect 670ff121e9cc
"Mounts": [ //挂载 -v卷
{
"Type": "bind",
"Source": "/home/cesh", //主机内地址
"Destination": "/home", //docker容器内地址
"Mode": "",
"RW": true,
"Propagation": "rprivate"
}
],
[root@ ~]# cd /home
[root@ home]# ll
total 8
drwxr-xr-x 2 root root 4096 Oct 26 21:59 cesh
drwx------ 5 lighthouse lighthouse 4096 Oct 26 01:03 lighthouse
[root@ home]# cd cesh
[root@ cesh]# touch suzhuji
#3.容器内相应路径查看
[root@670ff121e9cc /]# cd /home
[root@670ff121e9cc home]# ls
[root@670ff121e9cc home]# ls
suzhuji
#4.容器创建文件
[root@670ff121e9cc home]# touch rongqi
#5.宿主机相应路径查看
[root@ cesh]# ls
rongqi suzhuji
#6.容器退出（停止容器），再去宿主机修改文件测试
[root@670ff121e9cc home]# exit
exit
[root@ cesh]# vim /home/ceshi/suzhuji
i am a boy!
#7.重新启动容器
[root@ ~]# docker start 670ff121e9cc
670ff121e9cc
[root@ ~]# docker attach 670ff121e9cc
[root@670ff121e9cc /]# cd /home
[root@670ff121e9cc home]# ls
rongqi suzhuji
#8.容器内的数据在启动后继续同步
[root@670ff121e9cc home]# cat suzhuji
i am a boy!
总结：以后修改配置文件，数据文件等都可以在宿主机本地进行修改！道道容器的持久化和同步操作，容器之间可以数据共享！
安装MSQL
- 查官方文档
1. hub.docker.com
2. search mysql
3. asure:5.7
4. 查初始登陆说明
5. 运行选项说明
# -d 后台运行 -v 数据卷挂载共享/多个
# -p 端口映射 -e 环境配置
# --name 容器名字
# 镜像名：版本
[root@ ~]# docker run -d -p 3344:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql \
> -e MYSQL_ROOT_PASSWORD=123456 --name mysql_lpz mysql:5.7
70bc152bd24869e48a05d57b3731b9d0a05cb7c57a591c415207cfe65dfc6192
#登陆成功后，本地使用第三方工具：SQLyog测试登陆
#ip
#password
#port
#sqlyog连接到服务器的3344 ，服务器的3344端口与容器内的3306映射，这个时候连接成功
- 通过本地第三方工具间接在容器内创建数据库，查看宿主机数据库数据文件变化
[root@ data]# ls
auto.cnf ca.pem client-key.pem ibdata1 ib_logfil
ca-key.pem client-cert.pem ib_buffer_pool ib_logfile0 ibtmp1
[root@ data]# ls
auto.cnf ibdata1 private_key.pem
ca-key.pem ib_logfile0 public_key.pem
ca.pem ib_logfile1 server-cert.pem
client-cert.pem ibtmp1 server-key.pem
client-key.pem mysql sys
ib_buffer_pool performance_schema test
- 删除数据库测试
[root@ data]# docker kill mysql_lpz
mysql_lpz
[root@ data]# docker rm mysql_lpz
mysql_lpz
[root@ data]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
#测试宿主机
[root@ mysql]# cd /home/mysql
[root@ mysql]# ls data
auto.cnf ca.pem client-key.pem ibdata1 ib_logfile1 mysql private_key.pem server-cert.pem sys
ca-key.pem client-cert.pem ib_buffer_pool ib_logfile0 ibtmp1 performance_schema public_key.pem server-key.pem test
具名挂载和匿名挂载
#匿名挂载
-v 容器内路径！
-P 随机映射
docker run -d -P --name nginx01 -v /etc/nginx nginx
#查看所有的 volume 的情况
docker volume ls
#这里发现，都是匿名挂载，-v只写了容器内路径，没有写容器外路径，volumename显示随机数串
docker
#具名挂载
docker run -d -P --name nginx02 -v jvming-nginx:/etc/nginx nginx
#通过 -v 卷名：容器内路径
#查看卷
clear
docker volume inspect jvming-nginx
#测试
[root@ ~]# docker volume ls
DRIVER VOLUME NAME
local 0a36273b007e4b679abc5863fe5da5029b17804410884def64b4eca4fb54dc3d
[root@ ~]# docker volume inspect 0a36273b007e4b679abc5863fe5da5029b17804410884def64b4eca4fb54dc3d
[
{
"CreatedAt": "2020-10-26T16:16:59+08:00",
"Driver": "local",
"Labels": null,
"Mountpoint": "/var/lib/docker/volumes/0a36273b007e4b679abc5863fe5da5029b17804410884def64b4eca4fb54dc3d/_data",
"Name": "0a36273b007e4b679abc5863fe5da5029b17804410884def64b4eca4fb54dc3d",
"Options": null,
"Scope": "local"
}
]
- 所有docker容器内的卷，没有指定目录的情况下都是在，/var/lib/docker/volumes/xxx/_data
- 我们通过具名挂载可以方便的找到我们的一个卷，大多数情况在使用具名挂载
-v 容器内路径 #匿名挂载
-v 卷名:容器内路径 #具名挂载
-v /宿主机路径：容器内路径 #指定路径挂载
- 拓展：
#通过 -v 容器内路径，ro，rw改变读写权限
#一旦设定了容器权限，容器对我们挂载出来的内容就有限定了
docker run -d -P --name nginx02 -v jvming-nginx:/etc/nginx:ro nginx
docker run -d -P --name nginx02 -v jvming-nginx:/etc/nginx:rw nginx
#ro 这个路径内容只能通过宿主机来改变，容器内部无法操作
#rw
数据卷容器
-
先参考初识Dockerfile
-
之前课程讲述的都是容器与宿主机之间的数据同步
-
容器与容器之间如何数据同步？
-
多个MySQL同步数据！
-
谁去挂载到谁，谁就是父容器
#启动docker01
[root@ docker-test-volume]# docker images|grep linpengze/centos
linpengze/centos latest 427731168923 About a minute ago 215MB
[root@ docker-test-volume]# docker run -it --name centos01 linpengze/centos:latest
[root@6ab67abce6a4 /]# ls |grep volume
volume1
volume2
#ctrl+p+q
[root@6ab67abce6a4 /]# [root@ docker-test-volume]#
#启动centos02
[root@ docker-test-volume]# docker runrun -it --name docker02 --volumes-from docker01 linpengze/centos
Unable to find image 'linpengze/centos:latest' locally
^C
[root@ docker-test-volume]# docker runrun -it --name centos02 --volumes-from centos01 linpengze/centos
[root@cd54772a7271 /]# ls |grep volume
volume1
volume2
#进入centos01，在volume1目录下做测试操作
[root@ ~]# docker attach centos02
[root@cd54772a7271 /]#
[root@6ab67abce6a4 /]# cd volume1
[root@6ab67abce6a4 volume1]# touch centos01
#在centos02下测试
[root@cd54772a7271 /]# ls volume1
centos01
- 只要通过volumes-from实现数据共享
#删除centos01
[root@ docker-test-volume]# docker stop 6ab67abce6a4
6ab67abce6a4
[root@ docker-test-volume]# docker rm 6ab67abce6a4
6ab67abce6a4
[root@ docker-test-volume]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
cd54772a7271 linpengze/centos "/bin/sh -c /bin/bash" 20 minutes ago Up 20 minutes centos02
#测试centos02
[root@ ~]# docker attach centos02
[root@cd54772a7271 /]# ls volume1
centos01
多个mysql实现数据共享
#具名挂载方式创建第一个数据库
docker run -d -p 3344:3306 -v /home/mysql/conf:/etc/mysql/conf.d -v /home/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 --name mysql_lpz01 mysql:5.7
#创建第二个数据库，满足共享第一个数据库的数据
docker run -d -p 3355:3306 -e MYSQL_ROOT_PASSWORD=12345678 --name mysql_lpz02 --volumes-from mysql_lpz01 mysql:5.7
- 容器之间配置信息的传递，数据卷容器的生命周期一直持续到没有人使用为止；
- 但是一旦持久化到了本地，这个时候，本地的数据是不会删除的
L07 DockerFile
初识DockerFile
- Dockerfile就是用来构建Docker镜像的构建文件！命令参数脚本！
- 通过这个脚本可以生成镜像；镜像一层层；脚本是一个个命令，每个命令对应一层；
构建步骤：
1.编写dockerfile文件
2.docker build 构建成为一个镜像
3.docker run 运行镜像
4.docker pull 发布镜像 dockerhub 阿里云镜像仓库
- 测试
#进入目录：创建一个dockerfile文件
cd /home
mkdir docker-test-volume
cd docker-test-volume
#文件中的内容 指令大写
$ vim dockerfile1
FROM centos
VOLUME ["volume01"，"volume02"]
CMD echo "-----end-----"
CMD /bin/bash
#上面的每一个命令，就是镜像的一层
#根据文件创建容器
docker build -f /home/docker-test-volume/dockerfile1 -t linpengze/centos .
docker images
[root@ docker-test-volume]# docker build -f \
> /home/docker-test-volume/dockerfile \
> -t linpengze/centos .
Sending build context to Docker daemon 2.048kB
Step 1/4 : FROM centos
---> 0d120b6ccaa8
Step 2/4 : VOLUME ["volume1","volume2"]
---> Running in 13fe60f549b9
Removing intermediate container 13fe60f549b9
---> b7c640c88108
Step 3/4 : CMD echo "------end------"
---> Running in 396202138fe2
Removing intermediate container 396202138fe2
---> 5a76446a2acf
Step 4/4 : CMD /bin/bash
---> Running in 3e8922b656df
Removing intermediate container 3e8922b656df
---> 427731168923
Successfully built 427731168923
Successfully tagged linpengze/centos:latest
[root@ docker-test-volume]# docker images|grep linpengze/centos
linpengze/centos latest 427731168923 About a minute ago 215MB
#进入容器
docker run -it conID /bin/bash
ls |grep volume
#发现自动挂载的数据卷目录
#在共享数据卷里创建文件并退出
cd volume01
touch hahaxixi
exit
docker inspe
ct conID
#查看mounts
查找宿主机volume1下的文件内容
ls /var/lib/docker/volumes/????/_data
- 这个匿名挂载一定有一个同步的目录在宿主机
- 匿名挂载的路径依旧在/var/lib/docker/volumes下
- 这种方式未来使用比较频繁，因为我们通常会构建自己的镜像
- 假设构建镜像的时候没有挂载卷，就要手动镜像挂载 -v 卷名：容器内路径
查看官方镜像
- hub.docker.com搜索centos
- 选择任意的版本进入
- 页面跳转到对应版本的github仓库
- 很多官方镜像都是基础包，很多功能没有，我们通常要自己搭建自己的镜像
- 假设自需：centos+jdk+tomcat+mysql+redis；自制
- 官方可以自己制作镜像，我们也可以！
Dockerfile构建过程
基础知识
1.每个保留关键字（指令）必须是大写字母
2.从上到下执行
3.#表示注释
4.每一个指令都会创建提交一个新的镜像层，并提交！
| 层级内容（由下而上） | 层级 |
|---|---|
| 可写容器（Container） | 5（顶） |
| 镜像（Tomcat） | 4 |
| 镜像（JDK） | 3 |
| rootfs基础镜像（Cetos/Ubuntu） | 2 |
| Bootfs | 1（底） |
- Dockerfile面向开发，以后要发布项目，做镜像，信息需要编写dockerfile文件，这个文件不难构建！
- Docker逐渐成为企业交付的标准，必须要掌握！
- 步骤：开发，部署，运维。
- DockerFile：构建文件，定义了一切不厚，好比源代码
- DockerImage：通过DockerFile构建生成的镜像，最终发布和运行的产品；
- Docker容器：容器就是镜像运行起来提供服务器
总结：整个课程的设置是要先学会使用镜像和容器命令，最后利用所学来构建Dockerfile：工程领域叫做构建项目，容器技术领域叫做构建镜像；
Dockerfile指令
- 以前是使用别人的镜像，现在可以自己写一个镜像
| 指令 | 解释 |
|---|---|
| FROM | 基础镜像 centos |
| MAINTAINER | 镜像谁写的，姓名+邮箱 |
| RUN | 镜像构建时候需要运行的命令 |
| ADD | 步骤，Tomcat压缩包，这个压缩包，添加内容 |
| WORKDIR | 设置当前工作目录 |
| VOLUME | 设置卷，挂载主机目录 |
| EXPOSE | 指定对外端口 |
| CMD | 指定容器启动后要运行的命令，只最后一个会生效，-l可被替代 |
| ENTRYPOINT | 指定容器启动后要运行的命令，可以追加命令 |
| ONBUILD | 当构建一个被继承Dockerfie，这个时候会运行onbuild，触发指令 |
| COPY | 类似add，将文件拷贝到镜像中 |
| ENV | 构建的时候设置环境变量 |
实战测试
- dockerhub中99%镜像都是从这个基础镜像过来的FROM scrach ，然后配置需要的软件和配置来进行构建
#创建一个自己的centos
#1.编写
[root@ home]# mkdir dockerfile
[root@ home]# cd dockerfile/
[root@ dockerfile]# ls
[root@ dockerfile]# vim mydockerfile-centos
FROM centos
FROM centos
MAINTAINER linpengze
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] .
[root@ dockerfile]# docker build -f mydockerfile-centos -t linpengze/centos:0.1 .
...
Successfully built 764dc97d3166
Successfully tagged linpengze/centos:0.1
[root@ dockerfile]# docker images |grep linpengze/centos
linpengze/centos 0.1 764dc97d3166 About a minute ago 295MB
#3.测试运行
[root@ dockerfile]# docker run -it linpengze/centos:0.1
#测试当前目录：确定是预设镜像里所要求的；原生默认是根目录
[root@208ca3b11ab8 local]# pwd
/usr/local
#测试net-tools命令，原生centos没有这个命令
[root@208ca3b11ab8 local]# ifconfig
eth0: flags=4163 mtu 1500
inet 172.17.0.4 netmask 255.255.0.0 broadcast 172.17.255.255
ether 02:42:ac:11:00:04 txqueuelen 0 (Ethernet)
RX packets 8 bytes 656 (656.0 B)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 0 bytes 0 (0.0 B)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0
...
#测试vim，原先没有这个功能
[root@208ca3b11ab8 local]# vim aa
[1]+ Stopped vim aa
- 列出本地对镜像进行的历史变更，查看所有的镜像是怎么生成的，因此，我们也可以平时研究别人怎制作镜像
docker history imageID
CMD和ENTRYPOINT的区别
- 命令追加可否？
| 命令 | 解释 |
|---|---|
| CMD | 指定容器启动后要运行的命令，只最后一个会生效，-l可被替代 |
| ENTRYPOINT | 指定容器启动后要运行的命令，可以追加命令 |
测试CMD
#编写文件
[root@ docker-test-volume]# cat dockerfile-cmd-test
FROM centos
CMD ["ls","-a"]
#构建
[root@ docker-test-volume]# docker build -f \
> dockerfile-cmd-test -t cmdtest .
Sending build context to Docker daemon 3.072kB
Step 1/2 : FROM centos
---> 0d120b6ccaa8
Step 2/2 : CMD ["ls","-a"]
---> Running in 68836b647119
Removing intermediate container 68836b647119
---> d941b7e1d981
Successfully built d941b7e1d981
Successfully tagged cmdtest:latest
#运行只有最后一个命令会生效，ls -a
[root@ docker-test-volume]# docker run d941b7e1d981
.
..
.dockerenv
bin
...
var
追加一个命令
[root@ docker-test-volume]# docker run d941b7e1d981 -l
docker: Error response from daemon: OCI runtime create failed: container_linux.go:349: starting container process caused "exec: \"-l\": executable file not found in $PATH": unknown.
#cmd的清理下， -l 替换了CMD ["ls","-l"]命令，又由于-l不是命令，所以会报错
[root@ docker-test-volume]# docker run d941b7e1d981 ls -al
total 56
drwxr-xr-x 1 root root 4096 Oct 27 05:42 .
...
测试ENTRYPOINT
[root@ docker-test-volume]# cat dockerfile-cmd-entrypoint
FROM centos
ENTRYPOINT ["ls","-l"]
[root@ docker-test-volume]# docker build -f \
> dockerfile-cmd-entrypoint -t entrypoint-test .
Sending build context to Docker daemon 5.12kB
Step 1/2 : FROM centos
---> 0d120b6ccaa8
Step 2/2 : ENTRYPOINT ["ls","-l"]
---> Running in 4bd5e65558b1
Removing intermediate container 4bd5e65558b1
---> 3333b6d2f71b
Successfully built 3333b6d2f71b
Successfully tagged entrypoint-test:latest
[root@ docker-test-volume]# docker run 3333b6d2f71b
total 48
lrwxrwxrwx 1 root root 7 May 11 2019 bin -> usr/bin
drwxr-xr-x 5 root root 340 Oct 27 06:15 dev
...
[root@ docker-test-volume]# docker run 3333b6d2f71b -h
total 48K
lrwxrwxrwx 1 root root 7 May 11 2019 bin -> usr/bin
- Dockerfile很多命令十分显示，需要了解其中的区别，需要对比然后进行效果测试；
实战：Tomcat镜像
- 准备镜像文件 tomcat压缩包，jdk的压缩包！
jdk安装包
ftp接收
apache-tomcat-9.0.22.tar.gz
Dockerfile
jdk-8ull-linux-x64.tar.gz
read.txt
- 编写dockerfile文件,官方命名Dockerfile，build会自动寻找这个文件，就不需要-f指定了
#原先都是手动配置
touch readme.txt
vim Dockerfile
FROM centos
MAINTAINER linpengze
COPY readme.txt /usr/local/readme.txt
ADD jdk-8ull-linux-x64.tar.gz /usr/local
ADD apache-tomcat-9.0.22.tar.gz
/usr/local
RUN yum -y install vim
ENV MYPATH /usr/local
WORKDIR $MYPATH
ENV JAVA_HOME /usr/local/jdk1.8.0_11
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/localapache-tomcat-9.0.22
ENV CATALINA_BASH /usr/localapache-tomcat-9.0.22
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
EXPOSE 8080
CMD /usr/local/apache-tomcat-9.0.22/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.22/bin/logs/catalina.out
- 构建镜像(当前目录下)
docker build -t ditomcat .
- 容器运行
略