1、安装 Docker

# 安装依赖
sudo yum install -y yum-utils device-mapper-persistent-data lvm2
# 添加docker下载仓库
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
# 安装docker-ce
sudo yum install -y docker-ce
# 启动docker-ce
sudo systemctl start docker
# 验证
sudo docker --version
sudo docker run hello-world
图1

出现图1所示,Docker启动成功。

2、安装 docker-compose

sudo curl -L "https://github.com/docker/compose/releases/download/1.23.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

sudo chmod +x /usr/local/bin/docker-compose

docker-compose --version

自定义mycentos目的使我们自己的镜像具备如下:
登陆后的默认路径
vim编辑器
查看网络配置ifconfig支持

自己编写需求的dockerfile文件

FROM centos
MAINTAINER zzyy<zzyy167@126.cOm>        (作者和作者的邮箱)
ENV MYPATH/usr/locat                                     (定义进入实例化容器后的第一个落脚点)
WORKDIR $MYPATH                                        (引用定义变量,使进入实例化容器后的路径为此变量路径)
RUN yum -y install vim                                     (安装所需东西)
RUN yum -y install net-tools                            (安装所需东西)
EXPOSE 80                                                        (对外开放的端口)
CMD echo $MYPATH
CMD echo “success————-ok”
CMD /bin/bash                                                   (shell终端)

自定义镜像

构建        docker build -t 新镜像名字:TAG .

注:docker build -f 是指定路径         不加-f也可以直接在当前文件夹下载入其dockerfile文件

列出镜像的变更历史  docker history 镜像ID(或者镜像名)

发现我们魔改dockerfile生成的docker镜像的千层饼是倒着看的,这点有些类似栈的结构

cmd和ENTRYPOINT 案例

FROM centos
RUN yum install -y curl
CMD [“cur1″,”-s”,”http://ip.cn”]

FROM centos
RUN yum install -y curl
ENTRYPOINT [“curl”,”-s”,”https://ip.cn”]

这两个可以深入理解到ENTRYPOINT 是追加,而CMD只是覆盖

ONBULILD案列

FROM centos

RUN yum install -y curl ENTRYPOINT [“curL”,”-s”,”https://ip. cn”]
ONBUILD RUN echo “father images onbuild——–886”

然后根据这个dockerfile文件创建出镜像docker build -f dockerfile4 -t myip_father .

FROM myip_father
RUN yum install -y curl
CMD [“cur1″,”-s”,”http://ip.cn”]

docker build -f dockerfile5 -t myip_son .

这样运行的时候,会执行myip_father中的继承内容(这里不放图演示了,可自行操作)

至此docker的基本知识点梳理完毕,其中容器卷的知识,没有记录(以后有机会再学习,将其补上)

 

Dockerfile是什么

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

三步走:

手动编写一个dockerfile文件,当然,必须要符合file的规范

有这个文件后,直接docker build命令执行,获得一个自定义的的镜像

run

dockerfile内容基础知识

1:每条保留字指令都必须为大写字母且后面要跟随至少一个参数

2:指令按照从上到下,顺序执行

3:#表示注释
4:每条指令都会创建一个新的镜像层,并对镜像进行提交

Docker执行Dockerfile的大致流程

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

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

3 Docker容器,容器是直接提供服务的。

Docker体系结构(保留字指令)

FROM     基础镜像,当前新镜像是基于哪个镜像的
MAINTAINER    镜像维护者的姓名和邮箱地址
RUN    容器构建时需要运行的命令
EXPOSE   当前容器对外暴露出的端口
WORKDIR    指定在创建容器后,终端默认登陆的进来工作目录,一个落脚点(就是实列化进去pwd在哪个目录,没有写的话默认根目录)
ENV    用来在构建镜像过程中设置环境变量

ENV MY_PATH /usr/mytest

这个环境变量可以在后续的任何RUN指令中使用,这就如同在命令前面指定了环境变量前缀一样;也可以在其它指令中直接使用这些环境变量,比如:WORKDIR $MY_PATH
ADD   将宿主机目录下的文件拷贝进镜像且ADD命令会自动处理URL和解压tar压缩包
COPY    类似ADD,拷贝文件和目录到镜像中。将从构建上下文目录中<源路径>的文件/目录复制到新的一层的镜像内的<目标路径>位置

COPY srcdest

COPY [“src”,”dest”]
VOLUME       容器数据卷,用于数据保存和持久化工作
CMD      1.指定一个容器启动时要运行的命令

2.Dockerfile中可以有多个CMD指令,但只有最后一个生效,CMD会被docker run之后的参数替换
ENTRYPOINT   1.指定一个容器启动时要运行的命令

2.ENTRYPOINT的目的和CMD一样,都是在指定容器启动程序及参数(但是有个命令时不覆盖,会进行追加执行)

ONBUILD      当构建一个被继承的Dockerfile时运行命令,父镜像在被子继承后父镜像的onbuild被触发

 

 

UnionFS(联合文件系统):

Union文件系统(UnionFS)是一种分层、轻量级并且高性能的文件系统,它支持对文件系统的修改作为
一次提交来一层层的叠加,同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into a single virtual filesystem)。Union 文件系统是Docker镜像的基础。镜像可以通过分层来进行继承,基于基础镜像(没有父镜像),可以制作各种具体的应用镜像。
特性:一次同时加载多个文件系统,但从外面看起来,只能看到一个文件系统,联合加载会把各层文件系统叠加起来,这样最终的文件系统会包含所有底层的文件和自录

Docker镜像加载原理:

docker的镜像实际上由一层一层的文件系统组成,这种层级的文件系统UnionFS。
bootfs(boot filesystem)主要包含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这里才200M??
对于一个精简的OS,rootfs可以很小,只需要包括最基本的命令、工具和程序库就可以了,因为底层直接用Host的kernel,自己只需要提供rootfs就行了。由此可见对于不同的linux发行版,bootfs基本是一致的,rootfs会有差别,因此不同的段行版可以公用bootfs。
注:docker是与宿主机共用内核的,bootfs相当于linux内核,它就相当于那个蓝色鲸鱼的背

为什么Docker镜像要采用这种分层结构呢?

最大的一个好处就是-共享资源
比如:有多个镜像都从相同的base镜像构建而来,那么宿主机只需在磁盘上保存一份base镜像,同时内存中也只需加载一份base镜像,就可以为所有容器服务了。而且镜像的每一层都可以被共享。

docker镜像的特点:

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

docker镜像commit补充(这部分知识的暂且没理解上去,之后补充):

docker commit提交容器副本使之成为一个新的镜像(反馈回去)
docker commit -m=“提交的描述信息“ -a=“作者”容器ID 要创建的目标镜像名:[标签名]

docker commit -a=”purplet” -m=”del tomcat docs” 容器ID atguigu/tomcat02:1.2

容器命令中重要的部分

1.查看容器日志:docker logs -f -t –tail 容器ID

-t是加入时间戳
-f跟随最新的日志打
–tail数字显示最后多少条

这样前端有东西运行,再次查看进程时可以看到容器正常运行

2.查看容器内运行的进程  docker top (容器ID)

3.查看容器内部细节  docker inspect (容器ID)

4.进入正在运行的容器并以命令行交互(与ctrl+p+q对应)

docker exec -it 容器ID bashshell

重新进入docker attach 容器lD

上述两个区别

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

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

(1)exec不进入docker容器的终端,直接将命令的结果返回出来

(2)exec进入docker容器的终端

5.从容器内拷贝文件到主机上

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

e.g:docker cp 53ed8daaac5b(容器ID) /tmp/yum.log /root/

小总结

attach       Attach to a running container#当前shell 下attach连接指定运行镜像

build       Build an image from a Dockerfile#通过Dockerfile 定制镜像

commit       Create a new image from a container changes#提交当前容器为新的镜像

cp       Copy files/folders from the containers filesystem to the host path#从容器中拷贝指定文件或者目录到宿主机中

create       Create a new container#创建一个新的容器,同run,但不启动容器

diff       Inspect changes on a container’s filesystem#查看docker 容器变化

events       Get real time events from the server#从docker服务获取容器实时事件

exec       Run a command in an existing container#在已存在的容器上运行命令

export       Stream the contents of a container as a tar archive#导出容器的内容流作为一个tar归档文件[对应import]
history       Show the history of an image#展示一个镜像形成历史
images       List images#列出系统当前镜像
import       Create a new filesystem image from the contents of a tarbal#从tar包中的内容创建一个新的文件系统映像[对应export]
info       Display system-wide information#显示系统相关信息
inspect       Return low-level information on a container#查看容器详细信息
kill       Kill a running container#kill指定 docker容器
load       Load an image from a tar archive#从一个tar包中加载一个镜像[对应save]
login       Register or Login to the docker registry server#注册或者登陆一个docker源服务器
logout       Log out from a Docker registry server#从当前Docker registry退出
logs       Fetch the logs of a container#输出当前容器日志信息
port       Lookup the public-facing port which is NAT-ed to PRIVATE_PORT#查看映射端口对应的容器内部源端口
pause       Pause all processes within a container#暂停容器
ps       List containers#列出容器列表
pul       Pull an image or a repository from the docker registry server#从docker镜像源服务器拉取指定镜像或者库镜像

logs       Fetch the logs of a container#输出当前容器日志信息
port       Lookup the public-facing port which is NAT-ed to PRIVATE_PORT#查看映射端口对应的容器内部源端口

pause       Pause all processes within a container#暂停容器ps List containers#列出容器列表
pull       Pull an image or a repository from the docker registry server#从docker镜像源服务器拉取指定镜像或者库镜像

push       Push an image or a repository to the docker registry server#推送指定镜像或者库镜像至docker源服务器

restart       Restart a running container#重启运行的容器

rm       Remove one or more containers#移除一个或者多个容器
rmi       Remove one or more images#移除一个或多个镜像[无容器使用该镜像才可删除,否则需删除相关容器才可继续或-f强制剧除]
run       Run a command in a new container#创建一个新的容器并运行一个命令

save       Save an image to a tar archive#保存一个镜像为一个tar 包[对应loa]
search       Search for an image on the Docker Hub#在docker hub中搜索镜像

start       Start a stopped containers#启动容器
stop       Stop a running containers#停止容器

 

补充容器虚拟化技术的理论:

由于前面虚拟机存在这些缺点,Linux发展出了另一种虚拟化技术:Linux容器(Linux Containers,缩写为LXC)。
Linux容器不是模拟一个完整的操作系统,而是对进程进行隔离。有了容器,就可以将软件运行所需的所有资源打包到一个隔离的容器中。容器与虚拟机不同,不需要捆绑一整套操作系统,只需要软件工作所需的库资源和设置。系统因此而变得高效轻量并保证部署在任何环境中的软件都能始终如一地运行。

本篇前提:自己拉取一个centos的镜像(不会参考我前几章学习记录),本文出现的容器ID都可以换成对应的名字

dcoker容器命令:

1.新建并启动容器docker run [OPTIONS]IMAGE [COMMAND][ARG.…]

OPTIONS说明(常用):有些是一个减号,有些是两个减号
–name 容器新名字:为容器指定一个名称;
-d:后台运行容器,并返回容器ID,也即启动守护式容器;(常用)
-i  (interactive) :以交互模式运行容器,通常与-t同时使用    (常用)
-t(tty)   :为容器重新分配一个伪输入终端,通常与-i同时使用(常用)
-P(大写):随机端口映射;
-p(小写):指定端口映射,有以下四种格式

ip:hostPort:containerPort

ip::containerPort

hostPort:containerPort

containerPort

因为我们刚刚说到-it搭配使用获得一个伪输入交互的终端,我们后面指定的是刚刚pull下来的centos的ID值(可以在docke images中看到)

#使用镜像centos:latest以后台模式启动一个容器


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

docker run -it -p 8888:8080 tomcat(指定把tomcat的8080端口映射到8888端口)

docker run -it -P tomcat(随机分配指定端口)

这两条很重要,这里不放图了,可以自行尝试

2.列出当前正在运行的容器docker ps[OPTIONS]

查看linux中当前所有运行的进程的命令时ps -ef

这时候我们肯定会疑惑上图为什么我们运行centos的IMAGEID后获得的伪终端的ID数与其不对应,这就需要我们必须深层次的理解好镜像和容器的关系(可以看看我前几章的内容),这里我在解释一下

这里我们在外面的终端中docker ps查看当前run的镜像,我们可以看到红色框的是容器ID,而蓝色框的是镜像ID,我们是通过镜像ID实例化容器,从而获得的一个容器,黄色框可以看到这是我们15分钟前运行的

而后面的NAMES对应的是docker给这个容器随机分配的名字,我们可以对其进行修改docker run -it –name purpletcentos centos

同时我们也可以看到重新生成的容器ID发生了变化

OPTIONS说明(常用):
-a:列出当前所有正在运行的容器+历史上运行过的
-l:显示最近创建的容器。
-n:显示最近n个创建的容器。
-q:静默模式,只显示容器编号(即容器ID)。
–no-trunc:不截断输出。

3.退出容器(两种方法)

第一种:exit  容器停止退出

第二种:ctrl+p+q容器不停止退出

第一种已经可以看到没有运行的了

第二种仍然在运行

4.启动容器docker start(容器ID)(可以是之前已经关闭停止的容器)

5.重启容器:docker restart(容器ID)

可以看到重启后的容器刚运行5秒中

6.停止容器  docker stop (容器ID)相当于正常关机

7.强制停止 docker kill (容器ID)速度快,相当于直接拔电源

8.删除已停止的容器  docker rm 【-f】(容器ID)

加-f强制删除

9.一次性删除多个容器

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

docker的帮助命令:

1.docker version  2.docker info   3.docker –help(主要看这个学会看帮助信息)(英语好吃香奥)

通过docker图标深入理解几者的关系

蓝色的大海 ————–我们的ubuntu18.04

鲸鱼 ————————-docker

集装箱 ———————-容器实例         from镜像模板(下图最左边的)

docker的镜像命令:

1.docker images   列出本地主机上的镜像

这里可以看到前面的是我们可以拉取的镜像,通过上节docker run hello-world(先去找本地有没有这个镜像模板,有的话就通过这个镜像模板生成容器实例)

各个选项的说明:

REPOSITORY:表示镜像的仓库源(唯一镜像名)上图的这些就属于镜像模板

TAG:镜像的标签

IMAGE ID :镜像ID(唯一)

CREATED:镜像创建时间

SIZE:镜像大小

有几个OPTIONS说明

-a:列出本地所有的镜像(含中间映像层)

-q:只显示镜像ID

–digests:显示镜像的摘要信息

–no-trunc:显示完整的镜像信息

为什么会有none呢,可以理解镜像就是一个千层饼,一层套着一层

可以查看到全部的镜像ID值,以上最常用的是-a和-q

2.docker search 某个镜像名字(Tomcat)它实际上是从dockerhub(类似github保存着不同镜像)上进行的寻找

OPTIONS说明

–no-trunc:显示完整的镜像描述

-s :列出收藏数不小于指定值的镜像

–automated:只列出automatedbuild类型的镜像(是ok的)

3.docker pull 某个镜像名字(tomcat)[:TAG]

从dockerhub上对镜像文件进行下载

docker pull tomcat     等价于   docker pull tomcat :latest

4.docker rmi 镜像名字(hello-world)[:TAG](3.2版本)

也是默认删除最新的

当有容器实例跑着的时候会出现第一个的情况无法删除,接下来我们用-f进行强制删除

可以看到删除的是两层(映证前面的千层饼说法,镜像是一层一层套在一起的)

删除单个:docker rmi -f 镜像ID(或者镜像名称)

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

删除全部:docker rmi -f $(docker images -qa)

简单理解docker的作用:即:将一台电脑上可以运行好的程序封装成一个镜像(docker中的重要概念)

镜像内容包括:运行文档,配置环境,运行环境,运行依赖包,操作系统发行版,内核等信息

将其快速分配给其他人,方便其快速部署出相同的环境,运行其程序

docker三要素:仓库,镜像,容器(仓库是存放镜像的地方)

容器的概念:

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

docker是什么:一句话:解决了运行环境和环境配置问题软件容器,方便做持续集成并有助于整体发布的容器虚拟化技术

docker基于go语言编写

docker安装:1.在ubuntu18.04上安装参考https://www.cnblogs.com/ws17345067708/p/10455460.html(我记得我是跟着其安装下的,速度会有点慢)

​    ​    ​    ​    ​2.也可在centos7或8上安装(大于centos6.5)

ubuntu18.04安装配置docker的阿里云镜像加速器,参考:https://blog.csdn.net/qq_39506912/article/details/88974664

因为如果不使用加速器,调用的是国外的网站速度十分缓慢

最后检验是否安装完成docker version 或者docker info

接下来我们开始第一个hello-world           docker run hello-world

run先对本地的镜像进行一个查找,如果没有再从aliyun上进行查找(我们已经修改好),如果aliyun上也没有则获取不到任何东西

至此docker配置成功