docker
简介:
Docker 属于 Linux 容器的一种封装，提供简单易用的容器使用接口
Docker 将应用程序与该程序的依赖，打包在一个文件里面。运行这个文件，就会生成一个虚拟容器。
Docker 的接口相当简单，用户可以方便地创建和使用容器，把自己的应用放入容器。
Docker是基于Go语言实现的云开源项目，一次镜像，处处运行
Docker是内核级虚拟化
Docker镜像层都是只读的，容器层是可写的
Docker主要目标就是对应用组件的封装、发布、部署、运行等生命周期的管理
解决了运行环境和配置问题的软件容器， 方便做持续集成并有助于整体发布的容器虚拟化技术。
优点：
docker 启动快速属于秒级别。虚拟机通常需要几分钟去启动，需要的资源少，更轻量，可管理性，高可用和可恢复性
很重要的要说明的一点: Docker容器后台运行,就必须有一个前台进程
系统平滑移植，容器虚拟化技术。
Docker三个基本概念：
Docker 镜像（Image）就是一个只读的模板。
镜像可以用来创建 Docker 容器，一个镜像可以创建很多容器。
Image(镜像) 特殊的文件系统
docker容器是用镜像创建的运行实例
从镜像角度：可以把容器看做是一个简单版的linux环境
Docker公司提供的官方registry被称为Docker Hub，存放各种镜像模板的地方。
Container(容器) 一堆层的统一视角，上面那一层是可读可写的。
容器 = 镜像 + 读写层。
Repository(仓库) 一个仓库会包含同一个软件不同版本的镜像
仓库又可以分为两种形式：
private(私有仓库)
public(公有仓库)
使用c/s结构 客户端/服务器 后端是一个松耦合架构
docker安装网址
docker官网：网址
Docker Hub官网: 网址
最大的公开仓库是 Docker Hub(网址)
安装参考文档
Windows：网址
CentOS：网址
docker 运行流程
卸载旧的版本
yum remove docker
docker-client
docker-client-latest
docker-common
docker-latest
docker-latest-logrotate
docker-logrotate
docker-engine
安装 需要的安装包
yum install -y yum-utils
便捷安装版本
curl -fsSL get.docker.com -o get-docker.sh
sh get-docker.sh
yum安装gcc相关
yum -y install gcc
yum -y install gcc-c++
更新yum软件包索引
yum makecache fast
设置镜像仓库
#阿里云的
yum-config-manager
–add-repo
http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
更新yum包索引
yum makecache fast
安装docker Engine和containerd docker-ce 社区 ee企业版
yum install docker-ce docker-ce-cli containerd.io
docker卸载
查看docker里有没有下载的应用镜像
sudo docker images
卸载依赖
yum remove docker-ce docker-ce-cli containerd.io
删除资源
rm -rf /var/lib/docker #docker的默认工作路径
docker的卸载 首先关闭容器
查看状态
systemctl status docker
停止docker状态
systemctl stop docker
利用 rpm -qa查看docker的源文件
rpm -qa | grep docker
删除所有的包
yum -y remove docker*.x86_64
删除docker镜像文件
rm -rf /var/lib/docker
Cannot connect to the Docker daemon at unix:///var/run/docker.sock. Is the docker daemon running?出现问题
进入 /etc/docker
{
"registry-mirrors": ["https://registry.docker-cn.com"]
}
yum安装gcc相关
yum -y install gcc
yum -y install gcc-c++
安装需要的软件包
yum install -y yum-utils
设置stable镜像仓库
推荐
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
更新yum软件包索引
yum makecache fast
查看版本信息
docker version 或者
docker info
查看docker里有没有下载的应用镜像
sudo docker images
启动docker
systemctl start docker
重启docker
systemctl restart docker
查看docker状态
systemctl status docker
开机启动
systemctl enable docker
查看镜像/容器/数据卷所占的空间
docker system df
查看docker概要信息
docker info
删除资源
rm -rf /var/lib/docker #docker的默认工作路径
卸载依赖
yum remove docker-ce docker-ce-cli containerd.io
镜像命令
docker images
-a:列出所有镜像
-q:只显示镜像的ID
docker search 镜像名
列出本地主机上的镜像
docker images
有镜像才能创建容器，这是根本前提
docker pull centos
创建容器
docker run -tid 镜像ID/usr/sbin/init //centos7版本。使用/usr/sbin/init解决systemctl报错不能使用的问题
docker run -tid 镜像ID/bin/bash //非centos7
Docker文件拷贝
docker cp 原路径 docker容器路径（系统=>docker）
docker cpMySQL-server-5.6.38-1.el7.x86_64.rpm mysql_master2:/root/
docker cp docker容器路径 原路径（docker=>系统）
镜像
是一种轻量级、可执行的独立软件包，它包含运行某个软件所需的所有内容，我们把应用程序和配置依赖打包好形成一个可交付的运行环境(包括代码、运行时需要的库、环境变量和配置文件等)，这个打包好的运行环境就是image镜像文件。
阿里云镜像加速
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
"registry-mirrors": ["https://qbsnrzpx.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker
加载镜像(docker run)
docker有着比虚拟机更少的抽象层
docker利用的是宿主机的内核,而不需要加载操作系统OS内核
各个选项说明
REPOSITORY：表示镜像的仓库源
TAG：镜像的标签版本号
IMAGE ID：镜像ID
CREATED：镜像创建时间
SIZE：镜像大小
同一仓库源可以有多个 TAG版本，代表这个仓库源的不同个版本，我们使用 REPOSITORY:TAG 来定义不同的镜像。
如果你不指定一个镜像的版本标签，例如你只使用 ubuntu，docker 将默认使用 ubuntu:latest 镜像
docker run images
报错：
Unable to find image ‘nvcr.io/nvidia/tensorrt:latest’ locally
docker: Error response from daemon: manifest for nvcr.io/nvidia/tensorrt:latest not found: manifest unknown: manifest unknown.
See ‘docker run --help’.
解决方法：
使用docker images
docker run -it nvcr.io/nvidia/tensorrt:20.08-py3 /bin/bash
运行docker命令是 在前面不添加sudo
sudo usermod -aG docker $USER
docker pull 第三方仓库地址/仓库名称/镜像名称
docker pull hub.c.163.com/library/mysql:latest
-name="容器新名字" 为容器指定一个名称；
-d: 后台运行容器并返回容器ID，也即启动守护式容器(后台运行)；
-i：以交互模式运行容器，通常与 -t 同时使用；
-t：为容器重新分配一个伪输入终端，通常与 -i 同时使用；
也即启动交互式容器(前台有伪终端，等待交互)；
-P: 随机端口映射，大写P
-p: 指定端口映射，小写p
执行单条命令 (-i: 启动并且保留交互式命令行; -t:作用是分配一个虚拟的终端; docker run )
docker exec -it 容器名或容器id 执行的命令
如果我只需要执行简单的一两条命令可以使用docker exec
执行单条命令 (-i: 启动并且保留交互式命令行; -t:作用是分配一个虚拟的终端; docker run )
docker exec -it 容器名或容器id 执行的命令
用这种方法,我们还可以启动命令行,根据Linux的特性,系统程序会在/bin中,linux中常用的Shell有多个,其中大部分用的Linux默认的为bash 所以我们启动命令可以自行如下命令(除了/bin/bash外,linux一般还会带/bin/sh、/bin/rbash、/bin/dash等,具体区别可以自行百度)
docker exec -it 容器名或容器id /bin/bash
除了exec外还有attach可以使用,但它有个弊端,多终端启动attach后,都会会同步显示。如果有一个窗口阻塞了，那么其他窗口也无法再进行操作。
docker attach 容器名或容器id
从主机复制到容器 docker cp host_path containerID:container_path
从容器复制到主机 docker cp containerID:container_path host_path
关系 前后对比 - 开始 启动守护式容器(后台服务器)
docker images 查询到镜像
启动容器
docker run -it ubuntu /bin/bash
docker exec -it 容器名称或者ID /bin/bash
启动已停止运行的容器
docker start 容器ID或者容器名
获取镜像信息
docker inspect
查看已经启动的服务
systemctl list-units --type=service
查看是否设置开机启动
systemctl list-unit-files | grep docker
设置开机启动
systemctl enable docker.service
关闭开机启动
systemctl stop docker.service
查看容器名称
docker ps
设置容器自启
docker update --restart=always 容器名称
设置服务自启动：chkconfig --level 3 docker on
禁止服务自启动：chkconfig --level 3 docker off
查看服务是否自启动：chkconfig --list docker
列出系统所有服务的启动情况：chkconfig --list
删除镜像
docker rmi 名称
批量删除镜像
docker rmi docker images -q
创建镜像
docker create
-i：让容器的输入保持打开
-t：让 Docker 分配一个伪终端示例：
示例
docker create -it nginx:latest /bin/bash
启动容器
docker start 容器的ID/名称
重启容器
docker restart 容器ID或者容器名
重新进入
docker attach 容器ID
停止容器
docker container stop 容器名或者id
强制停止容器
docker kill 容器ID或容器名
强制关闭某容器
docker kill 容器名或者id
查询容器的启动信息
docker ps -a
删除已停止的容器
docker rm 容器ID
删除容器
docker rmi -f 容器id
禅道
docker run -d -p 8888:80 -p 3386:3306 -e USER=“admin” -e PASSWD=“123456” -e BIND_ADDRESS=“false” -e SMTP_HOST=“163.177.90.125 smtp.exmail.qq.com” -v /data/zbox/:/opt/zbox/ --name zentao-server idoop/zentao:latest
查看日志
docker logs 容器ID
查看容器内运行的进程
docker top 容器ID
查看容器内部细节
docker inspect 容器ID
导出容器
docker export 容器ID > 文件名.tar
导入容器
cat 文件名.tar | docker import - 镜像用户/镜像名:镜像版本号
有镜像才能创建容器，这是根本前提(下载一个Redis6.0.8镜像演示)
启动守护式容器(后台服务器)
-d 指定容器的后台运行模式
·redis 前后台启动演示case
·前台交互式启动
· docker run -it redis:6.0.8
·后台守护式启动
·docker run -d redis:6.0.8
UnionFS（联合文件系统）
Union文件系统（UnionFS）是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加
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等等。
镜像重点理解！
Docker镜像层都是只读的，容器层是可写的
当容器启动时，一个新的可写层被加载到镜像的顶部。这一层通常被称作“容器层”，“容器层”之下的都叫“镜像层”。
Docker镜像commit操作案例
docker commit提交容器副本使之成为一个新的镜像
docker commit -m=“提交的描述信息” -a=“作者” 容器ID 要创建的目标镜像名:[标签名]
-a :提交的镜像作者；
-m :提交时的说明文字；
原始的默认Ubuntu镜像是不带着vim命令的
docker容器内执行上述两条命令：
apt-get update
apt-get -y install vim
默认没有vim 通过执行命令
新增加了vim功能，可以成功使用。
Docker中的镜像分层，支持通过扩展现有镜像，创建新的镜像。
镜像上传到阿里云
阿里云开发者平台：https://promotion.aliyun.com/ntms/act/kubernetes.html
Docker中的镜像分层，支持通过扩展现有镜像，创建新的镜像。
类似Java继承于一个Base基础类，自己再按需扩展。
新镜像是从 base 镜像一层一层叠加生成的。每安装一个软件，
就在现有镜像的基础上增加一层
阿里云配置仓库
选择控制台，进入容器镜像服务
将镜像推送到阿里云
将镜像推送到阿里云registry
管理界面脚本
脚本实例
登录阿里云Docker Registry
docker login --username=孟先生0411 registry.cn-hangzhou.aliyuncs.com
docker tag [ImageId] registry.cn-hangzhou.aliyuncs.com/mengxx/myubuntu:[镜像版本号]
docker push registry.cn-hangzhou.aliyuncs.com/mengxx/myubuntu:[镜像版本号]
镜像从阿里云上面进行下载到本地
从Registry中拉取镜像
docker pull registry.cn-hangzhou.aliyuncs.com/mengxx/myubuntu:[镜像版本号]
本地镜像发布到私有库流程
官方Docker Hub地址：https://hub.docker.com/，中国大陆访问太慢了且准备被阿里云取代的趋势，不太主流。
Docker Registry是官方提供的工具，可以用于构建私有镜像仓库
下载镜像
Docker Registry
docker pull registry
运行私有库Registry，相当于本地有个私有Docker hub
仓库被创建在容器的/var/lib/registry目录下，建议自行用容器卷映射，方便于宿主机联调
docker run -d -p 5000:5000 -v /ubuntu/myregistry --privileged=true registry
ubuntu安装ifconfig命令
默认是不带着ifconfig命令
容器内ifconfig命令
docker容器内执行上述两条命令：
apt-get update
apt-get install net-tools
执行 ifconfig命令
提交
docker commit -m=“ifconfig cmd add” -a=“mxx” 261398eea6f7 myubuntu:1.2
启动测试一下
curl验证私服库上有什么镜像
curl -XGET http://172.17.0.2:5000/v2/_catalog
docker run -d -p 5000:5000 -v /cui/myregistry/:/temp/registry --privileged=true registry
空的
使用命令 docker tag 将myubuntu:1.2 这个镜像修
改为172.17.0.2:5000/myubuntu:1.2
docker tag myubuntu:1.2 172.17.0.2:5000/myubuntu:1.2
修改配置文件使之支持http
{
"registry-mirrors": [
"https://mirror.ccs.tencentyun.com",
"insecure- registries": ["172.17.0.2:5000"]
]
}
**docker默认不允许http方式推送镜像，通过配置选项来取消这个限制。**
push推送到私服库
docker push 172.17.0.2:5000/myubuntu:1.2
遇到问题
解决办法 mv /etc/docker/daemon.json daemon.conf
验证私服上有什么镜像
curl -XGET http://172.17.0.2:5000/v2/_catalog
pull到本地并运行
Docker容器数据卷
Docker 挂载主机目录访问如果出现cannot open directory .: Permission denied
解决办法：在挂载目录后多加一个–privileged=true参数即可
卷就是目录或文件，存在于一个或多个容器中，不属于联合文件系统。
卷的设计目的就是数据的数据的持久化。
特点：
1：数据卷可在容器之间共享或重用数据
2：卷中的更改可以直接实时生效，爽
3：数据卷中的更改不会包含在镜像的更新中
4：数据卷的生命周期一直持续到没有容器使用它为止
宿主vs容器之间映射添加容器卷
公式：docker run -it -v /宿主机目录:/容器内
目录 ubuntu /bin/bash
docker run -it --name test --privileged=true -v /tmp/myHostData:/tmp/myDockerData ubuntu /bin/bash
查看数据卷是否挂载成功
容器和宿主机之间数据共享
1 docker修改，主机同步获得
2 主机修改，docker同步获得
3 docker容器stop，主机修改，docker容器重启看数据是否同步。
读写规则映射添加说明
读写规则映射添加说明
读写(默认)
rw = read + write
·docker run -it --privileged=true -v /宿主机绝对路径目录:/容器内目录:rw 镜像名
默认同上案例，默认就是rw
只读
容器实例内部被限制，只能读取不能写
ro = read only
此时如果宿主机写入内容，可以同步给容器内，容器可以读取到。
安装tomcat
docker hub上面查找tomcat镜像
docker search tomcat
docker pull tomcat
docker images查看是否有拉取到的tomcat
使用tomcat镜像创建容器实例(也叫运行镜像)
docker run -it -p 8080:8080 tomcat
-p 小写，主机端口:docker容器端口
-P 大写，随机分配端口
i:交互
t:终端
d:后台
访问tomcat
解决
把webapps.dist目录换成webapps
查看webapps 文件夹查看为空
再次启动
成功
docker pull billygoo/tomcat8-jdk8
docker run -d -p 8080:8080 --name mytomcat8 billygoo/tomcat8-jdk8
安装mysql
docker search mysql
docker hub上面查找mysql镜像
sudo docker run -d -p 3306:3306 -v /usr/local/mysql/conf:/etc/mysql/conf.d -v /usr/local/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=1234 --name mysql mysql:5.7
docker run:在docker中启动一个容器实例
-d:该容器在后台运行
-p 3306:3306：容器与主机映射端口为，主机3306，容器3306
--name mysql：容器运行后的名称
-v /mysqldata/mysql/log:/var/log/mysql：将容器/var/log/mysql目录下的数据，备份到主机的 /mysqldata/mysql/log目录下
-v /mysqldata/mysql/data:/var/lib/mysql：将容器/var/lib/mysql目录下的数据，备份到主机的 /mysqldata/mysql/data目录下
-v /mysqldata/mysql/conf:/etc/mysql：将容器/etc/mysql目录下的数据，备份到主机的 mysqldata/mysql/conf目录下
-e MYSQL_ROOT_PASSWORD=root：设置当前mysql实例的密码为root
mysql:5.7:需要运行的容器名称以及版本号
在var/lib/docker/containers/下查看容器
cd /var/lib/docker/containers/
docker ps
docker exec -it 容器ID /bin/bash
mysql -uroot -p
docker里面的mysql容器实例查看，内容如下：
SHOW VARIABLES LIKE ‘character%’;
新建mysql容器实例
docker run -d -p 3306:3306 --privileged=true -v /zzyyuse/mysql/log:/var/log/mysql -v /zzyyuse/mysql/data:/var/lib/mysql -v /zzyyuse/mysql/conf:/etc/mysql/conf.d -e MYSQL_ROOT_PASSWORD=123456 --name mysql mysql:5.7
新建my.cnf
通过容器卷同步给mysql容器实例
[client]
default_character_set=utf8
[mysqld]
collation_server = utf8_general_ci
character_set_server = utf8
重新启动mysql容器实例再重新进入并查看字符编码
安装mysql主从复制
登陆mysql
mysql -uroot //默认没有密码
设置mysql登录密码
set password=password(‘你的密码’)
flush privileges;
加过密码下次登录需要
mysql -u root -p
主从复制原理，是通过binlog实现的
docker run -p 3307:3306 --name mysql-master \
-v /mydata/mysql-master/log:/var/log/mysql \
-v /mydata/mysql-master/data:/var/lib/mysql \
-v /mydata/mysql-master/conf:/etc/mysql \
-e MYSQL_ROOT_PASSWORD=1234\
-d mysql:5.7.37
进入/mydata/mysql-master/conf目录下新建my.cnf
vim my.cnf
[mysqld]
## 设置server_id，同一局域网中需要唯一
server_id=101
## 指定不需要同步的数据库名称
binlog-ignore-db=mysql
## 开启二进制日志功能
log-bin=mall-mysql-bin
## 设置二进制日志使用内存大小（事务）
binlog_cache_size=1M
## 设置使用的二进制日志格式（mixed,statement,row）
binlog_format=mixed
## 二进制日志过期清理时间。默认值为0，表示不自动清理。
expire_logs_days=7
## 跳过主从复制中遇到的所有错误或指定类型的错误，避免slave端复制中断。
## 如：1062错误是指一些主键重复，1032错误是因为主从数据库数据不一致
slave_skip_errors=1062
修改完配置后重启master实例
docker restart mysql-master
进入mysql-master容器
docker exec -it mysql-master /bin/bash
mysql -uroot -proot
master容器实例内创建数据同步用户
CREATE USER ‘slave’@‘%’ IDENTIFIED BY ‘1234’;
GRANT REPLICATION SLAVE, REPLICATION CLIENT ON . TO ‘slave’@‘%’;
新建从服务器容器实例3308
docker run -p 3308:3306 --name mysql-slave
-v /mydata/mysql-slave/log:/var/log/mysql
-v /mydata/mysql-slave/data:/var/lib/mysql
-v /mydata/mysql-slave/conf:/etc/mysql
-e MYSQL_ROOT_PASSWORD=1234
-d mysql:5.7.37
进入/mydata/mysql-slave/conf目录下新建my.cnf
vim my.cnf
[mysqld]
## 设置server_id，同一局域网中需要唯一
server_id=102
## 指定不需要同步的数据库名称
binlog-ignore-db=mysql
## 开启二进制日志功能，以备Slave作为其它数据库实例的Master时使用
log-bin=mall-mysql-slave1-bin
## 设置二进制日志使用内存大小（事务）
binlog_cache_size=1M
## 设置使用的二进制日志格式（mixed,statement,row）
binlog_format=mixed
## 二进制日志过期清理时间。默认值为0，表示不自动清理。
expire_logs_days=7
## 跳过主从复制中遇到的所有错误或指定类型的错误，避免slave端复制中断。
## 如：1062错误是指一些主键重复，1032错误是因为主从数据库数据不一致
slave_skip_errors=1062
## relay_log配置中继日志
relay_log=mall-mysql-relay-bin
## log_slave_updates表示slave将复制事件写进自己的二进制日志
log_slave_updates=1
## slave设置为只读（具有super权限的用户除外）
read_only=1
修改完配置后重启slave实例
docker restart mysql-slave
在主数据库中查看主从同步状态
show master status;
进入mysql-slave容器
docker exec -it mysql-slave /bin/bash
mysql -uroot -proot
在从数据库中配置主从复制
change master to master_host=‘宿主机ip’, master_user=‘slave’, master_password=‘123456’, master_port=3307, master_log_file=‘mall-mysql-bin.000001’, master_log_pos=617, master_connect_retry=30;
主从复制命令参数说明
master_host：主数据库的IP地址；
master_port：主数据库的运行端口；
master_user：在主数据库创建的用于同步数据的用户账号；
master_password：在主数据库创建的用于同步数据的用户密码；
master_log_file：指定从数据库要复制数据的日志文件，通过查看主数据的状态，获取File参数；
master_log_pos：指定从数据库从哪个位置开始复制数据，通过查看主数据的状态，获取Position参数；
master_connect_retry：连接失败重试的时间间隔，单位为秒。
在从数据库中查看主从同步状态
show slave status \G;
在从数据库中开启主从同步
查看从数据库状态发现已经同步
主从复制测试
主机新建库-使用库-新建表-插入数据，ok
从机使用库-查看记录，ok
安装redis
从docker hub上(阿里云加速器)拉取redis镜像到本地标签为6.0.8
docker pull redis
运行一下
docker run -d -p 6379:6379 redis:6.0.8
进入redis容器
docker exec -it 0b72e9917699 /bin/bash
命令提醒：容器卷记得加入–privileged=true
Docker挂载主机目录Docker访问出现cannot open directory .: Permission denied
解决办法：在挂载目录后多加一个–privileged=true参数即可
在CentOS宿主机下新建目录/app/redis
sudo mkdir -p /app/redis/
找一个redis.conf 文件 复制过来
将准备好的redis.conf文件放进/app/redis目录下
cp /home/ubuntu/redis.conf ./
赋权 chmod 777 redis.conf
/app/redis目录下修改redis.conf文件
开启redis验证
允许redis外地连接 必须
注释掉 # bind 127.0.0.1
将daemonize yes注释起来或者 daemonize no设置，因为该配置和docker run中-d参数冲突，会导致容器一直启动失败
开启redis数据持久化 appendonly yes 可选
docker run -p 6379:6379 --name myr3 --privileged=true -v /app/redis/redis.conf:/etc/redis/redis.conf -v /app/redis/data:/data -d redis:6.0.8 redis-server /etc/redis/redis.conf
Dockerfile介绍
dockerfile，相当于是一个文档，客户可以基于dockerfile生成新的容器。
dockerfile仅仅是用来制作镜像的源码文件，是构建容器过程中的指令，docker能够读取dockerfile的指定进行自动构建容器，基于dockerfile制作镜像，每一个指令都会创建一个镜像层，即镜像都是多层叠加而成，因此，层越多，效率越低，创建镜像，层越少越好。因此能在一个指令完成的动作尽量通过一个指令定义。
docker镜像制作的工作逻辑
首先需要有一个制作镜像的目录，该目录下有个文件，名称必须为Dockerfile，Dockerfile有指定的格式，#号开头为注释，指令默认用大写字母来表示，以区分指令和参数，docker build读取Dockerfile是按顺序依次Dockerfile里的配置，且第一条非注释指令必须是FROM 开头，表示基于哪个基础镜像来构建新镜像。可以根据已存在的任意镜像来制作新镜像。
镜像的生成途径
- 基于容器制作
- Dockerfile
什么是Dockerfile?
Dockerfile是一个包含用于组合镜像的命令的文本文档。可以使用在命令行中调用任何命令。 Docker通过读取Dockerfile中的指令自动生成镜像。
docker build命令用于从Dockerfile构建镜像。可以在docker build命令中使用-f 标志指向文件系统中任何位置的Dockerfile。
举例
docker build -f /path/to/a/Dockerfile .
Dockerfile的基本结构
Dockerfile 一般分为四部分：基础镜像信息、维护者信息、镜像操作指令和容器启动时执行指令，’#’ 为 Dockerfile 中的注释。
Dockerfile文件说明
Docker以从上到下的顺序运行Dockerfile的指令。为了指定基本映像，第一条指令必须是FROM。一个声明以＃字符开头则被视为注释。可以在Docker文件中使用RUN，CMD，FROM，EXPOSE，ENV等指令。
FROM
- 指定基础镜像，必须为第一个命令
格式：
FROM <image>
FROM <image>:<tag>
FROM <image>@<digest>
示例：
FROM mysql:5.6
注：
tag或digest是可选的，如果不使用这两个值时，会使用latest版本的基础镜像
MAINTAINER
- 维护者信息
格式：
MAINTAINER <name>
示例：
MAINTAINER Jasper Xu
MAINTAINER sorex@163.com
MAINTAINER Jasper Xu <sorex@163.com>
RUN
- 构建镜像时执行的命令
RUN用于在镜像容器中执行命令，其有以下两种命令执行方式：
shell执行
格式：
RUN <command>
exec执行
格式：
RUN ["executable", "param1", "param2"]
示例：
RUN ["executable", "param1", "param2"]
RUN apk update
RUN ["/etc/execfile", "arg1", "arg1"]
注：
RUN指令创建的中间镜像会被缓存，并会在下次构建中使用。
如果不想使用这些缓存镜像，可以在构建时指定--no-cache参数，如：docker build --no-cache
ADD
- 将本地文件添加到容器中，tar类型文件会自动解压(网络压缩资源不会被解压)，可以访问网络资源，类似wget。
格式：
ADD <src>... <dest>
ADD ["<src>",... "<dest>"] 用于支持包含空格的路径
示例：
ADD hom* /mydir/ # 添加所有以"hom"开头的文件
ADD hom?.txt /mydir/ # ? 替代一个单字符,例如："home.txt"
ADD test relativeDir/ # 添加 "test" 到 `WORKDIR`/relativeDir/
ADD test /absoluteDir/ # 添加 "test" 到 /absoluteDir/
COPY
- 功能类似ADD，但是是不会自动解压文件，也不能访问网络资源
CMD
- 构建容器后调用，也就是在容器启动时才进行调用。但是一个Dockerfile中只能有一条CMD命令，多条则只执行最后一条CMD。
- CMD主要用于container时启动指定的服务，当docker run command的命令匹配到CMD
command时，会替换CMD执行的命令。
格式：
CMD ["executable","param1","param2"] (执行可执行文件，优先)
CMD ["param1","param2"] (设置了ENTRYPOINT，则直接调用ENTRYPOINT添加参数)
CMD command param1 param2 (执行shell内部命令)
示例：
CMD echo "This is a test." | wc -
CMD ["/usr/bin/wc","--help"]
注：
CMD不同于RUN，CMD用于指定在容器启动时所要执行的命令，而RUN用于指定镜像构建时所要执行的命令。
ENTRYPOINT
- 配置容器，使其可执行化。配合CMD可省去"application"，只使用参数。
格式：
ENTRYPOINT ["executable", "param1", "param2"] (可执行文件, 优先)
ENTRYPOINT command param1 param2 (shell内部命令)
示例：
FROM ubuntu
ENTRYPOINT ["top", "-b"]
CMD ["-c"]
注：
ENTRYPOINT与CMD非常类似，不同的是通过docker run执行的命令不会覆盖ENTRYPOINT，
而docker run命令中指定的任何参数，都会被当做参数再次传递给ENTRYPOINT。
Dockerfile中只允许有一个ENTRYPOINT命令，多指定时会覆盖前面的设置，而只执行最后的ENTRYPOINT指令。
LABEL
- 用于为镜像添加元数据
格式：
LABEL <key>=<value> <key>=<value> <key>=<value> ...
示例：
LABEL version="1.0" description="这是一个Web服务器" by="IT笔录"
注：
使用LABEL指定元数据时，一条LABEL指定可以指定一或多条元数据，指定多条元数据时不同元数据之间通过空格分隔。
推荐将所有的元数据通过一条LABEL指令指定，以免生成过多的中间镜像。
ENV
- 设置环境变量
格式：
ENV <key> <value> #<key>之后的所有内容均会被视为其<value>的组成部分，因此，一次只能设置一个变量
ENV <key>=<value> ... #可以设置多个变量，每个变量为一个"<key>=<value>"的键值对，如果<key>中包含空格，可以使用\来进行转义，也可以通过""来进行标示；另外，反斜线也可以用于续行
示例：
ENV myName John Doe
ENV myDog Rex The Dog
ENV myCat=fluffy
EXPOSE
- 指定于外界交互的端口
格式：
EXPOSE <port> [<port>...]
示例：
EXPOSE 80 443
EXPOSE 8080
EXPOSE 11211/tcp 11211/udp
注：
EXPOSE并不会让容器的端口访问到主机。
要使其可访问，需要在docker run运行容器时通过-p来发布这些端口，或通过-P参数来发布EXPOSE导出的所有端口
VOLUME
- 用于指定持久化目录
格式：
VOLUME ["/path/to/dir"]
示例：
VOLUME ["/data"]
VOLUME ["/var/www", "/var/log/apache2", "/etc/apache2"
注：
一个卷可以存在于一个或多个容器的指定目录，该目录可以绕过联合文件系统，并具有以下功能：
1、卷可以容器间共享和重用
2、容器并不一定要和其它容器共享卷
3、修改卷后会立即生效
4、对卷的修改不会对镜像产生影响
5、卷会一直存在，直到没有任何容器在使用它
WORKDIR
- 工作目录，类似于cd命令
格式：
WORKDIR /path/to/workdir
示例：
WORKDIR /a (这时工作目录为/a)
WORKDIR b (这时工作目录为/a/b)
WORKDIR c (这时工作目录为/a/b/c)
注：
通过WORKDIR设置工作目录后，Dockerfile中其后的命令RUN、CMD、ENTRYPOINT、ADD、COPY等命令都会在该目录下执行。
在使用docker run运行容器时，可以通过-w参数覆盖构建时所设置的工作目录。
USER
- 指定运行容器时的用户名或 UID，后续的 RUN
也会使用指定用户。使用USER指定用户时，可以使用用户名、UID或GID，或是两者的组合。当服务不需要管理员权限时，可以通过该命令指定运行用户。并且可以在之前创建所需要的用户
格式:
USER user
USER user:group
USER uid
USER uid:gid
USER user:gid
USER uid:group
示例：
USER www
注：
使用USER指定用户后，Dockerfile中其后的命令RUN、CMD、ENTRYPOINT都将使用该用户。
镜像构建完成后，通过docker run运行容器时，可以通过-u参数来覆盖所指定的用户。
ARG
- 用于指定传递给构建运行时的变量
格式：
ARG <name>[=<default value>]
示例：
ARG site
ARG build_user=www
ONBUILD
- 用于设置镜像触发器
格式：
ONBUILD [INSTRUCTION]
示例：
ONBUILD ADD . /app/src
ONBUILD RUN /usr/local/bin/python-build --dir /app/src
注：
当所构建的镜像被用做其它镜像的基础镜像，该镜像中的触发器将会被钥触发
搭建springboot项目与dockerfile结合使用
新建dockerboot项目
maven
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.6.11</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.aliyun</groupId>
<artifactId>dockerboot</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>dockerboot</name>
<description>dockerboot</description>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<java.version>1.8</java.version>
<maven.compiler.target>1.8</maven.compiler.target>
<junit.version>4.12</junit.version>
<log4j.version>1.2.17</log4j.version>
<lombok.version>1.16.18</lombok.version>
<mysql.version>5.1.47</mysql.version>
<druid.version>1.1.16</druid.version>
<mapper.version>4.1.5</mapper.version>
<mybatis.spring.boot.version>1.3.0</mybatis.spring.boot.version>
</properties>
<dependencies>
<!--SpringBoot通用依赖模块-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<!--test-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-resources-plugin</artifactId>
<version>3.1.0</version>
</plugin>
</plugins>
</build>
</project>
主启动
package com.aliyun.dockerboot;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class DockerbootApplication {
public static void main(String[] args) {
SpringApplication.run(DockerbootApplication.class, args);
}
}
业务类 OrderController
package com.aliyun.dockerboot.controller;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import java.util.UUID;
/**
* @Author:meng_xiangxin
* @Date: 2023/2/15 9:11
* @Description: 控制类
*/
@RestController
public class OrderController {
@Value("{server.port}")
private String port;
@RequestMapping("/order/docker")
public String helloDocker() {
return "hello docker" + "\t" + UUID.randomUUID().toString();
}
@RequestMapping(value = "/order/index", method = RequestMethod.GET)
public String index() {
return "服务端口号:" + "\t" + port + UUID.randomUUID().toString();
}
}
进行打包
我是在/usr/local/docker/myfile进行创建测试
新建文本 vim Dockerfile
# 基础镜像使用java
FROM java:8
# 作者
MAINTAINER mxx
# VOLUME 指定临时文件目录为/tmp，在主机/var/lib/docker目录下创建了一个临时文件并链接到容器的/tmp
VOLUME /tmp
# 将jar包添加到容器中并更名为zzyy_docker.jar
ADD dockerboot-0.0.1-SNAPSHOT.jar zzyy_docker.jar
# 运行jar包
RUN bash -c 'touch /zzyy_docker.jar'
ENTRYPOINT ["java","-jar","/zzyy_docker.jar"]
#暴露6001端口作为微服务
EXPOSE 6001
构建镜像
docker build -t zzyy_docker:1.6 .
运行容器
docker run -d -p 6001:6001 zzyy_docker:1.6
UnionFS（联合文件系统）
Union文件系统（UnionFS）是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into a single virtual filesystem)。Union 文件系统是 Docker 镜像的基础。镜像可以通过分层来进行继承，基于基础镜像（没有父镜像），可以制作各种具体的应用镜像。
特性：一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统，联合加载会把各层文件系统叠加起来，这样最终的文件系统会包含所有底层的文件和目录
2845
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
