jieye の 数字花园

Search

Search IconIcon to open search

Docker基础

Last updated Dec 4, 2021

# 1 Docker简介

# 1.1 为什么会有docker?

一款产品从开发到上线,从操作系统,到运行环境,再到应用配置。作为开发+运维之间的协作我们需要关心很多东西,这也是很多互联网公司都不得不面对的问题,特别是各种版本的迭代之后,不同版本环境的兼容,对运维人员都是考验
Docker之所以发展如此迅速,也是因为它对此给出了一个标准化的解决方案。
环境配置如此麻烦,换一台机器,就要重来一次,费力费时。很多人想到,能不能从根本上解决问题,软件可以带环境安装?也就是说,安装的时候,把原始环境一模一样地复制过来。开发人员利用Docker可以消除协作编码时“在我的机器上可正常工作”的问题。
image-20211129163643863
之前在服务器配置一个应用的运行环境,要安装各种软件,就拿尚硅谷电商项目的环境来说,Java/TomcatMySQL/JDBC驱动包等。安装和配置这些东西有多麻烦就不说了,它还不能跨平台。假如我们是在Windows上安装的这些环境,到了Linux 又得重新装。况且就算不跨操作系统,换另一台同样操作系统的服务器,要移植应用也是非常麻烦的。

传统上认为,软件编码开发/测试结束后,所产出的成果即是程序或是能够编译执行的二进制字节码等java为例)。而为了让这程序可以顺利执行,开发团队也得准备完整的部署文件,让维运团队得以部署应用程式,开发需要清楚的告诉运维部署团队,用的全部配置文件+所有软件环境。不过,即便如此,仍然常常发生部署失败的状况。Docker镜 像的设计,使得Docker得以打过去「程序即应用」的观念。透过镜像(images)将作业系统核心除外,运作应用程式所需要的系统环境,由下而上打包,达到应用程式跨平台间的无缝接轨运.作。

# 1.2 docker理念

Docker是基于Go语言实现的云开源项目。
Docker的主要目标是“Build, Ship[ and Run Any App,Anywhere",也就是通过对应用组件的封装、分发、部署、运行等生命期的管理,使用户的APP (可以是一个WEB应用或数据库应用等等)及其运行环境能够做到“一次封装,到处运行”。

image-20211129163840868

Linux容器技术的出现就解决了这样一 一个问题,而Docker就是在它的基础上发展过来的。将应用运行在Docker容器上面,而Docker容器在任何操作系统上都是一-致的,这就实现了跨平台、跨服务器。只需要一次配置好环境,换到别的机子上就可以一键部署好,大大简化了操作

总结:Docker解决了运行环境和配置问题的软件容器,方便做持续集成并有助于整体发布的容器虚拟化技术

# 1.3 Docker可以做什么

# 1.3.1 虚拟机技术

虚拟机**(virtual machine)**就是带环境安装的一种解决方案。

它可以在一种操作系统里面运行另一种作系统,比如在Windows系统里面运行Linux系统。应用程序对此毫无感知,因为虚拟机看上去跟真实系统一模一样,而对于底层系统来说,虚拟机就是一个普通文件,不需要了就删掉,对其他部分毫无影响。这类虚拟机完美的运行了另一套系统,能够使应用程序,操作系统和硬件三者之间的逻辑不变。

image-20211129163953230

但是有一定的缺点:

# 1.3.2 容器虚拟化技术

由于前面虛拟机存在这些缺点,Linux 发展出了另一种虚拟化技术: Linux 容器(Linux Containers,缩为LXC)。

Linux容器不是模拟一个完整的操作系统,而是对进程进行隔离。有了容器,就可以将软件运行所的所有资源打包到一个隔离的容器中。容器与虚拟机不同,不需要捆绑一整套操作系统,只需要软件工作所需的库资源和设置。系统因此而变得高效轻量并保证部署在任何环境中的软件都能始终如一地运行。

image-20211129164118311

Docker和传统虚拟化方式的不同之处:

  1. 传统虚拟机技术是虚拟出一套硬件后,在其上运行一个完整操作系统,在该系统上再运行所需应用进程;
  2. 而容器内的应用进程直接运行于宿主的内核,容器内没有自己的内核,而且也没有进行硬件虚拟。因此容器要比传统虚拟机为轻便。
  3. 每个容器之间互相隔离,每个容器有自己的文件系统,容器之间进程不会相互影响,能区分计算资源。

# 1.3.3 开发/运维(DevOps)

一次构建、随处运行。

更快速的应用交付和部署

传统的应用开发完成后,需要提供一堆安装程序和配置说明文档,安装部署后需根据配置文档进行繁杂的配置才能正常运行。Docker化
之后只需要交付少量容器镜像文件,在正式生产环境加载镜像并运行即可,应用安装配置在镜像里已经内置好,大大节省部署配置和测
试验证时间。

更便捷的升级和扩缩容

随着微服务架构和Docker的发展,大量的应用会通过微服务方式架构,应用的开发构建将变成搭乐高积木一样,每个Docker容器将变成-块“积木”,应用的升级将变得非常容易。当现有的容器不足以支撑业务处理时,可通过镜像运行新的容器进行快速扩容,使应用系统的扩容从原先的天级变成分钟级甚至秒级。

更简单的系统运维

应用容器化运行后,生产环境运行的应用可与开发、测试环境的应用高度–致,容器会将应用程序相关的环境和状态完全封装起来,不会因为底层基础架构和操作系统的不一致性给应用带来影响,产生新的BUG。当出现程序异常时,也可以通过测试环境的相同容器进行快速定位和修复。

更高效的计算资源利用

Docker是内核级虚拟化,其不像传统的虚拟化技术一样 需要额外的Hypervisor支持,所以在一台物理机上可以运行很多个容器实例,可大大提升物理服务器的CPU和内存的利用率。

# 1.4 Docker基本结构

img

# 1.4.1 镜像(image)

镜像(lmage)就是一个只读的模板。镜像可以用来创建Docker容器,一个镜像可以创建很多容器。

image-20211129165021803

# 1.4.2 容器( container)

Docker利用容器(Container) 独立运行的一个或一组应用。容器是用镜像创建的运行实例。
它可以被启动、开始、停止、删除。每个容器都是相互隔离的、保证安全的平台。
可以把容器看做是一个简易版的Linux环境(包括root用户权限、进程空间、用户空间和网络空间等)和运行在其中的应用程序。
容器的定义和镜像几乎一模一样,也是一堆层的统一视角, 唯一区别在于容器的最上面那一层是可读可写的。

# 1.4.3 仓库( repository)

仓库(Repository) 是集中存放镜像文件的场所。
仓库(Repository)和仓库注册服务器(Registry) 是有区别的。仓库注册服务器上往往存放着多个仓库,每个仓库中又包含了多镜像,
每个镜像有不同的标签(tag) 。

仓库分为公开仓库(Public) 和私有仓库(Private) 两种形式。
最大的公开仓库是Docker Hub( https://hub.docker.com/)
存放了数量庞大的镜像供用户下载。国内的公开仓库包括阿里云、网易云等。

# 1.4.4 总结

需要正确的理解仓储/镜像/容器这几个概念:
Docker本身是一个容器运行载体或称之为管理引擎。我们把应用程序和配置依赖打包好形成一-个可交付的运行环境,这个打好的运行环境就似乎image镜像文件。只有通过这个镜像文件才能生成Docker容器。image文件可以看作是容器的模板。Docker根据image文件生成容器的实例。同一个image文件,可以生成多个同时运行的容器实例。
image文件生成的容器实例,本身也是一一个文件,称为镜像文件。
一个容器运行一种服务,当我们需要的时候,就可以通过docker客户端创建一-个对应的运行实例,也就是我们的容器至于仓储,就是放了一堆镜像的地方,我们可以把镜像发布到仓储中,需要的时候从仓储中拉下来就可以了。

# 1.5 底层原理

Docker是一个Client-Server结构的系统,Docker守 护进程运行在主机上,然后通过Socket连 接从客户端访问,守护进程从客户端接受命令并管理运行在主机上的容器。容器,是一个运行时环境,就是我们前面说到的集装箱。
image-20211129171424470

为什么Docker比较比vm快

  1. docker有着比虚拟机更少的抽象层。由亍docker不需要Hypervisor实现硬件资源虚拟化,运行在docker容器上的程序直接使用的都是实际物理机的硬件资源。因此在CPU、内存利用率上docker将会在效率上有明显优势。
  2. docker利用的是宿主机的内核,而不需要Guest OS。因此,当新建一个 容器时,docker不需要和虚拟机一样 重新加载- - 个操作系统内核仍而避免引寻、加载操作系统内核返个比较费时费资源的过程,当新建–个虚拟机时,虚拟机软件需要加载GuestOS,返个新建过程是分钟级别的。而docker由于直接利用宿主机的操作系统,则省略了返个过程,因此新建一-个docker容器只需要几秒钟。

image-20211129171508504

# 2 安装与Helloworld

CentOS Docker安装
Docker支持以下的CentOS版本:
CentOS 7 (64-bit)
CentOS 6.5 (64-bit)或更高的版本

前提条件
目前,CentOS 仅发行版本中的内核支持Docker。
Docker运行在CentOS 7.上,要求系统为64位、系统内核版本为3.10以上。
Docker运行在CentOS-6.5或更高的版本的CentOS上,要求系统为64位、系统内核版本为2.6.32-431或者更高版本。

image-20211129164440659

具体安装操作日新月异,参考官网文档、网上博客即可。https://docs.docker.com/engine/install/

# 2.1 镜像加速

# 阿里云镜像加速

是什么?https://promotion.aliyun.com/ntms/act/kubernetes.html

  1. 注册一个属于自己的阿里云账户( 可复用淘宝账号)

  2. 获得加速器地址连接

    登录阿里云开发者平台获取加速器地址

  3. 配置本机Docker运行镜像加速器

    鉴于国内网络问题,后续拉取Docker镜像十分缓慢,我们可以需要配置加速器来解决,
    我使用的是阿里云的本人自己账号的镜像地址(需要自己注册有一个属于你自己的): ht:po/. mirror aliyuncns .com

重新启动 Docker 后台服务:service docker restart

Linux系统下配置完加速器需要检查是否生效

此外还有网易云加速等。。

# 2.2 helloworld

启动Docker后台容器(测试运行 hello-world )

docker run hello-world

# 3 Docker常用命令

# 3.1 帮助类命令

# 3.2 镜像命令

# 1.列出所有images

docker images

1
2
3
4
-a 列出本地所有的镜像(含中间映射层)
-q 只显示镜像ID
--digests 显示镜像的摘要信息
--no-trunc 显示完整的镜像信息
image-20211129192629426

# 2.搜索image

docker search [OPTIONS] 镜像名字

1
2
3
4
-f, --filter filter   Filter output based on conditions provided
    --format string   Pretty-print search using a Go template
    --limit int       列出收藏数不小于指定值的镜像 (default 25)
    --no-trunc        Don't truncate output

# 3.下载image

docker pull [OPTIONS] NAME[:TAG|@DIGEST]

1
2
3
4
-a, --all-tags                Download all tagged images in the repository
    --disable-content-trust   Skip image verification (default true)
    --platform string         Set platform if server is multi-platform capable
-q, --quiet                   Suppress verbose output

默认为 NAME:latest

# 4.删除image

docker rmi [OPTIONS] IMAGE [IMAGE…]

1
2
-f, --force      Force removal of the image
    --no-prune   Do not delete untagged parents

删除单个 docker rm -f 镜像ID

删除多个 docker rm -f 镜像名1:TAG 镜像名2:TAG

删除多个 docker rmi -f ${docker images -qa}

# 5.提交image

docker commit [OPTIONS] CONTAINER [REPOSITORY[:TAG]]

e.g.docker commit -m="提交的描述信息" -a="作者" 容器ID 要创建的目标镜像名:[标签名]

1
2
3
4
-a, --author string    Author (e.g., "John Hannibal Smith <hannibal@a-team.com>")
-c, --change list      Apply Dockerfile instruction to the created image
-m, --message string   Commit message
-p, --pause            Pause container during commit (default true)
  1. 故意删除上一步镜像生产tomcat容器的文档

    image-20211130140543011

  2. 也即当前的tomcat运行实例是一个没有文档内容的容器,以他为模板commit一个没有doc的tomcat新镜像 atguigu/tomcat02

    image-20211130140601407

# 3.3 容器命令

有镜像才能创建容器,这是根本前提(下载一个Centos镜像演示)

docker pull centos

# 1.新建并启动容器

docker run [OPTIONS] IMAGE [COMMAND] [ARG…]

e.g.docker run -it -p 8888:8080 tomcat

8888为外主机端口

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
# !
-d, --detach                         Run container in background and print container ID
		--name string                    Assign a name to the container
-i, --interactive                    Keep STDIN open even if not attached
-t, --tty                            Allocate a pseudo-TTY
-p, --publish list                   Publish a container's port(s) to the host
	#指定端口映射,有以下四种格式
	#ip:hostPort:containerPort
	#ip::containerPort
	#hostPort:containerPort
	#containerPort
-P, --publish-all                    Publish all exposed ports to random ports 随机端口映射
#
      
    --add-host list                  Add a custom host-to-IP mapping (host:ip)
-a, --attach list                    Attach to STDIN, STDOUT or STDERR
    --blkio-weight uint16            Block IO (relative weight), between 10 and 1000, or 0 to
                                     disable (default 0)
    --blkio-weight-device list       Block IO weight (relative device weight) (default [])
    --cap-add list                   Add Linux capabilities
    --cap-drop list                  Drop Linux capabilities
    --cgroup-parent string           Optional parent cgroup for the container
    --cgroupns string                Cgroup namespace to use (host|private)
                                     'host':    Run the container in the Docker host's cgroup
                                     namespace
                                     'private': Run the container in its own private cgroup
                                     namespace
                                     '':        Use the cgroup namespace as configured by the
                                                default-cgroupns-mode option on the daemon (default)
    --cidfile string                 Write the container ID to the file
    --cpu-period int                 Limit CPU CFS (Completely Fair Scheduler) period
    --cpu-quota int                  Limit CPU CFS (Completely Fair Scheduler) quota
    --cpu-rt-period int              Limit CPU real-time period in microseconds
    --cpu-rt-runtime int             Limit CPU real-time runtime in microseconds
-c, --cpu-shares int                 CPU shares (relative weight)
    --cpus decimal                   Number of CPUs
    --cpuset-cpus string             CPUs in which to allow execution (0-3, 0,1)
    --cpuset-mems string             MEMs in which to allow execution (0-3, 0,1)
    --detach-keys string             Override the key sequence for detaching a container
    --device list                    Add a host device to the container
    --device-cgroup-rule list        Add a rule to the cgroup allowed devices list
    --device-read-bps list           Limit read rate (bytes per second) from a device (default [])
    --device-read-iops list          Limit read rate (IO per second) from a device (default [])
    --device-write-bps list          Limit write rate (bytes per second) to a device (default [])
    --device-write-iops list         Limit write rate (IO per second) to a device (default [])
    --disable-content-trust          Skip image verification (default true)
    --dns list                       Set custom DNS servers
    --dns-option list                Set DNS options
    --dns-search list                Set custom DNS search domains
    --domainname string              Container NIS domain name
    --entrypoint string              Overwrite the default ENTRYPOINT of the image
-e, --env list                       Set environment variables
    --env-file list                  Read in a file of environment variables
    --expose list                    Expose a port or a range of ports
    --gpus gpu-request               GPU devices to add to the container ('all' to pass all GPUs)
    --group-add list                 Add additional groups to join
    --health-cmd string              Command to run to check health
    --health-interval duration       Time between running the check (ms|s|m|h) (default 0s)
    --health-retries int             Consecutive failures needed to report unhealthy
    --health-start-period duration   Start period for the container to initialize before starting
                                     health-retries countdown (ms|s|m|h) (default 0s)
    --health-timeout duration        Maximum time to allow one check to run (ms|s|m|h) (default 0s)
    --help                           Print usage
-h, --hostname string                Container host name
    --init                           Run an init inside the container that forwards signals and reaps processes
    --ip string                      IPv4 address (e.g., 172.30.100.104)
    --ip6 string                     IPv6 address (e.g., 2001:db8::33)
    --ipc string                     IPC mode to use
    --isolation string               Container isolation technology
    --kernel-memory bytes            Kernel memory limit
-l, --label list                     Set meta data on a container
    --label-file list                Read in a line delimited file of labels
    --link list                      Add link to another container
    --link-local-ip list             Container IPv4/IPv6 link-local addresses
    --log-driver string              Logging driver for the container
    --log-opt list                   Log driver options
    --mac-address string             Container MAC address (e.g., 92:d0:c6:0a:29:33)
-m, --memory bytes                   Memory limit
    --memory-reservation bytes       Memory soft limit
    --memory-swap bytes              Swap limit equal to memory plus swap: '-1' to enable
                                     unlimited swap
    --memory-swappiness int          Tune container memory swappiness (0 to 100) (default -1)
    --mount mount                    Attach a filesystem mount to the container
    --network network                Connect a container to a network
    --network-alias list             Add network-scoped alias for the container
    --no-healthcheck                 Disable any container-specified HEALTHCHECK
    --oom-kill-disable               Disable OOM Killer
    --oom-score-adj int              Tune host's OOM preferences (-1000 to 1000)
    --pid string                     PID namespace to use
    --pids-limit int                 Tune container pids limit (set -1 for unlimited)
    --platform string                Set platform if server is multi-platform capable
    --privileged                     Give extended privileges to this container
    --pull string                    Pull image before running ("always"|"missing"|"never")
                                     (default "missing")
    --read-only                      Mount the container's root filesystem as read only
    --restart string                 Restart policy to apply when a container exits (default "no")
    --rm                             Automatically remove the container when it exits
    --runtime string                 Runtime to use for this container
    --security-opt list              Security Options
    --shm-size bytes                 Size of /dev/shm
    --sig-proxy                      Proxy received signals to the process (default true)
    --stop-signal string             Signal to stop a container (default "SIGTERM")
    --stop-timeout int               Timeout (in seconds) to stop a container
    --storage-opt list               Storage driver options for the container
    --sysctl map                     Sysctl options (default map[])
    --tmpfs list                     Mount a tmpfs directory
    --ulimit ulimit                  Ulimit options (default [])
-u, --user string                    Username or UID (format: <name|uid>[:<group|gid>])
    --userns string                  User namespace to use
    --uts string                     UTS namespace to use
-v, --volume list                    Bind mount a volume
    --volume-driver string           Optional volume driver for the container
    --volumes-from list              Mount volumes from the specified container(s)
-w, --workdir string                 Working directory inside the container

# 2.列出当前的容器

docker ps [OPTIONS]

1
2
3
4
5
6
7
8
-a, --all             列出当前所有正在运行的容器+历史上运行过的
-f, --filter filter   Filter output based on conditions provided
    --format string   Pretty-print containers using a Go template
-n, --last int        显示最近n个创建的容器 (includes all states) (default -1)
-l, --latest          显示最近创建的容器 (includes all states)
    --no-trunc        不截断输出
-q, --quiet           静默模式,只显示容器编号IDs
-s, --size            Display total file sizes

使用镜像centos:latest以后台模式启动一个容器
docker run -d centos

问题:然后docker ps -a进行查看,会发现容器已经退出
很重要的要说明的一点: Docker容器后台运行,就必须有一个前台进程.
容器运行的命令如果不是那些一直挂起的命令 (比如运行top,tail) ,就是会自动退出的。
这个是docker的机制问题,比如你的web容器,我们以nginx为例,正常情况下,我们配置启动服务只需要启动响应的service即可。例如
service nginx start
但是,这样做,nginx为后台进程模式运行,就导致docker前台没有运行的应用,这样的容器后台启动后,会立即自杀因为他觉得他没事可做了.所以,最佳的解决方案是将你要运行的程序以前台进程的形式运行

# 3.退出容器

exit 容器停止退出

ctrl+P+Q 容器不停止退出

# 4.启动容器

docker start 容器ID或容器签名

# 5.重启容器

docker restart 容器ID或容器签名

# 6.停止与强制停止容器

docker stop 容器ID或容器签名

docker kill 容器ID或容器签名

# 7.删除已停止的容器

docker rm 容器ID -f

一次性删除多个容器

docker rm -f $(docker ps -a -q)

docker ps -a -q | xargs docker rm

# 8.查看容器日志

docker logs -f -t --tail 容器ID

1
2
3
4
5
6
7
8
    --details        Show extra details provided to logs
-f, --follow         Follow log output 跟随最新的日志打印
    --since string   Show logs since timestamp (e.g. 2013-01-02T13:23:37Z) or relative (e.g.
                     42m for 42 minutes)
-n, --tail string    数字显示最后多少条 (default "all")
-t, --timestamps     是加入时间戳
    --until string   Show logs before a timestamp (e.g. 2013-01-02T13:23:37Z) or relative
                       (e.g. 42m for 42 minutes)

# 9.查看容器内进程

docker top CONTAINER [ps OPTIONS]

# 10.查看容器内部细节

docker inspect 容器ID

1
2
3
-f, --format string   Format the output using the given Go template
-s, --size            Display total file sizes if the type is container
    --type string     Return JSON for specified type

# 11.进入正在运行的容器并以命令行交互

docker exec [OPTIONS] CONTAINER COMMAND [ARG…]

e.g.docker exec -it 容器ID bashShell

1
2
3
4
5
6
7
8
9
-d, --detach               Detached mode: run command in the background
    --detach-keys string   Override the key sequence for detaching a container
-e, --env list             Set environment variables
    --env-file list        Read in a file of environment variables
-i, --interactive          Keep STDIN open even if not attached
    --privileged           Give extended privileges to the command
-t, --tty                  Allocate a pseudo-TTY
-u, --user string          Username or UID (format: <name|uid>[:<group|gid>])
-w, --workdir string       Working directory inside the container

docker attach [OPTIONS] CONTAINER

1
2
3
--detach-keys string   Override the key sequence for detaching a container
--no-stdin             Do not attach STDIN
--sig-proxy            Proxy all received signals to the process (default true)

attach 直接进入容器启动命令的终端,不会启动新的进程

exec 是在容器中打开新的终端,并且可以启动新的进程

# 12.从容器内拷贝文件

docker cp [OPTIONS] CONTAINER:SRC_PATH DEST_PATH|-

docker cp [OPTIONS] SRC_PATH|- CONTAINER:DEST_PATH

e.g.docker cp 容器ID:容器内路径 目的主机路径

Use ‘-’ as the source to read a tar archive from stdin and extract it to a directory destination in a container.

Use ‘-’ as the destination to stream a tar archive of a container source to stdout.

1
2
-a, --archive       Archive mode (copy all uid/gid information)
-L, --follow-link   Always follow symbol link in SRC_PATH

image-20211130134642659

# 小总结

image-20211130134709798

image-20211130134714298

# 4 Docker镜像

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

# 4.1 UnionFS(联合文件系统)

UnionFS (联合文件系统) : Union文件系统(UnionFS)是一一种分层、轻量级并且高性能的文件系统,它支持对文件系统的修作为一 次提交来一层层的叠加,同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into a singlevirtualfilesystem)。Union文件系统是Docker镜像的基础。镜像可以通过分层来进行继承,基于基础镜像(没有父镜像)可以制作各种具.体的应用镜像。

特性:一次同时加载多个文件系统,但从外面看起来,只能看到一个文件系统,联合加载会把各层文件系统叠加起来,这样最终的文件系统会包含所有底层的文件和目录。

# 4.2 镜像加载原理

docker的镜像实际上由一层一层的文件系统组成,这种层级的文件系统UnionFS。

botfs(boot file system)主要包含bootloaderkernel, 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等等。

image-20211130135141474

平时我们安装的虚拟机的Centos都是好几个G ,为什么docker这里才要200m?

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

分层的镜像

image-20211130135409596

Docker镜像都是只读的,当容器启动时,一个新的可写层被加载到镜像的顶部,这一层通常被称为容器层,容器层之下都叫镜像层

# 5 Docker容器数据卷

docker将运用与运行的环境打包形成容器运行,运行可以伴随着容器,但是我们对数据的要求希望是持久化的.但是docker容器产生的数据,如果不通过docker commit生成新的镜像,使得数据做为镜像的一部分保存下来,那么当容器删除后,数据自然也就没有了。

为了能保存数据在docker中我们使用卷:卷就是目录或文件,存在于一个或多个容器中,由docker挂载到容器,但不属于联合文件系统,因此能够绕过Union FileSystem提供一些用于持续存储或共享数据的特性:卷的设计目的就是数据的持久化,完全独立于容器的生存周期,因此Docker不会在容器删除时删除其挂载的数据卷。

特点:

  1. 数据卷可在容器之间共享或重用数据
  2. 卷中的更改可以直接生效
  3. 数据卷中的更改不会包含在镜像的更新中
  4. 数据卷的生命周期一直持续到没有容器使用它为止

# 5.1 添加数据卷

# 5.1.1 容器内添加

# 直接命令添加

docker run -it -v /宿主机绝对路径目录:/容器内目录 镜像名

e.g. docker run -it -v /docttt:/doct centos

执行后centos中会新建doct目录,宿主机会有docttt目录,但本人使用mac,发现/根目录下并没有相关目录,换到个人文件夹后则出现

若带权限:

docker run -it -v /宿主机绝对路径目录:/容器内目录:ro 镜像名

查看数据卷是否挂载成功

image-20211201144342675

容器和宿主机之间数据共享

image-20211201144404872

容器停止退出后,主机修改后的数据是否同步

image-20211201144418165

# DockerFile添加

在dockerfile中使用VOLUME指令来给镜像添加一个或多个数据卷:

VOLUME["/dataVolumeContainer","dataVolumeContainer2","/dataVolumeContainer3"]

因为出于可移植和分享的考虑,用-v 主机目录:容器目录这种方法不能够直接在Dockerfile中实现。
由于宿主机目录是依赖于特定宿主机的,并不能够保证在所有的宿主机上都存在这样的特定目录。

在dockerfile中编写:

build后生成镜像:

获得一个新镜像zzyy/centos,run容器

通过上述步骤,容器内的卷目录地址已经知道,对应的主机目录在哪(因为上面没有指定宿主机的目录,所以这里是随机生成的)

主机对应默认地址

Docker挂载主机目录Docker访问出现cannot open directory . Permission denied
解决办法:在挂载目录后多加一个–privileged=true参数即可

# 5.2 数据卷容器

命名(–name)的容器挂载数据卷,其它容器通过挂载这个(父容器)实现数据共享,挂载数据卷的容器,称之为数据卷容器.

个人理解为用一个镜像生成多个容器,这多个容器他们拥有各自的文件系统,但是在文件系统中都挂上了同一块卷,相当于一个U盘同时插在多个容器上。

例子:

  1. 以上一步新建的zzyy/centos为模板并运行3个容器 doc1/doc2/doc3。

    根据dockerfile的设定,他们已经具有容器卷/dataVolumeContainer1 /dataVolumeContainer2。

    先启动一个父容器doc1,并在dataVolumeContainer2新建测试文件doc1_add.txt

    image-20211202211735820

  2. doc2/doc3 继承doc1(--volumes -from),分别在dataVolumeContainer2各自新增内容

    image-20211202211906613

  3. 回到doc1可以看到02/03各自添加的都能共享了

  4. image-20211202211956741

  5. 检查删除doc1、 doc2修改后doc3是否可以访问

    image-20211202212022779

  6. 检查删除doc02后doc3是否访问

    image-20211202212042241

  7. 进一步生成doc4,然后删除doc03

    image-20211202212101899

    image-20211202212116830

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

# 6 DockerFile解析

# 6.1 DockerFile简介

Dockerfile是用来构建Docker镜像的构建文件,由一系列命令和参数构成的脚本。

构建步骤主要为:1.编写Dockerfile文件 2.docker build 3.docker run

以Centos为例:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
FROM scratch
ADD centos-7-x86_64-docker.tar.xz /

LABEL \
    org.label-schema.schema-version="1.0" \
    org.label-schema.name="CentOS Base Image" \
    org.label-schema.vendor="CentOS" \
    org.label-schema.license="GPLv2" \
    org.label-schema.build-date="20201113" \
    org.opencontainers.image.title="CentOS Base Image" \
    org.opencontainers.image.vendor="CentOS" \
    org.opencontainers.image.licenses="GPL-2.0-only" \
    org.opencontainers.image.created="2020-11-13 00:00:00+00:00"

CMD ["/bin/bash"]

# Docker执行Dockerfile的大致流程

  1. docker 从基础镜像运行一个容器
  2. 执行一-条指令并对容器作出修改
  3. 执行类似docker commit的操作提交一个新的镜像层
  4. docker再基于刚提交的镜像运行一一个新容器
  5. 执行dockerfile中的 下一条指令直到所有指令都执行完成

从应用软件的角度来看,Dockerfile、Docker镜像与Docker容器分别代表软件的三个不同阶段,Dockerfile是软件的原材料,Docker镜像是软件的交付品,Docker容器则可以认为是包括软件的整个运行环境。Dockerfile面向开发,Docker镜像成为交付标准,Docker容器则涉及部署与运维,三者缺一不可,合力充当Docker体系的基石。

image-20211202213317693
  1. Dockerfile,需要定义一个Dockerfile,Dockerfile定 义了进程需要的一切东西。Dockerfile涉 及的内容包括执行代码或者是文件、环境变量、依赖包、运行时环境、动态链接库、操作系统的发行版、服务进程和内核进程(当应用进程需要和系统服务和内核进程打交道,这时需要考虑如何设计namespace的权限控制)等等;
  2. Docker镜像,在用Dockerfile定义一文件之后,docker build时会产生- -个Docker镜像,当运行Docker镜像时,会真正开始提供服务;
  3. Docker容器,容器是直接提供服务的。

# 6.2 DockerFile 语法

  1. 每条保留字指令都必须为大写字母且后面要跟随至少一个参数.
  2. 指令按照从上到下顺序执行.
  3. #表示注释.
  4. 每条指令都会创建一个新的镜像层,并对镜像进行提交.

保留字:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
FROM 基础镜像,当前新镜像是基于哪个镜像的
MAINTAINER 镜像维护者的姓名和邮箱地址
RUN 容器构建时需要运行的命令
EXPOSE 当前容器对外暴露出的端口
WORKDIR 指定在创建容器后,终端默认登陆的进来工作目录,一个落脚点
ENV 用来在构建镜像过程中设置环境变量
ADD 将宿主机目录下的文件拷贝进镜像且ADD命令会自动处理URL和解压tar压缩包
COPY 类似ADD,拷贝文件和目录到镜像中。将从构建上下文目录中 <源路径> 的文件/目录复制到新的一层的镜像内的 <目标路径> 位置 COPY src dest / COPY ["src", "dest"]
VOLUME 容器数据卷,用于数据保存和持久化工作
CMD 指定一个容器启动时要运行的命令,Dockerfile 中可以有多个 CMD 指令,但只有最后一个生效,CMD 会被 docker run 之后的参数替换
ENTRYPOINT 指定一个容器启动时要运行的命令,ENTRYPOINT 的目的和 CMD 一样,都是在指定容器启动程序及参数,但与CMD不同的是在docker run后追加
ONBUILD 当构建一个被继承的Dockerfile时运行命令,父镜像在被子继承后父镜像的onbuild被触发

image-20211202214734383

# 6.3 通过Dockerfile构建镜像

# 6.3.1 Base 镜像(scratch)

Docker Hub中 99%的镜像都是通过在base镜像中安装和配置需要的软件构建出来的。

image-20211202215030615

# 6.3.2 自定义镜像mycentos

已知官方镜像的三个特点:

image-20211202215125533

自定义mycentos目的使我们自己的镜像具备如下:

  1. 登陆后的默认路径
  2. vim编辑器
  3. 查看网络配置ifconfig支持

操作步骤

  1. 准备Dockerfile文件

    1
    2
    3
    4
    5
    6
    7
    8
    9
    
    FROM centos
    MAINTAINER rax<rax@126.com>
    # 设置环境变量
    ENV MYPATH /usr/local
    WORKDIR $MYPATH 
    RUN yum -y install vim
    RUN yum -y install net-tools
    EXPOSE 80
    CMD echo $MYPATH
    
  2. 构建

    docker build -t 新镜像名字:TAG .(注意后面有个点,表示当前路径)

    image-20211204132129842

  3. 运行

    docker run -it 新镜像名字:TAG

    image-20211204132230129

  4. 列出镜像的变更历史

    docker history 镜像名

# 6.4 CMD/ENTRYPOINT的区别

两者都是指定一个容器启动时要运行的命令.

# 6.4.1 CMD

Dockerfile中可以有多个CMD指令,但只有最后一个生效,CMD会被docker run之后的参数替换,如docker run -it -p 8080:8080 tomcat ls -l.

image-20211204132947048

可以发现tomcat并没有启动,但是在dockerfile中设置了:

image-20211204133106376

# 6.4.2 ENTRYPOINT

docker run之后的参数会被当做参数传递给 ENTRYPOINT 之后形成新的命令组合.

案例

制作可以查询IP信息的容器,首先做一个CMD版本用于比较:

image-20211204133715951

curl的命令解释

curl命令可以用来执行下载、发送各种HTTP请求,指定HTTP头部等操作。

如果系统没有curl可以使用yum install curl安装,也可以下载安装。
curl是将下载文件输出到stdout
使用命令: curl http://www .baidu.com
执行后,www.baidu.com的html就会显示在屏幕上了

这是最简单的使用方法。用这个命令获得了htp://curl.haxx.se指向的页面,同样,如果这里的URL指向的是一个文件或者一幅图都可以直接下载到本地。如果下载的是HTML文档,那么缺省的将只显示文件头部,即HTML文档的header。要全部显示,请加参数-i

若加上参数-i,如下:

image-20211204134648910

可以看到可执行文件找不到的报错,**executable file not found。**之前说过,**跟在镜像名后面的是command,运行时会替换CMD的默认值。**因此这里的-i替换了原来的CMD,而不是添加在原来的curl -s htp://ip.cn后面。而-i根本不是命令,所以自然找不到。
那么如果希望加入-i这参数,我们就必须重新完整的输入这个命令:

docker run myip curl -s http://ip.cn -i

而使用ENTRYPOINT时,则可以实现:

image-20211204134558115

# 6.5 综合案例

# 6.5.1 自定义Tomcat

1
2
3
mkdir -p /zzyy/mydockerfile/tomcat9
touch c.txt
# 将jdk和tomcat安装的压缩包拷贝进上一步目录

在当前目录下新建Dockerfile文件:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
FROM centos
MAINTAINER zzyy<xxx@126.com>
#把宿主机当前上下文的c .txt拷贝到容器/usr/local/路径下
COPY c.txt /usr/local/cincontainer.txt
#把java与tomcat添加到容器中
ADD jdk-8u171-linux x64.tar.gz /usr/local/ #解压缩拷贝
ADD apache-tomcat-9.0.8.tar.gz /usr/local/
#安装vim编辑器
RUN yum -y install vim
#设置工 作访问时候的WORKDIR路径, 登录落脚点
ENV MYPATH /usr/local
WORKDIR $MYPATH
#配:置java与tomcat环境变量
ENV JAVA_ HOME /usr/local/jdk1.8.0_171
ENV CLASSPATH $JAVA_ HOME/lib/dt.jar:$JAVA_ HOME/lib/tools.jar
ENV CATALINA_ HOME /usr/local/apache-tomcat-9.0.8
ENV CATALINA_ BASE /usr/ocal/apache-tomcat-9.0.8
ENV PATH $PATH:$JAVA_ HOME/bin:$CATALINA_ HOME/ib:$CATALINA_ HOME/bin
#容器运行时监听的端口
EXPOSE 8080
#启动时运行tomcat
# ENTRYPOINT ["/usrl/local/apache-tomcat-9.0.8/bin/startup.sh" ]
# CMD ["/usr/local/apache-tomcat-9.0.8/bin/catalina.sh","run"]
CMD /usr/local/apache-tomcat-9.0.8/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.8/in/logs/catalina.out

构建:

image-20211204135937106

image-20211204140106215

运行:

1
2
3
docker run -d -p 9080:8080 -name myt9 #容器的名字
-v /zyuse/mydockerfiletomcat9/test:/usrlocal/apache-tomcat9.0.8/webapps/test #添加容器卷
-v /zzyyuse/mydockerfile/tomcat9/tomcat9logs/:/usrlocal/apache-tomcat-9.0.8/logs -privileged=true zzyytomcat9

image-20211204140414539

Docker挂载主机目录Docker访问出现cannot open directory : Permission denied解决办法:在挂载目录后多加一个-privileged=true参数即可

验证:

image-20211204140905503

部署外部网页:

在宿主机的映射对应目录中放入文件:

image-20211204141003758

在浏览器中,访问对应域名下/test/a.jsp即可。

# 6.6 总结

image-20211204141111986

# 7 Docker常用安装

# 7.1 总体步骤

搜索镜像->拉取镜像->查看镜像->启动镜像->停止容器->移除容器

# 7.2 安装Mysql

  1. docker hub 上查找mysql镜像

    image-20211204141309048

  2. 从docker hub(阿里云加速器)拉取mysql镜像到本地标签为5.6

    image-20211204141338583

  3. 使用mysql5.6镜像创建容器(也叫运行镜像)

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    
    docker run -p 12345:3306 --name mysql
    -v /ggcc/mysql/conf:/etc/mysql/conf.d
    -v /ggcc/mysql/logs:/logs
    -v /ggcc/mysql/data:/var/lib/mysql
    -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.6
    ----------------------------------------------
    命令说明:
    -p 12345:3306:将主机的12345端口映射到docker容器的3306端口。
    -name mysq:运行服务名字
    -V /ggcc/mysql/conf:/etc/mysql/conf.d :将主机/zzyyuse/mysq|录下的conf/my.cnf挂载到容器的/etc/mysql/conf.d
    -v /ggcc/mysqlogs/logs: 将主机/zzyyuse/mysq|目 录下的logs 目录挂载到容器的/logs。
    -V /ggcc/mysqldata:/var/lib/mysql :将主机lzzyyuse/mysql目录下的data目录挂载到容器的/var/lib/mysql .
    -e MYSQL_ ROOT_ PASSWORD=123456: 初始化root用户的密码。.
    -d mysql:5.6:后台程序运行mysql5.6
    ----------------------------------------------
    docker exec -it Mysql运行成功后的容器ID /bin/bash
    ----------------------------------------------
    数据备份小测试
    docker exec mysql服务容器ID sh -c 'exec mysqldump --all-databases -uroot -p"123456"' >/ggcc/all-database.sql
    

    image-20211204141851277

  4. 数据备份测试:

    image-20211204141940982

# 7.3 安装Redis

  1. 从docker hub上(阿里云加速器)拉取redis镜像到本地标签为:3.2

    image-20211204142111662

  2. 使用redis3.2镜像创建容器(也叫运行镜像)

    1
    
    docker run -p 6379:6379 -v /ggcc/myredis/data:/data -v /ggcc/myredis/conf/redis.conf:/usr/local/etc/redis/redis.conf -d redis redis-server /usr/local/etc/redis/redis.conf --appendonly yes
    
  3. 在主机/ggcc/myredis/conf/redis.conf目录上新建redis.conf文件

    1
    2
    3
    
    vim /ggcc/myredis/conf/redis.conf/redis.conf
    
    ...
    
  4. 测试 redis-cli连接

    docker exec -it 运行着redis服务容器的ID redis-cli

    image-20211204142358105

  5. 测试持久化文件生成

    image-20211204142411901

# 8 发布镜像到云

# 8.1 阿里云

image-20211204142453916

# 8.1 生成镜像

  1. 前面的Dockerfile

  2. 从容器中创建一个新的镜像

    docker commit [OPTIONS] 容器ID [REPOSITORY[:TAG]]

    image-20211204142611069

# 8.2 推送到阿里云

  1. image-20211204142725727

  2. 阿里云开发者平台

    https://promotion.aliyun.com/ntms/act/kubernetes.html

    创建镜像仓库

    image-20211204142747218

  3. 1
    2
    3
    4
    
    sudo docker login --username=white3e registry.cn-shenzhen.aliyuncs.com
    sudo docker tag [ImageId] registry.cn-shenzhen.aliyuncs.com/ggccqq/mycentos:[镜像版本号]
    sudo docker push registry.cn-shenzhen.aliyuncs.com/ggccqq/mycentos:[镜像版本号]
    其中[ImageId][镜像版本]自己填写
    

    image-20211204142828359

  4. 公有云可以查询得到

    image-20211204142858198

    image-20211204142901490

  5. 将阿里云上的镜像下载到本地

    image-20211204142923943