Docker学习笔记

1、Docker的介绍

虚拟机就是带环境安装的一种结局方案

安装部署环境

Linux Containers（Linux容器）

容器的运行寄宿与内核

docker就是缩小版的虚拟机，因此docker的运行级别是秒级的

1.查看uname -r

镜像：只读的模板

容器：用镜像创建的运行实例

仓库：集中存储镜像

2.Docker在Centos6.8安装的步骤

1）、yum install -y epel-release

2）、yum install -y docker-io

3）、安装后的配置文件：/etc/sysconfig/docker

4）、启动docker后台服务：service docker start

5）、验证docker版本：docker version

Centos7的话可以参考官方文档的安装：部分执行命令可能不同

具体的安装步骤参照:https://docs.docker.com

Docker在Centos7下叫做Docker CE（社区版），在Centos6.8下叫做Docker IO

3、添加阿里云的加速器——在docker的配置文件上加上

1）、登录阿里云：https://dev.aliyun.com/search.html

2）、获取加速器地址：https://xxxx.mirror.aliyuncs.com

3）、CentOS6.8需要设置配置文件的信息，这个配置文件在哪里？/etc/sysconfig/docker

other_args="--registry-mirror=https://xxxx.mirror.aliyuncs.com.mirror.aliyuncs.com" 

4）、重启docker后台服务： service docker restart

5）、检查配置是否生效：ps -ef|grep docker。能看见指定的阿里云的加速地址，说明配置成功

假设装的是Docker CE版本

见：https://dev.aliyun.com/search.html获取加速器的介绍

4、容器技术和虚拟机技术（docker和虚拟机的区别）

docker面向内核、软件，docker是秒级别的

虚拟机面向硬件，分钟级别

5、docker的基本命令

1）、帮助命令

docker vision

docker info

docker --help————linux中的查看命令：man

2、镜像命令

docker image ： 列出本地的镜像

	options：

		-a ：显示所有镜像

		-q : 只显示当前全部镜像的镜像id

		--digests ： 显示摘要信息

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

docker search + "镜像名称" ： 从docker hub中查询docker镜像

	options：

		docker search -s 30 tomcat  ： 查询超过30颗星的tomcat镜像

docker pull + “镜像名称”  						 拉去指定的镜像

docker rmi + “镜像名称” 			 			删除指定镜像  

docker rmi  -f  镜像id 							 删除单个镜像

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

docker rmi -f $（docker images -qa）			删除全部

3、容器命令

可以把容器看成简易版的Linux环境（包括root用户权限，进程空间，用户空间和网络空间等）和运行在其中的应用程序。

有镜像才能有容器：下载一个centos镜像：docker pull centos

1、新建并启动容器

  docker run 【options】 IMAGE  【COMMAND】 【ARG····】

	options 标签说明：

		--name	： 给容器起一个新名字。为容器指定一个名称

		-d 	： 后台运行容器

		-i	： 	以交互模式运行容器，通常与-t连用

** -t ： 为容器重新分配一个伪终端，通常与-i连用**

		-P	：	随机端口映射

		-p	：	指定端口映射，有四种方式

			常用：	hostPost：containerPort

2、列出所有启动的容器

docker ps 【options】

	options 标签说明：

		-l 	:	显示最近创建的容器

		-n	:	显示最近n个创建的容器

		-a	：	列出所有的运行过的容器

		-q	：	列出容器id

3、退出容器

两种方式：

	关闭并离开容器	：	exit		容器状态显示为关闭

	离开容器不关闭	:	Ctrl + PQ	容器状态显示为UP

4、启动容器

# 开启之前关闭的容器
docker start + 容器id或者容器名	

5、重启容器

docker restart 容器编号

6、停止容器

docker stop 容器id

7、强制停止容器

docker kill 容器id

8、删除已停止的容器

docekr rm 容器id

#批量删除容器
docker rm -f ${docker ps -q -a}	
docker ps -a -q | xargs docker rm

Docker容器重点：

1、以守护进程的方式运行容器

docker run -d centos

注意：docker ps -a ： 发现容器已经关闭

原因：这是docker的运行机制，docker 容器后台运行，就必须有一个前台进程。容器命令不是那些一直被挂起的命令：如top、tail等，就会自动退出。

最佳解决方案：将要运行的程序以前台进程的形式运行。

2、查看容器日志

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

	-t	：	加入时间戳

	-f	：	跟随最新的日志打印

	--tail 数字	：	显示最后多少条

#执行一个简单的sh脚本
docker run -d centos /bin/sh -c "while true;do echo hello world;sleep 2;done"

3、查看容器内运行的进程

docker top 容器id

4、查看容器内部细节

#在容器数据卷中详细介绍
docker inspect 容器id

5、进入正在运行的容器并以命令行交互

#进入容器中
docker attach 容器id

#可以进入容器、也可以不进入容器，实现操作容器
#进入容器，并交互
docker exec -it 容器id /bin/bash
#不进入容器，直接在宿主机操作容器
docker exec 容器id

区别：attach：直接进入容器启动命令的终端，不会启动新的进程。

    exec：在容器中打开新的 终端，并且可以启动新的进程。相当于隔山打牛，不进入容器可以操作容器的终端。

6、从容器内copy文件数据到宿主机上

# 注意：容器停止（docker stop），这样容器中的数据就没有了

docker cp 容器id 容器内路径文件 目的地主机路径

4、docker镜像

1、Docker镜像是什么？

轻量级的，可执行的独立软件包。用来打包软件运行环境和基于运行环境开发的软件，包含所需的所有内容。

1）、UnionFS联合文件系统

一层一层的叠加。

2）、docker镜像加载原理

Docker镜像的最底层是bootfs。每一个容器就是精简版的linux系统，相当于linux的内核。

3）、分层的镜像：这就是为什么tomcat镜像这么大的原因

4）docker为什么要采用这种分层结构

最大的好处就是共享资源。

2、特点

Docker镜像都是只读的

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

3、Docker镜像commit

docker commit 提交容器副本使之成为一个容器镜像

docker commit -m=“描述信息” -a=“作者” 容器id 要创建的目标镜像名：TAG标签

案例演示：删除tomcat中的doc

1）、从hub中下载tomcat并运行

docker run -it -p 8888:8080 tomcat

-it:终端交互	-p：分配端口		-P：随机分配端口

2）、删除tomcat中容器文档

3)、以修改的tomcat为模板，commit

4)、启动新的镜像和原来的作对比

如何查看容器id：运行的镜像才能有容器id。

重点的两个没理解：

1、docker exec -it 容器id bashShell

	重新进入容器：docker attach 容器id

2、不同容器运行状态

以守护进程的方式运行容器与以终端交互方式运行容器

docker run -d 镜像id

docker run -it 镜像id

5、Docker容器数据卷

1、数据卷是什么

Data volumes是一个或者多个容器特别指定的目录,它区别于联合文件系统的(Union File System,或称UnionFS,通过底层的操作的文件系统,具有轻量级和快速的特性,Docker 容器也是使用联合文件系统去创建数据块的.)

Docker的理念：

1）、将运行环境和运行的代码打包成容器，运行可以伴随着容器，但是我们对容器中数据的要求可能是持久化的。

2）、容器之间希望有可能共享数据

docker中的数据如果不使用commit生成新的镜像，关闭容器或者删除容器时，容器中的数据自然就会被删除

为了能保存容器中的数据我们使用卷，有点类似Redis中的rdb和aof文件。

2、数据卷的作用（Data volumes）

作用：容器的持久化、容器间继承和共享数据

• 当容器被创建的同时,数据卷已经被初始化了.当镜像数据在制定的挂载点上时,存在的数据会复制到新的卷上.(但是,如果挂载的是主机路径不适用)
• 容器之间的数据卷可以重用和共享.
• 可以直接更改数据卷
• 镜像更新不会更改数据卷.
• 容器被删除，数据卷不受影响.

3、容器内添加数据卷

向容器中添加数据卷的两种方式：

1、直接命令添加

1）命令：

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

#例如
docker run -it -v /myDataVolume:/containerDataVolume centos
#会在宿主机上生成myDataVolume目录并在docker容器centos中生成containerDataVolume目录，用于宿主机和容器的数据交互（就相当于将移动硬盘插入到笔记本中）

2）、查看数据卷是否挂在成功

#查看容器内部细节：以json串的格式显示容器内部细节。
docker inspect 容器id

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

在容器中或者在宿主机中修改数据能够实现数据的共享！

4）、容器停止退出后，主机修改数据是否能同步？

5）、命令（带权限）

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

#例如
docker run -it -v /myDataVolume:/containerDataVolume：ro centos
#ro:相当于给容器设定权限，readOnly。只可以读不可以写！只容许宿主机操作，容器只能读！
#可以使用：docker inspect 容器id  查看

2、DockerFile添加

DockerFile：镜像模板的描述文件！

使用DokcerFile添加容器数据卷

1）、根目录下创建myDocker文件夹并进入

2）、可在DockerFile中使用VOLUME指令来给镜像添加一个或多个数据卷

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

说明：处于移植和分享的考虑，使用 -v 主机目录：容器目录 这种方法不能直接在dockerFile中实现。

由于宿主机目录是依赖特定宿主机的，并不能保证所有的宿主机都存在所建的特定目录！

3）、File构建

vim dockerFile

#内容
# volume test
FROM centos
VOLUME["/dataVolumeContainer1","/dataVolumeContainer2"]
CMD echo "finished,----------success1"
CMD /bin/bash

4）、build后生成镜像

docker build -f /mydocker/dockerfile -t zzyy/centos .

#参数说明：
#-f：指明dockerFile的位置，如果就在dockerFile当前位置，可以不用写
#-t：给生成的镜像命名
# 最后是一个点，不能省略

5）docker run 新生成的镜像

dockerFile指明了新生成的容器中生成了两个数据卷：dataVolumeContainer1和dataVolumeContainer2

6）、通过上述步骤，容器内的卷目录地址已经知道，对应的主机目录在哪呢？

#如果不指明，会有一个默认的宿主机卷路径
docker inspect 容器id

注意：如果报错：Cannot open directroy

解决办法：在挂载目录下多加一个–privileged=true参数即可

4、数据卷容器

1、数据卷容器是什么？

命令的容器挂载数据卷，其他容器通过挂载这个（父容器）实现数据共享，挂载数据卷的容器，称之为数据卷容器。

2、总体介绍

1）、以上一步新建的镜像zzyy/centos为模板并运行容器dc01/dc02/dc03

2）、他们已经具有容器卷：/dataVolumeContainer1,dataVolumeContainer2

3、容器间传递共享（–volumes-form）

1）、先启动一个父容器(在dataVolumeContainer2中新增内容)

docker run -it --name dc01 zzyy/centos

2）、dc02、dc03继承自dc01

#dc02继承dc01
#并在2容器中添加内容
docker run -it --name dc02 --volumes-from dc01 zzyy/centos


#dc03继承dc01
#在3容器中添加内容
docker run -it --name dc03 --volumes-from dc01 zzyy/centos

3）、回到dc01、可以看到02/03都实现了数据的共享

4）删除dc01，dc02修改后dc03是否可访问

5） 新建dc04继承dc03后在删除dc03，查看dc04容器中的数据

总结：容器之间的配置信息的传递，数据卷的声明周期已知延续到没有容器使用它为止。

6、DockerFile解析

1、DockerFile是什么

1）、DockerFile：用来构建Docker镜像的构建文件，是由一系列命令和参数构成的脚本。

2）、构建三步骤：

按指定语法编写dockerFile文件（上述的：dockerFile）

docker build：构建一个新的镜像

docker run

3）、文件是什么样？

以熟悉的Centos为例

2、DockerFile构建过程解析

1）、dockerFile内容基础知识

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

b、指令按照从上到下顺序执行

c、# 表示注释

d、每条指令都会创建一个新的镜像层，并对镜像进行提交

2）Docker执行DockerFile的大致流程

a、docker从基础镜像运行一个容器（镜像的祖宗：scratch）

b、执行一条指定就对容器做出修改

c、执行类似docker commit的操作提交一个新的镜像层

d、docker再基于刚提交的镜像运行一个新容器

e、执行dockerFile中的下一条指令直到所有指令都执行完成

3）、总结

从应用软件的角度看，DockerFile、Docker镜像，Docker容器分别代表软件的三个不同阶段。

DockerFile是软件的原材料

Docker镜像是软件的交付品

Docker容器可以认定为软件的运行状态

DockerFile面向开发，镜像称为交付标准，容器设计部署与运维，三者缺一不可，合力充当docker体系的基石。

3、DockerFile体系结构（保留字指令）

FROM：基础镜像，当前镜像是基于哪个镜像的

MAINTAINER：镜像维护者的姓名和邮箱地址

RUN：构建容器时需要运行的命令（相当于运行java中的sout）

EXPOSE：当前容器对外暴露的端口

WORKDIR：指定创建容器后，终端默认登录进来的目录，一个落脚点

ENV：用来在构建镜像过程中设置环境变量

ADD：将宿主机目录下的文件拷贝进镜像且ADD命令会自动处理URL和解压tar压缩包

COPY：类似ADD，拷贝文件和目录到镜像中。

          将从构建上下文目录中<原路径>的文件/目录复制到新的一层的镜像内的<目标路径>位置

	COPY src dest/COPY["src",""]

VOLUME : 容器数据卷，用于数据保存和持久化工作

CMD： 指定一个容器启动时要运行的命令

            Dockerfile中可以有多个CMD指令，但只有最后一个生效，CMD会被docker run之后的参数替换

ENTRYPOINT： 指定一个容器启动时要运行的命令

	ENTRYPOINT的目的和CMD一样，都是指定容器启动程序及参数

ONBUILD：当构建一个被继承的DockerFile时运行命令，父镜像在被子镜像继承后父镜像的onbulid被触发

总结：

4、案例

1）、Base镜像（Scratch）：docker hub中99%的镜像都是通过在base镜像中安装和配置需要的软件构建出来的

2）、自定义镜像

案例一：

自定义mycentos具有如下特征：

登录后的默认路径

vim编辑器

查看网络配置支持ifconfig

步骤：

1、在myDocker文件夹下创建dockerFile2文件

2、写入如下dockerFile

FROM centos

MAINTAINER haiyang<[email protected]>

ENV MYPATH /usr/local

WORKDIR $MYPATH

RUN yum -y install vim
RUN yum -y install net-tools
EXPOSE 80
CMD echo $MYPATH
CMD	echo "success-------------ok
CDM /bin/bash

3、构建新的镜像

docker bulid -f  -t 新镜像名：TAG .

# 例
docekr build -f /myDocker/dockerFile02 -t mycentos:1.0 .

4、运行

docker run -it mycentos

5、列出镜像的变更历史

docker history 镜像id

案例二：CMD与ENTRYPOINT镜像案例

它们都是指定一个容器启动时要运行的命令

CMD：Dockerfile中可以有多个CMD命令，但只有最后一个生效，CMD会被docker run后面的参数覆盖

CMD tomcat的演示：

#运行tomcat
docker run -it -p 8888:8080 tomcat

#加一条命令：就相当于加了CMD ls -l的指令
docker run -it -p 8888:8080 tomcat ls -l

#结果会不会启动tomcat也不会打日志，只会显示tomcat的目录结构,因为tomcat的WORKDIR在tomcat目录下

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

演示：制作CMD版查询ip的容器

#curl命令的解释

#dockerFile3

FROM centos
RUN yum install -y crul
CMD ["crul","-s","http://ip.cn"]

#在此dockerFile基础之上，追加http头信息，加上-i会报错
docker run 镜像 -i

#dockerFile4

FROM centos
RUN yum install -y crul
ENTRYPOINT ["crul","-s","http://ip.cn"]

#在此dockerFile基础之上，追加http头信息，加上-i不会报错
docker run 镜像 -i
#因为CMD会替换上面的功能，只是最后一个CMD生效

#就相当于ENTRYPOINT ["crul","-s","-i","http://ip.cn"]

案例三：ONBUILD

#在dockerFile中添加这个触发器，继承他的dockerFile在build时，会触发这个触发器

ONBUILD RUN echo "father images onbuild----------888"

案例四：ADD和COPY的区别

1、第一步

mkdir -p /zzyyuse/myDockerFile/tomcat9

2、在上述目录上创建c.txt

3、将jdk和tomcat安装的压缩包copy进上一层目录

4、在/zzyyuse/myDockerFile/tomcat9目录下新建DockerFile文件

FROM centos
MAINTAINER haiyang<[email protected]>
#把宿主机上的c.txt文件copy到容器的/usr/local/下,并重名了
COPY c.txt /usr/local/cincontainer.txt
#把java和tomcat添加到容器指定的位置，并解压
ADD apache-tomcat-7.0.70.tar.gz /usr/local/
ADD jdk-7u79-linux-x64.gz /usr/local/
#安装vim编辑器
RUN yum -y install vim
#设置工作访问的WORKDIR路径，登录落脚点
ENV MYPATH /usr/local 
WORKDIR $MYPATH
#配置java和tomcat环境变量
ENV JAVA_HOME /usr/local/jdk1.7.0_79
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-7.0.70
ENV CATALINA_BASE /usr/local/apache-tomcat-7.0.70
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
#容器运行的监听端口
EXPOSE 8080
#启动时运行tomcat
#ENTRYPOINT ["usr/local/apache-tomcat-7.0.70/bin/startup.sh"] 
#CMD ["usr/local/apache-tomcat-7.0.70/bin/catalina.sh","run"]
CMD usr/local/apache-tomcat-7.0.70/bin/startup.sh && tail -f /usr/local/apache-tomcat-7.0.70/bin/logs/catalina.out

5、构建

docker build -f /zzyyuse/myDockerFile/tomcat9/DockerFile -t zzyytomcat9

6、run

#后台运行
#端口映射
#起名称
#建了两个卷 
docker run -d -p 8888:8080 --name myt9 -v /zzyyuse/myDockerFile/tomcat9/test:/usr/local/apache-tomcat-7.0.70/webapps/test -v /zzyyuse/myDockerFile/tomcat9/tomcat9logs:/usr/local/apache-tomcat-7.0.70/logs --privilege=true zzyytomcat9

7、验证

1）、端口验证

2）、容器类的环境变量的验证

8、结合前述的容器卷将测试的web服务test发布

#在test下新建
cd /zzyyuse/myDockerFile/tomcat9/test
mkdir WEB-INFO
#在web-info下创建web.xml并添加内容
vim web.xml

#在test目录下创建a.jsp
vim a.jsp

5、总结

7、Docker常用安装

1、总体安装

见上

2、安装tomcat

见上

3、安装mysql

1、docker hub上查找mysql镜像

# 在官网直接查找
docekr search mysql：5.6

2、pull

3、运行

docker run -d -p 3306:3306 --name mysql -v /zzyyuse/mysql/conf:/etc/mysql/conf.d -v /zzyyuse/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 mysql:5.6

#卷解释
#1.第一个配置文件
#2.数据同步

注意：在容器外部操作容器

docker exec 容器id 操作指令

进入容器操作的两种方式：

docker attach 容器id

docker exec -it 容器id /bin/bash

进入mysql容器后，操作数据库

-- 1.登录数据库
mysql -uroot -p 
-- 密码：123456

-- 展示数据库
show database

-- 创建数据库db01
creat database db01；

--指定该数据库
use db01；

-- 创建表
create table t_user（id int not null primary key,ame varchar(20)）；

--插入数据
inser into values（1，haiyang）；

4、安装redis

1、pull

docker pull redis:3.2

2、运行redis镜像

1）、run

docker run -d -p 6379:6379 -v /zzyyuse/myredis/data:/data -v /zzyyuse/myredis/conf/redis.conf:/usr/local/etc/redis/redis.conf redis:3.2 /usr/local/etc/redis/redis.conf --appendondy yes

# --appendondy yes 开启redis的持久化aof

# 第一个卷用于redis生成aof文件
# 第二个卷用于配置文件修改

2）、在宿主机上新建/zzyyuse/myredis/conf/redis.conf/redis.conf文件

# 将redis的配置文件copy进来，相当于设定redis的配置文件
vim /zzyyuse/myredis/conf/redis.conf/redis.conf
# 注释绑定本机设置

3、测试连接redis

#使用redis-cli连接redis
docker exec -it 容器id redis-cli

4、持久化文件生成

cd /zzyyuse/myredis/data
# 可以看到aof文件生成

5、安装negix

8、本地镜像发布到阿里云

1、本地镜像发布到阿里云流程

简单的说就是将本地镜像push到阿里云！

2、镜像的生成方法

1）dockerFile生成镜像

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

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

docker commit -a haiyang -m "haiyang centos 1.4 from 1.3" 容器id mycentos：1.4

# 说明：提交的是运行的容器id   生成的是mycentos:1.4新的镜像和TAG标签

3、本地镜像推送到阿里云

1、本地镜像素材原型——本地的镜像

docker images mycentos：1.4

2、阿里云开发者平台

https://dev.aliyun.com/search.html

3、创建仓库镜像
详情见阿里云

4、将阿里云上的镜像下载到本地

在阿里云上搜索自己上传的镜像，然后复制地址

docker pull 镜像地址

9、CentOS7安装Docker

1、参照官方文档 https://docs.docker.com/install/linux/docker-ce/centos/

2、确定是centos7及以上版本

cat /etc/redhat-release

#centos7不支持这个命令
lsb_release -a

3、yum安装gcc相关

1）、确定centos7能上外网

# 安装gcc
yum -y install gcc

yum -y install gcc-c++

4、卸载旧版本

# \ 是连接符或者说是换行符
$ sudo yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-selinux \
                  docker-engine-selinux \
                  docker-engine

5、安装需要的软件包

$ sudo yum install -y yum-utils \
  device-mapper-persistent-data \
  lvm2

6、设置stable镜像仓库

$ sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo
    
#如果下载慢可以连接阿里云地址
$ sudo yum-config-manager \
    --add-repo \
    http://mirrors.aliyun.com/linux/docker-ce/linux/centos/docker-ce.repo

7、更新yum软件包索引

yum makecache fast

8、安装docker ce

yum -y install docker-ce 

9、启动docker服务

systemctl docker start

10、测试

docker version

docker run hello-world

11、配置镜像加速

mkdir -p /etc/docker

vim /etc/docker/daemon.json

#网易加速器
{
  "registry-mirrors": ["http://hub-mirror.c.163.com"]
}

#阿里加速器
{
  "registry-mirrors": ["https://[自己的阿里云加速器地址].mirror.aliyuncs.com"]
}


#重新加载配置文件
systemctl daemon-reload 
#重启服务
systemctl restart docker

#查看
ps -ef | grep docker

12、卸载docker

systemctl stop docker

$ sudo yum remove docker-ce

#删除docker仓库
$ sudo rm -rf /var/lib/docker