Docker学习笔记

目录

一：Docker是什么？

二：容器

三：镜像

四：容器数据卷

五：DockerFile

六：自定义镜像tomcat9

---

一：Docker是什么？

Docker利用容器独立运行一个或一组应用。容器是用镜像创建的运行实例。

它可以被启动、开始、停止、删除。每个容器都是相互隔离的、保证安全的平台。

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

容器的定义和镜像几乎一模一样，也是一堆层的统一视角，唯一区别在于容器的最上面那一层是可读可写的。

仓库（repository）：
仓库是集中存放镜像文件的场所。
仓库和仓库注册服务器（registry）是有区别的。仓库注册服务器上往往存放着多个仓库，每个仓库中又包含了多个镜像，每个镜像有不同的标签（tag）。

仓库分为公开仓库和私有仓库两种形式。

最大的公开仓库是Docker Hub（https://hub.docker.com/）

存放了数量庞大的镜像供用户下载。国内的公开仓库包括阿里云(https://dev.aliyun.com/search.html)、网易云(https://c.163yun.com/hub#/m/home/)等。

Docker本身是一个容器运行载体或称之为管理引擎。我们把应用程序和配置依赖打包好形成一个可交付的运行环境，这个打包好的运行环境就似乎image镜像文件。只有通过这个镜像才能生存Docker容器。image文件可以看作是容器的模板。docker根据image文件生成容器的实例。同一个image文件，可以生成多个同时运行的容器实例。

image文件生成的容器实例，本身也是一个文件，称之为镜像文件。

一个容器运行一种服务当我们需要的适合，就可以通过docker客户端创建一个对应的运行实例，也就是我们的容器。

至于仓库，就是放了一堆镜像的地方，我们可以把镜像发布到仓库中，需要的时候从仓库中拉下来就可以了。

centos6.8
1.yum install -y epel-release（类似Java中的jdbc驱动包）
2.yum install -y docker-io
3.安装后的配置文件：/etc/sysconfig/docker
4.启动docker后台服务：service docker start
5.docker version验证

centos7
https://docs.docker.com/install/linux/docker-ce/centos
中文网：https://www.docker-cn.com

阿里云镜像加速：
是什么：https://dev.aliyun.com/search.html
注册一个属于自己的的阿里云账户
获得加速器地址连接
配置本机docker运行镜像加速器
重新启动docker后台服务 service docker restart
linux系统下配置完加速器需要检查是否生效

https://s02zwcoe.mirror.aliyuncs.com

{
  "registry-mirrors": "https://s02zwcoe.mirror.aliyuncs.com"
  }

常用命令：
docker version
docker info
docker --help

鲸鱼背上有集装箱
蓝色的大海里面-------宿主系统windows10

鲸鱼 ----docker

集装箱 ---- 容器实例 form 来自我们能用的镜像模板

docker images
options说明
-a:列出本地所有的镜像（含中间镜像层）
-q:只显示镜像ID.
--digests:显示镜像的摘要信息
--no-trunc:显示完整的镜像信息

docker search 某个xxx镜像的名字 
网站： https://hub.docker.com
命令：
options:说明
--no-trunc:显示完整的镜像描述
-s:列出收藏数不小于指定值的镜像
--automated:只列出automated build类型的镜像；
docker search -s 30 tomcat

docker pull 某个xxx镜像名字
下载镜像
docker pull tomcat 等价于 docker pull tomcat:lastest

docker rmi 某个镜像名字id
docker rmi -f(强制删除) hello-world:latest
options:说明
[root@localhost /]# docker rmi -f hello-world nginx:latest
[root@localhost /]# docker rmi -f $(docker images -qa)

二：容器

有镜像才能创建容器，这是根本前提（下载一个centos镜像演示，[root@localhost /]# docker pull centos）
新建并启动容器 docker run[options] image [command][arg] 
options说明（常用）：有些是一个减号，有些是两个减号

--name="容器新名字"：为容器制定一个名称：
-d:后台运行容器，并返回容器ID，也即启动守护式容器：
-i:以交互模式运行容器，通常与-t同时使用：
-t:为容器重新分配一个伪输入终端，通常与-i同时使用：
-P：随机端口映射
-p:制定端口映射，有一下四种格式
    ip:hostPort:containerPort
    ip:containerPort
    hostPort:containerPort
    containerPort

列出所有当前正在运行的容器
ps -ef：查看所有进程
docker ps:查看所有集装箱
options说明（常用）：
-a:列出当前所有正在运行的容器+历史上运行过的
-l:显示最近创建的容器
-n:显示最近n个创建的容器
-q:静默模式，只显示容器编号
--no-trunc:不截断输出

退出容器：
两种退出方式：
exit 容器停止、退出
ctrl+P+Q 容器不停止退出

启动容器：
docker start 容器id或者容器名

重启容器：
docker restart 容器id或者容器名

停止容器：
docker stop 容器id或者容器名

强制停止：
docker kill 容器id或者容器名

删除已停止的容器：
docker rm 容器id 
一次性删除多个容器
docker rm -f $(docker ps -a -q)
docker ps -a -q | xargs docker rm

重要：
启动守护式进程 docker run -d 容器名
问题：使用docker ps -a将进行查看，会发现容器已经退出
很重要的要说明的一点：docker容器后台运行，就必须有一个前台进程
容器运行的命令如果不是那些一直过期的命令（比如运行top,tail），就是会自动退出的。

这个是docker的机制问题，比如你的web容器，我们以nginx为例，正常情况下，我们配置启动服务只需要启动相应的service即可。例如service nginx start
但是，这样做，nginx为后台进程模式运行，就导致docker前台没有运行的应用，这样的容器后台启动后，会立即自杀因为他就的没事可做了，所以，最佳的方案是，将你要运行的程序以前台进程的形式运行。

查看可能容器日志：
docker logs -f -t --tail 容器id
-t 是加入时间戳
-f 跟随最新的日志打印
--tail 数字显示最后多少条

docker run -d centos /bin/sh -c "while true;do echo hello zzyy;sleep 2;done"

查看容器内运行的进程
docker top 容器id

查看容器内部细节
docker inspect 容器id

进入正在运行的容器并以命令行交互
docker exec -it 容器id bashshell
重新进入docker attach 容器id
上述两个区别：
attach:直接进入容器自动命令的终端，不会启动新的进程
exec:是在容器中打开新的终端，并且可以启动新的进程

docker run -it centos
docker run -it /bin/bash(默认)

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

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

[root@localhost /]# docker cp f27586d32b9f:/tmp/yum.log /root

三：镜像

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

是什么：
UnionFS(联合文件系统)

Docker镜像加载原理

分层的镜像
为什么tomcat400多兆?
因为：(tomcat(jdk8(centos(kernel))))

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

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

docker镜像commit操作补充
docker commit提交容器副本使之成为一个新的镜像
docker commit -m="提交的描述信息" -a="作者" 容器id 要创建的目标镜像名：[标签名]
案例演示：
1.从hub上下载tomcat镜像到本地并成功运行
docker run -it -p 8080:8080 tomcat
[root@localhost conf]# docker run -it -p  8888:8080 tomcat
-p:主机端口：docker容器端口
-P 随机分配端口
i:交互
t:终端

2.故意删除上一步镜像生产tomcat容器的文档
root@5a8b2743ef45:/usr/local/tomcat/webapps# rm -rf docs/

3.也即当前的tomcat运行实例是一个没有文档内容的容器，以它的模板commit一个没有doc的tomcat新镜像atguigu/tomcat02
docker commit -a="liyinlong" -m="tomcat without docs" 容器id atguigu/mytomcat:1.2 

[root@localhost /]# docker commit -a="liyinlong" -m="tomcat without docs" 5a8b2743ef45 atguigu/mytomcat:1.2

删除所有容器：
[root@localhost /]# docker rm -f $(docker ps -q)

4.启动我们的镜像并和原来的对比

[root@localhost /]# docker run -it -p 7777:8080 atguigu/mytomcat:1.2

后台启动：
[root@localhost /]# docker run -it -p 7788:8080 tomcat

前台启动：
[root@localhost /]# docker run -d -p 7788:8080 tomcat

四：容器数据卷

5.Docker容器数据卷
是什么？
一句话：有点类似我们redis里面的rdb和aof文件

可以做什么？
容器的持久化
容器间继承+共享数据

数据卷
卷就是目录或文件，存在于一个或多个容器中，有docker挂载到容器，但不属于联合文件系统，因此能够绕过Union File System提供一些用于持续存储或共享数据的特性：

卷的设计目的就是数据的持久化，完全独立于容器的生存周期，因此Docker不会再容器删除时删除其挂载的数据卷。

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

容器内添加：
直接命令添加
命令：
docker run -it -v /宿主机绝对路径：/容器内目录 镜像名

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

docker run -it -v /myDataVolume:/dataVolumeContainer 镜像名

docker run -it -v /宿主机绝对路径目录：/容器内目录：ro 镜像名
ro:read only
容器仅允许读取，不允许写入，允许 主机读取和写入。

[root@localhost /]# docker inspect 4ba0ed330ea4

DockerFile添加：
dockerfile是什么？
javaEE Hello.java   ---> Hello.class
Docker images ===> DockerFile; t 

查看数据卷是否 挂载成功：
    
容器和宿主机之间数据共享：
        
容器停止退出后，主机修改后数据是否同步：
命令（带权限）：

DockerFile：
是什么？
java Hello.java --->  Hello.class
docker images ====> DockerFile
https://hub.docker.com
是镜像模板的描述文件
根目录下新建mydocker文件夹并进入
可在dockerfile中使用volume指令来给镜像添加一个或多个数据卷
File构建
build后生成镜像  获得一个新镜像liyinlong/centos
run容器
通过上述步骤，容器内的卷目录地址已经知道
对应的主机目录地址在哪？
主机对应默认地址

VOLUME ["/dataVolumeContainer","/dataVolumeContainer2","/dataVolumeContainer3"]
说明：处于可抑制和分享的考虑，用-v 主机目录：容器目录这种方法不能够直接在dockerfile中实现。
由于宿主机目录是依赖与特定宿主机的，并不能够保证在所有的宿主机上都存在这样的特定目录。

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

docker run -it -v /host1:/dataVolumeContainer1 -v /host2:/dataVolumeContainer2 centos /bin/bash
 

[root@localhost mydocker]# docker build -f /mydocker/Dockerfile -t liyinlong/centos .

docker run -it liyinlong/centos

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

备注：

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

以上一步新建的镜像liyilong/centos为模板并运行容器dc01/dc02/dc03
它们已经具有容器卷
/dataVolumeContainer1
/dataVolumeContainer2

容器间传递共享（--volumes-from）
先启动一个父rongqidc01
在dataVolumeContainer2新增内容

命令
docker run -it --name dc01 liyinlong/centos
[root@6d9a7c77330d dataVolumeContainer2]# touch dc01_add.txt
ctrl+p+q

dc02/dc03继承自dc01
docker run -it --name dc02 --volumes-from dc01 liyinlong/centos
touch dc02_add.txt

docker run -it --name dc03 --volumes-from dc01 liyinlong/centos

删除dc01,dc02修改后dc03可否访问

删除dc02后dc03可否访问

新建dc04继承dc03后再删除dc03
docker run -it --name dc04 --volumes-from dc03 liyinlong/centos

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

--volumes-from

dc02/dc03分别在dataVolumeContainer2各自新增内容

五：DockerFile

6.dockerFile解析
是什么
dockerfile内容基础知识：
a.每条保留字指令都必须为大写字母且后面要跟随至少一个参数
b.指令从上到下，顺序执行
c.#表示注释
d.每条指令都会创建一个新的镜像层，并对镜像进行提交

回顾：
1.手动编写一个dockerfile文件，当然，必须要符合file的规范
2.有这个文件后，直接docker build命令执行，获得一个
自定义的镜像
3.run

maven build
jar 
java -jar ext...

dockerfile是用来构建docker镜像的构建文件，是由一系列命令和参数构成的脚本

构建三步骤
1）编写dockerfile文件
2）docker build
3）docker run

文件什么样？？？
以我们熟悉的centos为例
FROM scratch(所有镜像的祖先类：本源镜像，基础镜像：元镜像)
MAINTAINER(作者、邮箱) The CentOS Project
ADD c68-docker.tar.xz /
LABEL name="CentOS Base Image" \
    vendor="CentOS" \
    license="GPLv2" \
    build-date="2016-06-02"

# Default command
CMD ["/bin/bash"]

docker run -it centos -->CMD ["/bin/bash"]

class Book{
    private int id;

    public Book(){

    }

    {
        System.out.print();
    }

    static{

    }
}

dockerfile构建过程解析
docker执行dockerfile的大致流程
1）docker从基础镜像运行一个容器
2）执行一条指令并对容器做出修改
3）执行类似docker commit的操作提交一个新的镜像层
4）docker再基于刚提交的镜像运行一个新容器
5）执行 dockerfile中的下一条指令直到所有指令都执行完成

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

FROM 
    基础镜像，当前新镜像是基于哪个镜像的
MAINTAINER 
    镜像维护者的姓名和邮箱地址
RUN 
    容器构建时需要运行的命令
EXPOSE 
    当前容器对外暴露出的端口
WORKDIR 
    指定在创建容器后，终端默认登陆进来的工作目录，一个落脚点
ENV 
    用来在构建镜像过程中设置环境变量
例如：ENV MY_PATH /usr/mytest
这个环境变量可以在后续的任何RUN指令中使用，这就如同在命令前面指定了环境变量前缀一样；也可以在其他指令中直接使用这些环境变量；
比如：WORKDIR $MY_PATH

ADD 
    将宿主机目录下的文件拷贝进镜像且ADD命令会自动处理URL和解压tar压缩包
COPY 
    类似ADD，拷贝文件和目录到镜像中。将从构建上下文目录中<源路径>的文件/目录复制到新的一层的镜像内的<目标路径>位置
    COPY src dest
    COPY["src","dest"]
VOLUME 
    容器数据卷，用户数据保存和持久化工作
CMD 
    指定一个容器启动时要运行的命令；
    Dockerfile中可以有多个CMD命令，但只有最后一个生效，CMD会被docker run之后的参数替换
CMD容器启动命令
cmd指令的格式和run相似，也是两种格式：
shell 格式：CMD<命令>
exec 格式：CMD["可执行文件"，"参数1"，"参数2"...]
参数列表格式：CMD["参数1","参数2",...]，在指定了ENTRYPOINT指令后，用CMD指定具体的参数。

ENTRYPOINT 
    指定一个容器启动时要运行的命令
    ENTRYPOINT的目的和CMD一样，都是在指定容器启动程序及参数。
ONBUILD 
    当构建一个被继承的dockerfile时运行命令，父镜像在被子继承后父镜像的onbuild被出发
    
案例
Base镜像(scratch):
    docker hub中99%的镜像都是通过在base镜像中安装和配置需要的软件构建出来的
自定义镜像mycentos：
1).编写：
Hub默认centos镜像什么情况
准备编写dockerfile文件
mycentos内容dockerfile

FROM centos

ENV mypath /tmp
WORKDIR $mypath

RUN yum -y install vim
RUN yum -y install net-tools

EXPOSE 80
CMD /bin/bash

======================
FROM centos

MAINTAINER liyinlong<[email protected]>
ENV MYPATH /usr/local
WORKDIR $MYPATH

RUN yum -y install vim
RUN yum -y install net-tools

EXPOSE 87
CMD echo $MYPATH
CMD echo "success---------------ok"
CMD /bin/bash
2).构建
    docker build -t 新镜像名字：TAG.(.表示当前目录)
[root@localhost mydocker]# docker build -f /mydocker/Dockerfile2 -t mycentos:1.3 .

3).运行

4).列出镜像的变更历史
[root@localhost /]# docker history 5182e96772bf

CMD/ENTRYPOINT镜像案例：
都是指定一个容器启动时要运行的命令
CMD:
Dockerfile中可以有多个cmd命令，但只有最后一个生效，cmd会被docker run之后的参数替换!

[root@localhost /]# docker run -it -p 7777:8080 tomcat ls -l
执行此命令，tomcat不会启动！！！

Case:tomcat的讲解演示

Dockerfile里面是最后
CMD ["catalina.sh","run"]

ENTRYPOINT:
docker run之后的参数会被当做参数传递给ENTRYPOINT,之后形成新的命令组合。
Case:
制作CMD版可以查询IP信息的容器
FROM centos
RUN yum install -y curl
CMD ["curl","-s","http://ip.cn"]

[root@localhost mydocker]# dcoker build -f /mydocker/Dockerfile3 -t myip .

[root@localhost mydocker]# docker run -it myip
当前 IP：119.137.52.31 来自：广东省深圳市 电信

问题：如果我们希望显示HTTP头信息，就需要加上-i参数
[root@localhost mydocker]# curl -s -i http://ip.cn
HTTP/1.1 200 OK
Date: Fri, 07 Sep 2018 03:28:31 GMT
Content-Type: text/html; charset=UTF-8
Transfer-Encoding: chunked
Connection: keep-alive
Set-Cookie: __cfduid=d94e004a4e5bec5ff1df5dc0912b94a601536290911; expires=Sat, 07-Sep-19 03:28:31 GMT; path=/; domain=.ip.cn; HttpOnly
Server: cloudflare
CF-RAY: 456615f7c1945420-LAX

当前 IP：119.137.52.31 来自：广东省深圳市 电信

WHY

制作ENTROYPOINT版查询IP信息的容器

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

[root@localhost mydocker]# docker build -f /mydocker/Dockerfile4 -t myip2 .

[root@localhost mydocker]# docker run -it myip2 -i
HTTP/1.1 200 OK
Date: Fri, 07 Sep 2018 03:34:01 GMT
Content-Type: text/html; charset=UTF-8
Transfer-Encoding: chunked
Connection: keep-alive
Set-Cookie: __cfduid=df3f9160681e3384fa388f4a72031a2a51536291241; expires=Sat, 07-Sep-19 03:34:01 GMT; path=/; domain=.ip.cn; HttpOnly
Server: cloudflare
CF-RAY: 45661e00e45378e0-LAX

curl http://www.baidu.com(获取网页源代码)

ONBUILD:

[root@localhost mydocker]# docker build -f /mydocker/Dockerfile4 -t my_father .

Dockerfile5
FROM my_father
RUN yum install -y curl
CMD ["curl","-s","http://ip.cn"]

[root@localhost mydocker]# docker build -f /mydocker/Dockerfile5 -t my_son .
Sending build context to Docker daemon  6.144kB
Step 1/3 : FROM my_father
# Executing 1 build trigger
 ---> Running in 1f0d719e1181
father image onbuild---------886
Removing intermediate container 1f0d719e1181
 ---> 933adadb2304
Step 2/3 : RUN yum install -y curl
 ---> Running in d0492d89d9a7
Loaded plugins: fastestmirror, ovl
Loading mirror speeds from cached hostfile
 * base: mirrors.huaweicloud.com
 * extras: mirrors.aliyun.com
 * updates: mirrors.aliyun.com
Package curl-7.29.0-46.el7.x86_64 already installed and latest version
Nothing to do
Removing intermediate container d0492d89d9a7
 ---> 6f0cfe4eb39c
Step 3/3 : CMD ["curl","-s","http://ip.cn"]
 ---> Running in 80036c4f893c
Removing intermediate container 80036c4f893c
 ---> 98e4f43e4976
Successfully built 98e4f43e4976
Successfully tagged my_son:latest

六：自定义镜像tomcat9

1.mkdir -p /liyinlong/mydockerfile/tomcat9
2.在上述目录下touch c.txt
3.将jdk和tomcat安装的压缩包拷贝进上一步目录
apache-tomcat-9.0.8.tar.gz
jdk-8u171-linux-x64.tar.gz
4.在/liyinlong/mydockerfile/tomcat9目录下新建dockerfile文件
内容：
FROM   centos
MAINTAINER liyinlong<[email protected]>
#把宿主机当前上下文的c.txt拷贝到容器/usr/local/路径下
COPY c.txt /usr/local/cincontainer.txt
#把java与tomcat添加到容器中
ADD jdk-8u181-linux-x64.tar.gz /usr/local/
ADD apache-tomcat-9.0.11.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_181
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.11
ENV CATALINA_BASE /usr/local/apache-tomcat-9.0.11
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
#容器运行时监听的端口
EXPOSE 8080
#启动时运行tomcat
# ENTRYPOINT ["/usr/local/apache-tomcat-9.0.11/bin/startup.sh"]
# CMD ["/usr/local/apache-tomcat-9.0.11/bin/catalina.sh","run"]
CMD /usr/local/apache-tomcat-9.0.11/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.11/bin/logs/catalina.out

5.构建
[root@localhost tomcat9]# docker build -t  liyinlongtomcat9 .
-f指定dockerfile文件，若名称为Dockerfile，则不需要加-f

6.run
docker run -d -p 9080:8080 --name myt9 -v /liyinlong/mydockerfile/tomcat9/test:/usr/local/apache-tomcat-9.0.11/webapps/test -v /liyinlong/mydockerfile/tomcat9/tomcat9logs/:/usr/local/apache-tomcat-9.0.11/logs --privileged=true liyinlongtomcat9

分步讲解：
docker run -d(后台运行) -p 9080:8080 --name myt9 

-v(添加容器卷) /liyinlong/mydockerfile/tomcat9/test:
/usr/local/apache-tomcat-9.0.11/webapps/test 

-v(添加容器卷) /liyinlong/mydockerfile/tomcat9/tomcat9logs/:
/usr/local/apache-tomcat-9.0.11/logs 

--privileged=true 

liyinlongtomcat9

7.验证
浏览器打开：http://192.168.17.132:9080/
[root@localhost /]# docker exec f38d823eec6a ls -l
total 8
drwxr-xr-x. 9 root root 4096 Sep  7 07:12 apache-tomcat-9.0.11
drwxr-xr-x. 2 root root    6 Apr 11 04:59 bin
-rw-r--r--. 1 root root    0 Sep  7 06:32 cincontainer.txt
drwxr-xr-x. 2 root root    6 Apr 11 04:59 etc
drwxr-xr-x. 2 root root    6 Apr 11 04:59 games
drwxr-xr-x. 2 root root    6 Apr 11 04:59 include
drwxr-xr-x. 7   10  143 4096 Jul  7 08:09 jdk1.8.0_181
drwxr-xr-x. 2 root root    6 Apr 11 04:59 lib
drwxr-xr-x. 2 root root    6 Apr 11 04:59 lib64
drwxr-xr-x. 2 root root    6 Apr 11 04:59 libexec
drwxr-xr-x. 2 root root    6 Apr 11 04:59 sbin
drwxr-xr-x. 5 root root   49 Aug  4 22:04 share
drwxr-xr-x. 2 root root    6 Apr 11 04:59 src

8.结合前述的容器将测试的web服务test发布
docker exec -it containerID /bin/bash
小总结：
见有道云笔记
7.Docker常用安装
总体步骤：
搜索镜像、拉取镜像、查看镜像、启动镜像、停止容器、移除容器
安装tomcat：
a).docker hub上面查找tomcat镜像
docker search tomcat
b).从docker hub上拉去tomcat镜像到本地
docker pull tomcat
c).docker images查看是否有拉取到的tomcat
docker images tomcat
d).使用tomcat镜像创建容器（也叫运行镜像）
docker run -it -p 8080:8080 tomcat
-p:主机端口：docker容器端口
-P：随机分配端口
-i:交互
-t:终端
安装MySQL：
a).docker hub上面查找mysql镜像
docker search mysql
b).从docker hub上(阿里云加速器)拉取镜像到本地标签为5.6
docker pull mysql:5.6
c).使用mysql5.6镜像创建容器(也叫运行镜像)

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

命令说明：
-p 12345:3306 将主机的12345端口映射到docker容器的3306端口
--name mysql:运行服务名字
-v /liyinlong/mysql/conf:/etc/mysql/conf.d:将主机/liyinlong/mysql目录下的conf/my.cnf挂载到容器的/etc/mysql/conf.d
-v /liyinlong/mysql/logs:/logs:将主机/liyinlong/mysql目录下的logs目录挂载到容器的/logs
-v /liyinlong/mysql/data:/var/lib/mysql:将主机/liyinlong/mysql目录下的data目录挂载到容器的/var/lib/mysql
-e MYSQL_ROOT_PASSWORD=123456:初始化root用户的密码
-d mysql5.6:后台程序运行mysql5.6

docker exec -it MySQL运行成功后的容器ID /bin/bash

数据备份：
docker exec mysql服务器ID sh -c 'exec mysqldump --all-databases -uroot -p"123456"' > /liyinlong/all-databases.sql

安装redis：
1.拉取镜像
[root@localhost /]# docker pull redis:3.2
2.镜像创建容器（也叫运行镜像）
docker run -p 6379:6379 -v /liyinlong/myredis/data:/data -v /liyinlong/myredis/conf/redis.conf:/usr/local/etc/redis/redis.conf -d redis:3.2 redis-server /usr/local/etc/redis/redis.conf --appendonly yes

docker run -p 6379:6379 
-v /liyinlong/myredis/data:/data 
-v /liyinlong/myredis/conf/redis.conf:/usr/local/etc/redis/redis.conf 
-d(后台运行) redis:3.2 redis-server /usr/local/etc/redis/redis.conf 
--appendonly（开启aof） yes
3.在主机/liyinlong/myredis/conf/redis.conf目录下新建redis.conf文件

vim /liyinlong/myredis/conf/redis.conf/redis.conf

client-output-buffer-limit normal 0 0 0
client-output-buffer-limit slave  256mb 64mb 60
client-output-buffer-limit pubsub 32mb 8mb 60
hz 10
aof-rewrite-incremental-fsync yes

protected-mode yes

port 6379

tcp-backlog 511

timeout 0

tcp-keepalive 300

supervised no

pidfile /var/run/redis_6379.pid

测试redis-cli连接上来

docker exec -it 容器id redis-cli

测试持久化文件生成
[root@localhost data]# vi /liyinlong/myredis/data/appendonly.aof 

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

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

镜像的生成方法：
a).前面的Dockerfile
b).从容器创建一个新的镜像
docker commit [OPTIONS] 容器ID [REPOSITORY[:TAG]]
-a:提交的镜像作者：
-m:提交时的说明文字：

将本地镜像推送到阿里云：
1.运行一个实例
[root@localhost data]# docker run -it mycentos:1.3
2.生成一个新的镜像并commit
[root@localhost data]# docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS               NAMES
36a6d4d97ff7        mycentos:1.3        "/bin/sh -c /bin/bash"   33 seconds ago      Up 31 seconds       87/tcp              mystifying_murdock
[root@localhost data]# docker commit -a liyinlong -m "new mycentos:1.4 with vim and ifconfig" 36a6d4d97ff7 mycentos:1.4
sha256:bcc1767f51c0a24adcfafb3d43bf67d00d7e207401c96ee6c5c2e403c5f1d5f4
[root@localhost data]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
mycentos            1.4                 bcc1767f51c0        10 seconds ago      371MB
3.推送到阿里云
3.1本地镜像素材原型
3.2阿里云镜像开发者平台
https://dev.aliyun.com/search.html
3.3创建仓库镜像
3.3.1命名空间
3.3.2仓库名称
3.4将镜像推送到registry

$ sudo docker login --username=龙_1994 registry.cn-shenzhen.aliyuncs.com
$ sudo docker tag [ImageId] registry.cn-shenzhen.aliyuncs.com/liyinlong/mycentos:[镜像版本号]
$ sudo docker push registry.cn-shenzhen.aliyuncs.com/liyinlong/mycentos:[镜像版本号]

registry.cn-shenzhen.aliyuncs.com/liyinlong/mycentos   1.4                 bcc1767f51c0
3.5公有云可以查询到
liyinlong/mycentos
6.查看详情

将阿里云上的镜像下载到本地：
docker pull registry.cn-shenzhen.aliyuncs.com/liyinlong/mycentos

[root@localhost data]# docker run -it bcc1767f51c0