Docker核心技术学习笔记

Docker核心技术


思维导图: http://naotu.baidu.com/file/85634842b0e8e8630651d0fc5bf5b9a4

一 、Docker简介

问题:为什么会出现docker呢?

场景:1、“在我机器上可以正常工作”问题。因为环境和配置不同,开发和运维会出现运行结果。

​ 2、多台机器上需要部署一套代码(集群)。每一台都进行一次安装操作,过程繁琐耗时。

开发 | 运维

代码—> war | 部署

解答: 安装的时候,把原始环境一模一样的复制,开发和运维的环境和配置一样(不需要重新安装环境和更改配置)!

平台耦合性

你今天的优势会被明天的趋势所取代!

买书容易,看书难,搬家还麻烦!

二、Docker安装

前提说明

1、 CentOs Docker 安装

Docker 支持一下的CentOs版本:

  • CentOS 7 (64 bit)
  • CentOS 6.5 (64 bit)或者更高版本

2、 前提条件

目前,CentOS仅发行版本中内核支持Docker。

Docker运行在CentOS 7上,要求系统为64位,系统内核为3.10+!

Docker运行在CentOS6.5或者更高版本的CentOS上,要求系统为64位,系统内核版本为2.6.32-431或者更高。

3、查看自己的内核

uname 命令打印当前系统相关信息。内核版本号、硬件架构、主机名称和操作系统类型等。

# uname -r

查看安装CentOS版本信息

# lsb_release -a
# cat /etc/readhat-release

Docker 的基本组成

几张图帮你理解 docker 基本原理及快速入门

Docker构架

1、镜像(Image)

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

Docker 面向对象
容器 对象
镜像

2、容器(container)

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

它可以被启动、开始、停止、删除。每个容器都是互相隔离的、保证安全的平台。可以把容器看做是一个简易版的Linux环境(包括root用户权限、进程空间、用户空间和网络空间等)和运行在其中的应用程序。

3、仓库(Repository)

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

仓库分为: 公开仓库(Public)和私有仓库(Private)

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

存在放数量庞大的镜像提供用户下载。国内公开的仓库有阿里云、网易云等。

4、总结

总结

安装

配置 镜像加速,配置的时候CentOS 6.8和 7配置文件不同。

Docker 安装
Docker 安装清华

配置 镜像加速:

# 阿里云
sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://n7alqmf2.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

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

centos 7 安装docker

1、官网中文安装手册

2、确定你是centos7及以上版本
cat /etc/redhat-release

3、yum安装gcc相关
yum -y install gcc
yum -y install gcc-c++
gcc  -v

4、卸载旧的docker版本

5、安装需要的软件包

6、设置stable 镜像仓库
# 大坑
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
报错:
Errno 14 : TCP connection reset by peer
Errno 12 : Timeout
# 推荐
sudo yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
7、更新yum 软件包索引
yum makecache fast

8、安装docker ce
yum -y install docker-ce

9、启动docker
systemctl start docker

10、测试 
docker version
docker run  hello-world

11、配置进行加速配置
(1)、mkdir -p /etc/docker
(2)、vim /etc/docker/daemon.json
#### 网易云
{"registry-mirrors":["http://hub-mirror.c.163.com"]}

#### 阿里云
{"registry-mirrors":["http://{自己的编码}.mirror.aliyuncs.com"]}
# dufy aliyun
{
  "registry-mirrors": ["https://n7alqmf2.mirror.aliyuncs.com"]
}

(3)、systemctl daemon-reload
(4)、systemctl restart docker

12、停止docker服务
systemctl stop docker
13、卸载
yum -y remove docker-ce
rm -rf /var/lib/docker

启动hello-world

docker run hello-world ,先从本地找,如果本地不存在,则会从远程的仓库中 镜像pull 操作。(下载镜像)

run 启动容器。

底层原理

1、Docker是怎么工作的?

2、Docker为什么比VM快?

三、Docker常用命令

帮助命令

docker  version : docker版本

docker info : docker详细信息描述

docker --help : docker 的帮助命令

镜像命令

1、docker images

列出本地主机上的镜像

REPOSITORY TAG IMAGE ID CREATED SIZE
表示镜像的仓库 镜像的标签 镜像ID 镜像创建时间 镜像大小

同一个仓库源可以有多个TAG,代表这个仓库源的不同个版本,使用REPOSITORY:TAG来定义不同的镜像。如果不指定一个镜像的版本标签,例如使用Ubuntu,Docker默认使用ubuntu:latest镜像。

参数说明:

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

-q : 只显示镜像ID

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

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

2、docker search XXX 某个镜像的名字

网站:https://hub.docker.com/

命令:docker search 【options】 镜像名字

-s : 列出收藏数不小于指定值的镜像,docker search -s 30 tomcat

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

–automated : 只列出 automated bulid 类型的镜像

3、docker pull 镜像名

docker pull tomcat == docker pull tomcat[: TAG] ,默认TAG为latest

4、docker rmi 镜像名字/镜像ID - 删除镜像

强制删除:-f

删除单个:docker rmi -f hello-world

删除多个:docker rmi -f hello-world nginx

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

?? 思考:结合git的学习心得,可以猜测docker 会有 docker commit /docker push?

容器命令

前提:有镜像才能创建容器

1、新建并启动容器

# docker run [options] image [command] [arg...]
options说明:有些是一个减号,有些是两个减号
--name="容器新名字" : 为容器指定一个名称
-d : 后台运行容器,并返回容器的ID,也即启动守护式容器
-i : 以交互模式运行容器,通常与 -t 同时使用  [重要]
-t : 为容器重新分配一个伪输入终端,通常与 -i 一起使用  [重要]
-P : (大写)随机端口映射
-p : (小写)指定端口映射,有以下四种格式
	ip:hostPort:containerPort
	ip::containerPort
	hostPort:containerPort [重要]
	containerPort

2、列出当前所有正在运行的容器

docker ps  [-a]
-a : 代表 所有容器,包括运行和非运行的容器。
-l : 显示最近创建的容器
-n : 显示最近n个创建的容器
-q : 静默模式,只显示容器编号
--no-trunc : 不截断显示

3、容器的退出、启停

# 退出交互终端
exit : 容器停止退出
ctrl+P+Q : 容器不停止退出
# 启动
docker start container-name/container-id

# 重启
docker restart container-name/container-id

# 停止
docker stop container-name/container-id

# 强制停止
docker kill container-name/container-id

4、容器的删除

# 删除一个
docker rm container-id
-f : 强制删除

# 删除多个
docker rm -f $(docker ps -a -q)
docker ps -a -q | xargs docker rm # 上一个参数的结果集传递给下一个参数

6、重要

(1)、启动守护式容器

docker run -d 容器名

注意:使用后台模式启动一个镜像,使用docker ps -a 查看,发现容器已经退出。
很重要的一点说明:Docker 容器后台运行,就必须有一个前台进程
容器运行的命令如果不是那些一直挂起的命令(如 top、tail)等,就是会自动退出的。

这个是Docker的机制问题,比如 你的web容器,我们以nginx 为例,正常情况下,我们配置启动服务只需要启动响应的Service即可。例如 service nginx start。但是,这样做,nginx为后台进行模式运行,就导致docker 前台没有运行的应用,这样的容器后台启动后,会立即自杀。因为他觉得他没事可做了。

所以,最佳的解决方案是: 将你要运行的程序以前台进程的形式运行。

例子:
docker run -d /bin/bash -c "while true;do echo hello centos;sleep 2;done"

(2)、查看容器日志

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

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

docker top 容器id

(4)、查看容器内部细节

# docker 镜像是一层套一层
docker inspect 容器id

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

# docker exec -it 容器id bashShell
docker exec -t 3d51887b06b6  ls -l /tmp

docker exec -t 3d51887b06b6 /bin/bash

# 重新进入docker attach 容器id
docker attach 3d51887b06b6
上述两个区别:
- attach:直接进入容器启动命令的终端,不会启动新的进程
- exec:在容器中打开新的终端,并可以启动新的进程

(6)、从容器内拷贝文件到主机上

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

总结

Docker event state

不懂原理,你就是一个API调用工程师!

docker全部的命令 : http://www.runoob.com/docker/docker-command-manual.html

四、Docker 镜像

Docker 镜像就是一个千层饼,一层套一层。

1、镜像是什么?

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

  • UnionFS(联合文件系统)

UnionFS

  • Docker镜像加载原理

Docker镜像加载原理

  • 分层的镜像

以pull 为例,一层一层的往下拉取。

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

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

问题1:tomcat为什么那么大400多M?

​ 实际上有多层文件构成,一层一层进行打包。

2、镜像特点

​ Docker 镜像 都是只读的(类似鸡蛋- 蛋壳-》蛋清-》蛋黄),当容器启动时,一个新的可写层被加载到镜像的顶部。这一层通常被称作 “容器层” ,“容器层”之下都叫 “镜像层”。

3、Docker镜像commit操作补充

(1)、docker commit

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

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

# 案例演示
1、启动tomcat镜像 ,-p 8888代表是 docker的端口,8080 docker中 是tomcat的端口。
docker run -p 8888:8080 tomcat
-p:指定端口映射
-P:随机端口映射

2、故意删除tomcat容器的文档

3、把没有文档的tomcat容器当作一个模板,提交commit

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

4 、镜像生成的途径

5、 镜像导入导出

一次打包可以打包多个镜像。

docker save -o tomcatimage.gz dufy/tomcat:v0.9 dufy/tomcat:v1.0

docker load -i tomcatimage.gz

6、镜像推送到仓库

推送Docker hub、推送到阿里云,需要进行登录。dokcer login 、 docker logout

五、Docker容器数据卷

1、是什么

简单的说就是将Docker容器运行的一些数据结果保存起来(持久化+共享)。类似redis中的RDB和AOF。

Docker理念:

  • 将应用与运行的环境打包形成容器运行,运行可以伴随着容器,但是我们对数据的要求希望是持久化的
  • 容器之间希望有可能共享数据

Docker 容器产生的数据,如果不通过docker commit 生成新的镜像,使得数据作为镜像的一部分保存下来,那么容器删除之后,数据自然也就没有了。

为了能保存数据在docker 中,我们使用数据卷。

2、能干嘛

  • 容器产生数据的持久化
  • 容器间继承 + 共享数据
  • 容器到主机,主机到容器之间的数据共享

3、数据卷

(1)直接命令添加

注意: 数据卷的目录地址不能映射容器应用一样的目录名!

例如: tomcat /usr/local/tomcat/conf ,这个配置文件的目录不能进行映射。

# 添加命令  如果有Permission denied ,加 --privileged=true
1、docker run -it -v /容器内目录 镜像名 # 此种方式会自动在宿主机中生成一个对应绑定的目录
2、docker run -it -v /宿主机绝对路径目录:/容器内目录 镜像名

例子: docker run -it -v /myDataVolume:/dataVloumeContainer centos
-v : 主机和容器之间数据共享

# 查看数据卷是否挂载成功
docker inspect 容器id

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

# 容器停止退出后,主机修改后数据是否同步
容器 exit,主机修改文件后,容器启动后,数据可以进行同步。

# 命令(带权限)写保护,
docker run -it -v /宿主机绝对路径目录:/容器内目录:ro 镜像名
- ro : read only ,容器只可以读,不可写。

(2)、DockerFile添加

DockerFile : 镜像 --》DockerFile , 描述Docker的文件。

JavaEE : Hello.java —》Hello.class

# 1、根目录下新建一个myDocker 文件夹并进入
mkdir myDcker
# 2、可以在Dockerfile 中使用 VOLUME指令 来给镜像添加一个或多个数据卷
VOLUME["/dataVolumeContainer","/dataVolumeContainer2","/dataVolumeContainer3"]
说明:
	出于可移植和分享的考虑,用 -v 主机目录:容器目录 这种方法不能够直接在Dockerfile中实现。
	由于宿主机目录是依赖于特定宿主机的,并不能保证所有的宿主机上都存在这样特定目录。

# 3、File构建
vim Dockerfile
---------------------------------------------------------------
# volume test
FROM centos
VOLUME ["/dataVolumeContainer","/dataVolumeContainer2"]
CMD echo "finished ..."
CMD /bin/bash
---------------------------------------------------------------

# 4、bulid后生成镜像--》 获得一个新镜像 newcentos
docker bulid -f /mydocker/Dockerfile -t newcentos/centos .

-f: dockerFile 的意思,dockerfile 文件的目录地址

# 5、run容器
docker run -it newcentos/centos


通过上述步骤,容器内的卷目录地址已经知道,对应的主机目录地址在哪呢??
-- 
docker inspet 容器id ,查看默认的docker分配的宿主机目录  # 主机上会生成对应默认地址

(3)、备注

Docker 挂载主机目录Docker访问出现 cannot open directory : Permission denied。

解决方法: 在挂载目录后多加一个 --privileged=true 参数。

4、数据容器卷

(1)是什么?

​ 命名的容器挂载数据卷,其他容器通过挂载这个(父容器)实现数据共享,挂载数据卷的容器,称之为数据卷容器。(活动硬盘挂活动硬盘,实现数据传递共享)

(2)总体介绍

​ 根据上面学习的构建好的newcentos镜像为模板,并运行容器 dc01/dc02/dc03

​ 运行的容器都具有容器卷 ["/dataVolumeContainer","/dataVolumeContainer2"] 。

(3)容器间传递共享(–volumes-from)

# 1、先启动一个父容器dc01 ,在 dataVolumeContainer2 中新增内容
docker run -it --name dc01 newcentos/centos
cd /dataVolumeContainer2 
touch dco1.txt

# 2、dc02/dc03继承自dc01 ,使用--volumes-from ,使用同一个网络  --network:container:容器名称
docker run -it --name dc02 --volumes-from dc01 newcentos/centos
cd /dataVolumeContainer2 
ll
>  dco1.txt
touch dco2.txt

docker run -it --name dc03 --volumes-from dc01 newcentos/centos
ll
>  dco1.txt
>  dco2.txt
touch dco3.txt

# 3、回到dc01可以看到02/03各自添加的都能共享
三个实现传递和共享
# 4、删除dc01,dc02修改后dc03可否访问
docker rm -f dc01
dco1.txt 是否还在?
> 还在!

docker attach dc02
touch dco2_update.txt

docker attach dc03
ll
> 也可以实现dc02和dc03之间数据共享
# 5、删除dc02后dc03可否访问

# 6、新建dc04 继承dc03 后,再删除dc03

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

六、DockerFile解析

1、是什么

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

构建三步骤:

​ 1、手动编写一个dockerfile文件,符合file的规范

​ 2、进行bulid执行,获得一个自定义的镜像

​ 3、进行run,启动这个自定义的镜像的容器

文件是什么样?

 # 来自哪里
FROM scratch 
# 
ADD centos-7-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="20181006"

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

2、DockerFile构建过程解析

(1) dockerfile内容基础知识

  • 每条保留字指令 都必须为大写字母(最好大写)且后面要跟随 至少一个参数 ,参数和保留字直接要有空格
  • 指令按照从上到下,顺序执行
  • ‘#’ 表示注释
  • 第一个非注释行,必须是FROM 开始
  • 每条指令都会创建一个新的镜像层,并对镜像镜像提交
  • 要有工作目录,Dockerfile文件名首字母必须大写,所有依赖的包,也必须放入工作目录,或者工作目录的子目录,一定不能是工作目录的父目录。
  • 支持在工作目录中创建一个 .dockeringore,在打包时候不包含配置的文件列表,类似git的ingore

(2)Docker执行Dockerfile的大致流程

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

(3)小总结

3、DockerFile体系结构(保留字指令)

  • FORM : 指定基准镜像,当前新的镜像是基于哪个镜像的,可以是任何可以用的镜像。默认情况在本地主机上查找,若不存在,这会从Docker hub Registry 上拉取。

  • MAINTAINER: 作者和作者的邮箱,最新版本废弃,使用下面的LABEL 指令

  • LABEL 指定各种各样的元数据。

  • RUN : 容器构建时候需要的命令

run中执行的命令必须是基础镜像中有的命令!

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tnjGEIyi-1575196281141)(http://dufyun.gitee.io/images_bed/images/qiniu/201811112249_700.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y5M9Tnyp-1575196281142)(http://dufyun.gitee.io/images_bed/images/qiniu/201811112232_995.png)]

  • EXPOSE :暴露容器对外服务的端口号,默认协议就是tcp

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fux2JLj8-1575196281143)(http://dufyun.gitee.io/images_bed/images/qiniu/201811112200_344.png)]

  • WORKKDIR :指定在创建容器后,终端默认登录的进来工作目录,一个落脚点

  • ENV :用来在构件镜像过程中设置环境变量

    ENV key value

    $key 或者 ${key} ${key:-hello} ${key:+heloo}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pxnQTNKN-1575196281144)(http://dufyun.gitee.io/images_bed/images/qiniu/201811112209_725.png)]

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5TvF4Y6q-1575196281147)(http://dufyun.gitee.io/images_bed/images/qiniu/201811112156_707.png)]

  • COPY:类似ADD,拷贝文件和目录到镜像中。 COPY src dest / COPY [“src”,“dest”]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-14jZuVxY-1575196281149)(http://dufyun.gitee.io/images_bed/images/qiniu/201811112022_133.png)]

  • VOLUME:容器数据卷,用于数据保存和持久化工作,创建的时候自动创建

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TvmsSIin-1575196281150)(http://dufyun.gitee.io/images_bed/images/qiniu/201811112153_948.png)]

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-POup9sn0-1575196281151)(http://dufyun.gitee.io/images_bed/images/qiniu/201811112248_774.png)]

  • ENTRYPOINT:指定一个容器启动时要运行的命令;ENTRYPOINT目的和CMD一样,都是在指定容器启动程序及参数,ENTRYPOINT会被 docker run 之后的 追加 !

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QJaUrOIS-1575196281151)(http://dufyun.gitee.io/images_bed/images/qiniu/201811112309_288.png)]

  • ONBUILD:当构建一个被继承的Dockerfile时运行命令,父镜像在被子继承后父镜像的onbulid被触发
  • USER : 指定容器运行中的用户名或者UID

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rej0fLOd-1575196281152)(http://dufyun.gitee.io/images_bed/images/qiniu/201811122248_317.png)]

  • healthCHeck : 检查主进线的健康状态,可设定检查的时间

  • SHELL : 默认是[“bin/sh”,"-c"] ,运行程序默认执行,知道即可。

  • STOPSIGNAl: 停止信号,知道即可。

  • ARG : build 的时候使用。–docker build --build-arg

  • 保留字运行的阶段

DockerFile

4、案例

运用知识的能力,执行力!

4.1 Base镜像(scratch)

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

4.2 自定义镜像

  • 1、编写
    • Hub上默认centos的情况
    • 准备编写DockerFile文件
    • myCentos内容DockerFile
#1、初始 centos 运行该镜像 进入时候默认路径是 / 
#2、默认不支持 vim
#3、默认不支持 ifconfig

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

from centos
env mypath /tmp
workdir $mypath

run yum -y install vim
run yum -y install net-tools

expose 80

cmd echo $mypath
cmd echo "success..."
cmd /bin/bash
 
------
新建dockerfile文件
  • 2、构建

docker build -f dockerfile文件目录 -t 新镜像名字:TAG .

-t : 打标签,仓库名:标签

注意 . ,当前目录。

  • 3、运行

docker run -it mycentos:tag

  • 4、列出镜像的变更历史

docker history 镜像ID

4.3 CMD/ENTRYPOINT 镜像案例

都是指定一个容器启动时要运行的命令。CMD会替换最后运行的参数。ENTRYPOINT不会替换,进行追加(新的命令组合)。

# tocmat 演示  CMD 
CMD ["catalina.sh","run"]
docker run -p 7777:8080 tomcat ls -l
# 这个时候tomcat不会自动启动tomcat

-------------------------------------

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

想看 请求头 curl -i

制作ENTRYPOINT 版本的IP信息查询容器
FORM centos
RUN  yum -y install curl
ENTRYPOINT ["curl","-s","http://ip.cn"]
# onbuild  案例
FORM centos
RUN  yum -y install curl
ENTRYPOINT ["curl","-s","http://ip.cn"]
ONBUILD RUN echo "some one extend me!,I am father image."

定义为 ip_father

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

4.4 自定义镜像Tomcat9

# 1、创建一个目录,级联创建
mkdir -p /dufy/mydockerfile/tomat9
# 2、在上面的目录,创建一个c.txt,为了演示 copy 
touch c.txt
# 3、将JDK和tomcat安装的压缩包拷贝进上一步的目录 
apapche-tomcat-9.tar.gz
jdk-8u171-linux64.tar.gz

# 4、在 /dufy/mydockerfile/tomat9 目录新建Dockerfile文件 
-------------------------------------------------
FROM centos
MAINTAINER dufy@qq.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 yun -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/local/apache-tomcat-9.0.8
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/bin:$CATALINA_BASE/bin
# 容器运行时监控的端口
EXPOSE 8080
# 启动时运行tomcat
# ENTRYPOINT ["/usr/local/apache-tomcat-9.0.8/bin/startup.sh"]
# CMD ["/usr/local/apache-tomcat-9.0.8/bin/startup.sh"]
CMD /usr/local/apache-tomcat-9.0.8/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.8/bin/logs/catalina.out
-------------------------------------------------

# 5、构建.当前Dockerfile 目录
docker build Dockerfile -t image:tag .

# 6、运行 run
docker run -d -p 9080:8080 --name mytomcat9 -v /dufy/mydockerfile/tomcat9/test:/usr/local/apache-tomcat-9.0.8/webapps/test -v /dufy/mydockerfile/tomcat9/logs:/usr/local/apache-tomcat-9.0.8/logs --privileged=true image

# 7、验证

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

4.5 自定义nginx

FROM nginx:1.14-alpine
LABEL 
ENV NGX_DOC_ROOT='/data/web/html' 
ADD entrypoint.sh /bin/
ADD index.html $NGX_DOC_ROOT
EXPOSE 80/tcp
HEALTHCHECK --start-period=3s CMD wget -O - -q http://${IP:-0.0.0.0}:${PORT:-80}/
CMD ["/usr/sbin/nginx","-g","daemon off"]
ENTRYPOINT ["/bin/entrypoint.sh"] # 要使用双引号 ,不能用单引号

entorypoint.sh
#!/bin/sh
cat  > /etc/nginx/conf.d/www.conf << EOF
server {
	server_name ${HONSTNAME};
	lister ${IP:-0.0.0.0}:${PORT:-80};
	root ${NGX_DOC_ROOT:-/usr/share/nginx/html};
}
EOF
exec "$@" #脚本的所有参数
chmod +x entrypoint.sh

index.html

 
 docker run --name names --rm -P -e "PORT=8080" ngxin:v1.0-1
 netstat -tnl

5、小总结

七、Docker常用安装

1、总体步骤

  • 搜索镜像
  • 拉取镜像
  • 查看镜像
  • 启动镜像-成为容器
  • 停止容器
  • 移除容器
  • 删除镜像

2、安装Tomcat

3、安装Mysql

(1)、从docker hub上面查找mysql镜像

(2)、从docker hub上 拉取 mysql镜像到本地

(3)、运行mysql镜像,启动一个mysql容器

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

数据备份测试:

docker exec mysql服务容器id sh -c 'exec mysqldump --all-databases -uroot -p"123456"' > /dufy/all-databases.sql

4、安装Redis

(1)、从docker hub 拉取redis镜像到本地,下载tag 3.2

(2)、运行redis镜像创建容器

1、使用镜像
docker run -p 6379:6379 -v /dufy/myredis/data:/data -v /dufy/myredis/conf/redis.conf:/usr/local/etc/redis/redis.conf -d redis:3.2 redis-server /usr/local/etc/redis/redis.conf --appendonly yes

2、在主机/dufy/myredis/conf/redis.conf 目录下新建redis.conf 文件
vim /dufy/myredis/conf/redis.conf/redis.conf

去掉 bind 绑定 主机
3、测试redis-cli连接
docker  exec -it 容器id redis-cli
4、测试持久化文件生成
shutdown ,dicker容器redis停止了

cd  /dufy/myredis/data # 是否有备份文件

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

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

  • 镜像的生成方法
1、前面的Dockerfile ,编写完后 build 

2、从容器创建一个新的镜像,docker commit [options] 容器id  [repository[:tag]] 
-a:提交的镜像作者
-m:提交时候的说明文字

例子:
docker commit -a dufy -m "new tomcat" 容器id myTomcat:1.0

注:commit 需要容器在运行状态。
  • 将本地镜像推送到阿里云
1、本地镜像素材原型
2、阿里云开发者平台 -- http://dev.aliyun.com/search.html
3、创建仓库镜像 
	命名空间
	仓库名称
4、将镜像推送到registry 
	-- 初次进入需要设置密码
	-- 镜像名字要符合aliyun的要求
5、公有云可以查询到
6、查看详情

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

注: 镜像也可以推送到Docker hub上面。

九、Docker 私有Registry

1、 Docker Registry 分类

Registry 用于保存Docker镜像,包括镜像 的 层次结构和元数据。

用户可以自建Registry,也可以使用官方的Docker hub.(此处类似 用户可以使用自建gitlab, 也可以使用github)

分类 说明
Sponsor Registry 第三方的Registry,供客户和Docker社区使用
Mirror Registry 第三方的Registry,只让客户使用
Vendor Registry 由发布Docker 镜像的供应商提供的Registry
Private Registry 通过设有防火墙和额外安全层的私有实体提供的Registry

Docker 拒绝使用http协议。

docker-distribution

2、Registry 安装

yum info docker-registry

yum install docker-registry

rpm -ql docker-distribution

cd /etc/docker/registry 
config.yml # 使用默认配置即可


ss -tnl


docker tag 镜像名:tag  hostname:port/镜像名:tag

docker push hostname:port/镜像名:tag
#报错 默认不支持 http协议

在daemon.json 加上 insecure-registries:["hostname:prot"]

重启Docker 

history

!行数 # 执行历史命名
  
# 查看上传的镜像
cd /var/lib/registry/docker/registry


# 下载上传到私有Registry的镜像

3、构建本地完整的私有仓库 - harbor

vmvare harbor

docker compose

github 有 harbor

lftp mget bye

yum -y install docker-compose 1.7+

十、Docker的系统资源限制及验正

OOME: E代表异常。一旦发生OOME,任何进程都可能被杀死,包括docker daemon在内。为此Docker 特地调整了docker daemon 的OOME优先级,以免它被内核“正法”,但容器的优先级并未调整。

可以限制一个容器可用的内存。


如果需要Docker相关的学习资料和视频,可以关注下方公众号获取。
在这里插入图片描述

发布了299 篇原创文章 · 获赞 1853 · 访问量 152万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 数字20 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览