SpringCloud 整合 Dockerfile 构建镜像（springcloud+docker）

25-01-25 33

针对SpringCloud整合Dockerfile构建镜像和springcloud+docker这两个问题，本篇文章进行了详细的解答，同时本文还将给你拓展(干货)构建镜像之Dockerfile、02.

针对SpringCloud 整合 Dockerfile 构建镜像和springcloud+docker这两个问题，本篇文章进行了详细的解答，同时本文还将给你拓展(干货)构建镜像之Dockerfile、02 . DockerFile构建镜像和Docker仓库、docker - dockerfile构建一个简单的springboot应用镜像、Docker build Dockerfile 构建镜像 - 二等相关知识，希望可以帮助到你。

本文目录一览：

SpringCloud 整合 Dockerfile 构建镜像（springcloud+docker）
(干货)构建镜像之Dockerfile
02 . DockerFile构建镜像和Docker仓库
docker - dockerfile构建一个简单的springboot应用镜像
Docker build Dockerfile 构建镜像 - 二

SpringCloud 整合 Dockerfile 构建镜像（springcloud+docker）

一、新建 springboot 项目 -- 省略

二、在项目的 main 下面新建 docker 文件夹、在该文件夹下面新建 Dockerfile 文件

三、编写 Dockerfile

FROM java:8  //项目依赖的镜像环境
VOLUME /tmp  //目录挂载点
ADD Eureka.jar app.jar
RUN bash -c ''touch /app.jar''
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]
EXPOSE 8761 //暴露的端口

四、在 docker 虚拟机下面新建文件夹用于存放 jar 包和 Dockerfile

五、将该文件拷贝到新建的文件夹下面、切换至该目录、执行 - docker build -t itmuch/docker-eureka:0.0.1 .(0.0.1 为版本、注意后面的。表示当前目录)

六、镜像构建完成后执行 docker images 即可查看镜像是否构建完成

docker@default:~$ docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
itmuch/docker-eureka 0.0.1 967be7faa1ea 27 seconds ago 697MB
java 8 d23bdf5b1b1b 14 months ago 643MB

七、镜像构建完成启动镜像、docker run -d -p 8761:8761 itmuch/docker-eureka:0.0.1

八、通过 docker ps 可查看镜像启动状态

docker@default:~$ docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
a1dde97c6d33 itmuch/docker-eureka:0.0.1 "java -Djava.securit…" 57 seconds ago Up 55 seconds 0.0.0.0:8761->8761/tcp cocky_sammet

或者可以通过浏览器访问 http:// 虚拟机 ip:8761 查看

(干货)构建镜像之Dockerfile

Dockerfile是一个文本文件，记录了镜像构建的所有步骤。

饭提示：学习Dockerfile构建镜像，就是在学习Dockerfile文件构建的命令+shell脚本语句

Dockerfile简单介绍

　　Docker可以使用Dockerfile的内容来自动构建镜像。Dockerfile是一个文件，其中有创建镜像、运行指令等一系列的命令，且每行只支持一个运行命令。

Docker file分为四部分组成：

　　基础镜像信

　　维护者信息

　　镜像操作指令

　　容器启动时执行指令

　　dockerfile指令忽略大小写，建议大写，#作为注释，每行只支持一条指令，指令可以带多个参数。

dockerfile指令有：

　　构建指令：用于构建image，其指定的操作不会在运行image的容器中执行。

　　设置指令：用于设置image的属性，其指定的操作会在运行image的容器中执行。

Dockerfile指令

Dockerfile指令一共有以下种：

1、FROM

　　用来指定基础镜像，然后通过在基础镜像上构建新的镜像，基础镜像一般有远程或本地仓库。并且Dockerfile文件第一行必须的FROM指令，如果一个Dockerfile需要创建多个镜像，可以使用多个FROM指令。

#具体使用用法如下：

　　FROM < image_name > #默认是latest版本

　　FROM <image:version> #指定版本

eg：	FROM mysql:5.6

2、MAINTAINER

　　指定镜像的创建者信息

#具体使用法如下：

　　MAINTAINER < name >

eg：	MAINTAINER fanfan

3、RUN

　　运行所有基础镜像能支持的命令，同样也可以使用多条RUN指令，可以使用\来换行

#具体使用法如下：

　备注：# 由shell启动，Linux默认为`/bin/sh -c`，Windows默认为`cmd /S /C`

　　RUN < command > #shell启动

　　RUN ["executable", "param1", "param2" ... ] (exec form)

eg：	RUN yum -y update
	RUN ["/etc/execfile", "arg1", "arg1"]

4、CMD

　　用于容器启动时的指定操作，它可以是命令，也可以是脚本，但只执行一次，如果有多个，默认只会执行最后一个。

#具体使用法如下：

　　CMD [“executable” ,”Param1”, “param2”]使用exec执行，推荐

　　CMD command param1 param2，在/bin/sh上执行

　　CMD [“Param1”, “param2”] 提供给ENTRYPOINT做默认参数。

eg：	CMD echo "This is a test." \| wc - CMD ["/usr/bin/wc","--help"]

5、EXPOSE

　　指定容器的端口映射（容器与物理机），运行容器时加上-p参数指定EXPOSE设置的端口。EXPOSE可以设置多个端口号，相应地运行容器配套多次使用-p参数。可以通过docker port +容器需要映射的端口号和容器ID来参考宿主机的映射端口。

#具体使用法如下：

　　EXPOSE <port> [port1 , port2 ............]

eg：	EXPOSE 80 443 EXPOSE 8080 例如-p 3307:3306将容器内的3306绑定到本机的3307

6、ENV

　　在镜像中用于设置环境变量的，然后RUN命令可以使用此设置的环境变量，在容器启动后也以通过docker inspect查看环境变量，可以通过docker run --env key=value来设置或修改环境变量。

#具体使用法如下：

　　ENV <key> <value>

　　ENV <key>=<value> ...

eg：

ENV JAVA_HOME /usr/local/jdk

ENV myName="John Doe"

myDog=Rex\ The\ Dog \

myCat=fluffy

等同于

ENV myName John Doe

ENV myDog Rex The Dog

ENV myCat fluffy

7、ADD

　　(1)、复制指定的源文件、目录、URL到容器的指定目录中。所有拷贝到container中的文件和文件夹权限为0755，uid和gid为0。

　　(2)、如果源是一个目录，那么会将该目录下的所有文件添加到container中，不包括目录；

　　(3)、如果源文件是可识别的压缩格式，则docker会帮忙解压缩（注意压缩格式）；

　　　　identity, gzip, bzip2，xz，tar.gz，tgz等类型的文件将被添加tar -x命令，进行解压。

　　(4)、如果源是文件且目标目录中不使用斜杠结束，则会将目标目录视为文件，源的内容会写入目标目录；饭：可以理解成目标目录变为文件了。

　　(5)、如果源是文件且目标目录中使用斜杠结束，则会源文件拷贝到目标目录下。

#具体使用法如下：

　　ADD <源> <目标>

eg：	ADD hom* /mydir/ # 添加所有以"hom"开头的文件 ADD hom?.txt /mydir/ # ? 替代一个单字符,例如："home.txt" ADD test relativeDir/ # 添加 "test" 到 `WORKDIR`/relativeDir/ ADD test /absoluteDir/ # 添加 "test" 到 /absoluteDir/ ADD test /absoluteDir # 添加 "test" 到 / 下，并重命名为absoluteDir

8、COPY（同ADD，只是不会解压文件）

　　复制本地主机的源（默认为Dockerfile所在的目录）到容器中的目标中，目标路径不存在时会自动创建。

#具体使用法如下：

　　COPY <源> <目标>

　　COPY web/index.html /var/web/

　　路径必须是绝对路径，如果不存在，会自动创建对应目录

　　路径必须是Dockerfile 所在路径的相对路径

　　如果是一个目录，只会复制目录下的内容，而目录本身则不会被复制

9、ENTRYPOINT

　　指定容器启动后执行的命令，多行只执行最后一行。并且不可被docker run提供的参数覆盖。

#具体使用法如下：

　　ENTRYPOINT "command" "param1" "param2" (shell内部命令)

　　ENTRYPOINT ["executable", "param1", "param2"] (可执行文件, 优先)

eg：	FROM ubuntu ENTRYPOINT ["top", "-b"] CMD ["-c"] 当启动容器后，你将直接看到相当于运行了top -b -c 要进一步查看，你可以直接使用命令docker exec -it test ps aux 相当于使用了docker exec top -b -it test ps aux

10、VOLUME

　　创建一个可以从本地主机或其它容器挂载的挂载点，一般用于存放数据。与docker run -v也可以实现此功能。

　　例如-v ~/opt/data/mysql:/var/lib/mysql将本机的~/opt/data/mysql和容器内的/var/lib/mysql做持久化关联

　　容器启动时会加载，容器关闭后会回写。

#具体使用法如下：

　　VOLUME [directory_name]

eg:	VOLUME ["/data"] VOLUME ["/var/www", "/var/log/apache2", "/etc/apache2"]

11、USER

　　指定容器运行时使用的用户或UID，后面RUN、CMD、ENTRYPIONT都会使用此用户来运行命令。

#具体使用法如下：

　　USER [username/uid]

eg:	USER 123 或 USER git

12、WORKDIR

　　指定RUN、CMD、ENTRYPIONT指定的命令的运行目录。可以使用多个WORKDIR指令，后续参数如果是相对路径，则会基于之前的命令指定的路径。如：WORKDIR /data　WORKDIR work。最终的路径就是/data/work。path路径也可以是环境变量。

#具体使用方法如下：

　　WORKDIR [path]

eg:	WORKDIR /a (这时工作目录为/a) WORKDIR b (这时工作目录为/a/b) WORKDIR c (这时工作目录为/a/b/c)

13、ONBUILD

　　配置当前所创建的镜像作为其它新创建镜像的基础镜像时，所执行的操作指令。就是,这个镜像创建后，如果其它镜像以这个镜像为基础，会先执行这个镜像的ONBUILD命令。

#具体使用法如下：

　　ONBUILD [INSTRUCTION]

14、LABEL

　　给镜像添加信息。使用docker inspect可查看镜像的相关信息

　　LABEL "com.example.vendor"="ACME Incorporated"
　　LABEL com.example.label-with-value="foo"
　　LABEL version="1.0"
　　LABEL description="This text illustrates \
　　that label-values can span multiple lines."

当你在命令行执行docker inspect name时，会发现时key velue键值对类型的。

15、ARG

　　由外部启动时必须传入的参数，在容器启动时用--build-arg传递参数

　　指定于外界交互的端口，在容器启动时用-p传递参数

　　例如--build-arg CONT_IMG_VER=v2.0.1

eg:	FROM ubuntu ARG CONT_IMG_VER ENV CONT_IMG_VER ${CONT_IMG_VER:-v1.0.0} RUN echo $CONT_IMG_VER

　　有些默认参数，无需指定，也不用使用``传递，可直接传参

　　HTTP_PROXY

　　http_proxy

　　HTTPS_PROXY

　　https_proxy

　　FTP_PROXY

　　ftp_proxy

　　NO_PROXY

　　no_proxy

02 . DockerFile构建镜像和Docker仓库

为什么用DockerFile

Dockerfile 是一个用来构建镜像的文本文件，文本内容包含了一条条构建镜像所需的指令和说明。

说dockerfile之前我们先说一下dockercommit

利用commit理解镜像构成

注意： docker commit 命令除了学习之外，还有一些特殊的应用场合，比如被入侵后保存现场等。但是，不要使用 docker commit 定制镜像，定制镜像应该使用 Dockerfile 来完成

镜像是容器的基础，每次执行 docker run 的时候都会指定哪个镜像作为容器运行的基础。

我们之前所使用的镜像都是docker hub等网站上的，直接使用这些镜像可以满足一定的需求，而当这些镜像无法直接满足需求时候，我们需要定制这些镜像.之前有说过，镜像是多层存储，每一层是在前一层的基础上进行的修改，而容器也是多层存储，是在以镜像为基础层，在其基础上加一层作为容器运行时的存储层.

定制一个Web服务器

docker pull daocloud.io/library/Nginx

docker run --name webserver -d -p 80:80 daocloud.io/library/Nginx
# 我们访问这个web服务，会看到Nginx的默认欢迎界面,假如我不喜欢这个界面，想看到欢迎docker的文字，可以exec
curl 119.3.255.91
<!DOCTYPE html>
<html>
<head>
<title>Welcome to Nginx!</title>

docker exec -it webserver bash
root@6e63ab0d5109:/# echo ''<h1>Hello,Docker!</h1>''> /usr/share/Nginx/html/index.html 
root@6e63ab0d5109:/# exit
exit

# 我们在访问时候就发现内容改变了
curl 119.3.255.91
<h1>Hello,Docker!</h1>
# 我们修改了容器的文件，就是改动了容器的存储层，我们可以通过docker diff命令看到具体变动
docker diff webserver
C /root
A /root/.bash_history
C /run
A /run/Nginx.pid
C /var
C /var/cache
C /var/cache/Nginx
A /var/cache/Nginx/fastcgi_temp
A /var/cache/Nginx/proxy_temp
A /var/cache/Nginx/scgi_temp
A /var/cache/Nginx/uwsgi_temp
A /var/cache/Nginx/client_temp
C /usr
C /usr/share
C /usr/share/Nginx
C /usr/share/Nginx/html
C /usr/share/Nginx/html/index.html

现在我们定制好了变化，我们希望将其保存下来形成镜像.

要知道，当我们运行一个容器的时候（如果不使用卷的话），我们做的任何文件修改都会被记录于容器存储层里。而 Docker 提供了一个 docker commit 命令，可以将容器的存储层保存下来成为镜像。换句话说，就是在原有镜像的基础上，再叠加上容器的存储层，并构成新的镜像。以后我们运行这个新镜像的时候，就会拥有原有容器最后的文件变化(类似于虚拟机的快照)。

docker commit 的语法格式为:
docker commit  [选项] <容器ID或容器名> [<仓库名>[:<标签>]]
# 我们可以用下面的命令将容器保存为镜像
docker commit -a="youmen <18621048481@163.com>" -m="edited Nginx Default page" webserver Nginx:v2
* -m 提交的描述信息   
* -a 指定镜像作者   
* webserver为你要给那个容器做成镜像的那个容器名字或者ID
* Nginx:v2是形成的新镜像名

# 接下来我们基于这个创建好的新镜像再启动一个容器.
docker run --name web2 -d -p 81:80 Nginx:v2
curl `cat ip.txt`:81 
<h1>Hello,Docker!</h1>
# 就这样，我们完成了一次基于容器构建定制镜像的操作.

慎用docker commit

使用 docker commit 命令虽然可以比较直观的帮助理解镜像分层存储的概念，但是实际环境中并不会这样使用。

首先，如果仔细观察之前的 docker diff webserver 的结果，你会发现除了真正想要修改的 /usr/share/Nginx/html/index.html 文件外，由于命令的执行，还有很多文件被改动或添加了。这还仅仅是最简单的操作，如果是安装软件包、编译构建，那会有大量的无关内容被添加进来，如果不小心清理，将会导致镜像极为臃肿。

此外，使用 docker commit 意味着所有对镜像的操作都是黑箱操作，生成的镜像也被称为黑箱镜像，换句话说，就是除了制作镜像的人知道执行过什么命令、怎么生成的镜像，别人根本无从得知。而且，即使是这个制作镜像的人，过一段时间后也无法记清具体在操作的。虽然 docker diff 或许可以告诉得到一些线索，但是远远不到可以确保生成一致镜像的地步。这种黑箱镜像的维护工作是非常痛苦的。

而且，回顾之前提及的镜像所使用的分层存储的概念，除当前层外，之前的每一层都是不会发生改变的，换句话说，任何修改的结果仅仅是在当前层进行标记、添加、修改，而不会改动上一层。如果使用 docker commit 制作镜像，以及后期修改的话，每一次修改都会让镜像更加臃肿一次，所删除的上一层的东西并不会丢失，会一直如影随形的跟着这个镜像，即使根本无法访问到。这会让镜像更加臃肿.

使用Dockerfile定制镜像

从刚才的 docker commit 的学习中，我们可以了解到，镜像的定制实际上就是定制每一层所添加的配置、文件。如果我们可以把每一层修改、安装、构建、操作的命令都写入一个脚本，用这个脚本来构建、定制镜像，那么之前提及的无法重复的问题、镜像构建透明性的问题、体积的问题就都会解决。这个脚本就是 Dockerfile。

Dockerfile 是一个文本文件，其内包含了一条条的指令(Instruction)，每一条指令构建一层，因此每一条指令的内容，就是描述该层应当如何构建。

还以之前定制 Nginx 镜像为例，这次我们使用 Dockerfile 来定制。

在一个空白目录中，建立一个文本文件，并命名为 Dockerfile ：

cat DockerFile
mkdir myNginx
cd myNginx
vim Dockerfile
FROM Nginx
RUN echo ''<h1>Hello,Docker!</h1>'' > /usr/share/Nginx/html/index.html

FROM指定基础镜像

FROM为指定基础镜像,我们定制镜像，肯定要以一个镜像为基础，在其上做定制，而FROM就是指定基础镜像，因此一个Dockerfile中FROM是必备的命令，并且必须是第一条指令.

在Docker Store上有非常多高质量的官方镜像，有可以直接拿来使用的服务类镜像，如Nginx,redis,MysqL,mongo,tomcat等，也有方便开发、构建、运行各种语言的镜像，如node,openjdk,python,ruby,golang等，可以在其中寻找一个最符合我们的镜像为基础镜像进行定制.

如果还没有找到对应服务的镜像，官方镜像中提供了一些更为基础的操作系统镜像，如ubuntu,debian,centos,fedora,alpine等，这些操作系统的软件库为我们提供了更广阔的扩展空间.

除了选择现有镜像为基础镜像外，Docker 还存在一个特殊的镜像，名为 scratch 。这个镜像是虚拟的概念，并不实际存在，它表示一个空白的镜像。

如果你以 scratch 为基础镜像的话，意味着你不以任何镜像为基础，接下来所写的指令将作为镜像第一层开始存在。不以任何系统为基础，直接将可执行文件复制进镜像的做法并不罕见，比如 swarm 、 coreos/etcd 。对于 Linux 下静态编译的程序来说，并不需要有操作系统提供运行时支持，所需的一切库都已经在可执行文件里了，因此直接 FROM scratch 会让镜像体积更加小巧。使用 Go 语言开发的应用很多会使用这种方式来制作镜像，这也是为什么有人认为 Go 是特别适合容器微服务架构的语言的原因之一。

RUN 执行命令

RUN 指令是用来执行命令行命令的。由于命令行的强大能力， RUN 指令在定制镜像时是最常用的指令之一。其格式有两种：

shell 格式： RUN <命令> ，就像直接在命令行中输入的命令一样。刚才写的 Dockerfile 中的 RUN 指令就是这种格式。

RUN echo ''<h1>Hello,Docker!</h1>'' > /usr/share/Nginx/html/index.html

exec 格式： RUN ["可执行文件","参数1","参数2"] ，这更像是函数调用中的格式。既然 RUN 就像 Shell 脚本一样可以执行命令，那么我们是否就可以像 Shell 脚本一样把每个命令对应一个 RUN 呢？比如这样：

cat Dockerfile
FROM debian:jessie 

RUN apt-get update 
RUN apt-get install -y gcc libc6-dev make 
RUN wget -O redis.tar.gz "http://download.redis.io/releases/redis-3.2.5.tar.gz" 
RUN mkdir -p /usr/src/redis RUN tar -xzf redis.tar.gz -C /usr/src/redis --strip-components=1 
RUN make -C /usr/src/redis 
RUN make -C /usr/src/redis install

之前说过，Dockerfile 中每一个指令都会建立一层， RUN 也不例外。每一个 RUN 的行为，就和刚才我们手工建立镜像的过程一样：新建立一层，在其上执行这些命令，执行结束后， commit 这一层的修改，构成新的镜像。

而上面的这种写法，创建了 7 层镜像。这是完全没有意义的，而且很多运行时不需要的东西，都被装进了镜像里，比如编译环境、更新的软件包等等。结果就是产生非常臃肿、非常多层的镜像，不仅仅增加了构建部署的时间，也很容易出错。这是很多初学 Docker 的人常犯的一个错误。

Union FS 是有最大层数限制的，比如 AUFS，曾经是最大不得超过 42 层，现在是不得超过 127 层。因此上面Dockerfile可以这样写:

cat DockerFile
FROM debian:jessie 
RUN buildDeps=''gcc libc6-dev make'' \ 
&& apt-get update \ && apt-get install -y $buildDeps \ 
&& wget -O redis.tar.gz "http://download.redis.io/releases/redis-3.2.5.tar.gz" \ 
&& mkdir -p /usr/src/redis \ && tar -xzf redis.tar.gz -C /usr/src/redis --strip-components=1 \ 
&& make -C /usr/src/redis \ 
&& make -C /usr/src/redis install \ 
&& rm -rf /var/lib/apt/lists/* \ && rm redis.tar.gz \
&& rm -r /usr/src/redis \ 
&& apt-get purge -y --auto-remove $buildDeps

首先，之前所有的命令只有一个目的，就是编译、安装 redis 可执行文件。因此没有必要建立很多层，这只是一层的事情。因此，这里没有使用很多个 RUN 对一一对应不同的命令，而是仅仅使用一个 RUN 指令，并使用 && 将各个所需命令串联起来。将之前的 7 层，简化为了 1 层。在撰写 Dockerfile 的时候，要经常提醒自己，这并不是在写 Shell 脚本，而是在定义每一层该如何构建。

并且，这里为了格式化还进行了换行。Dockerfile 支持 Shell 类的行尾添加 \ 的命令换行方式，以及行首 # 进行注释的格式。良好的格式，比如换行、缩进、注释等，会让维护、排障更为容易，这是一个比较好的习惯。

此外，还可以看到这一组命令的最后添加了清理工作的命令，删除了为了编译构建所需要的软件，清理了所有下载、展开的文件，并且还清理了 apt 缓存文件。这是很重要的一步，我们之前说过，镜像是多层存储，每一层的东西并不会在下一层被删除，会一直跟随着镜像。因此镜像构建时，一定要确保每一层只添加真正需要添加的东西，任何无关的东西都应该清理掉。

很多人初学 Docker 制作出了很臃肿的镜像的原因之一，就是忘记了每一层构建的最后一定要清理掉无关文件。

构建镜像

在之前Dockerfile文件所在目录执行

cat DockerFile
mkdir myNginx
cd myNginx
# 我们继续编辑一下DockerFile
vim DockerFile
FROM Nginx
RUN echo ''<h1>Hello,Docker!</h1>'' > /usr/share/Nginx/html/index.html


docker build -t Nginx:v3 .
# 最后的.表示本文执行的上下文路径
Sending build context to Docker daemon  2.048kB
Step 1/2 : FROM Nginx
 ---> 231d40e811cd
Step 2/2 : RUN echo ''<h1>Hello,Docker!</h1>'' > /usr/share/Nginx/html/index.html
 ---> Running in 3a439666c4da
Removing intermediate container 3a439666c4da
 ---> 78990dc4a6a6
Successfully built 78990dc4a6a6
Successfully tagged Nginx:v3

从命令的输出结果中，我们可以清晰的看到镜像的构建过程。在 Step 2 中，如同我们之前所说的那样， RUN 指令启动了一个容器231d40e811cd，执行了所要求的命令，并最后提交了这一层 3a439666c4da ，随后删除了所用到的这个容器78990dc4a6a6。

docker build [选项] <上下文路径/URL/->

构建成功后我们可以跟Nginx:v2那样运行这个镜像，结果一样.

这只是默认行为，实际上 Dockerfile 的文件名并不要求必须为 Dockerfile ，而且并不要求必须位于上下文目录中，比如可以用 -f ../Dockerfile.PHP 参数指定某个文件作为 Dockerfile

上下文路径

是指在docker构建镜像,有时候想要使用本机的文件(比如复制),docker build命令知道这个路径后,会将这个路径下所有内容打包.

由于 docker 的运行模式是 C/S。我们本机是 C，docker 引擎是 S。实际的构建过程是在 docker 引擎下完成的，所以这个时候无法用到我们本机的文件。这就需要把我们本机的指定目录下的文件一起打包提供给 docker 引擎使用。

如果未说明最后一个参数，那么默认上下文路径就是 Dockerfile 所在的位置。

注意：上下文路径下不要放无用的文件，因为会一起打包发送给 docker 引擎，如果文件过多会造成过程缓慢。

Docker build的用法

直接用git repo 进行构建

yum -y install git
docker build https://github.com/twang2218/gitlab-ce-zh.git:8.14 docker 
build https://github.com/twang2218/gitlab-ce-zh.git\#:8.14 
Sending build context to Docker daemon 2.048 kB Step 1 : 
FROM gitlab/gitlab-ce:8.14.0-ce.0 8.14.0-ce.0: 
Pulling from gitlab/gitlab-ce

这行命令指定了构建所需的Git repo,并且指定默认的master分支，构建目录为/8.14/,然后Docker就会自己去git clone这个项目，切换到指定分支，并进入到指定目录后开始构建.

用给定的tar压缩包构建

docker build http://server/context.tar.gz
# 如果所给出的 URL 不是个 Git repo，而是个 tar 压缩包，那么 Docker 引擎会下载这个包,# 并自动解压缩，以其作为上下文，开始构建。

从标准输入中读取Dockerfile进行构建

docker build - < Dockerfile
or
cat Dockerfile | docker build -

如果标准输入传入的是文本文件，则将其视为 Dockerfile ，并开始构建。这种形式由于直接从标准输入中读取 Dockerfile 的内容，它没有上下文，因此不可以像其他方法那样可以将本地文件 copY 进镜像之类的事情。

从标准输入中读取上下文压缩包进行构建

docker build - < context.tar.gz
# 如果发现标准输入的文件格式是gzip、bzip2、以及xz的话，将会使其为上下文压缩包，直接将其展开，
# 将里面视为上下文，并开始构建.

Dockerfile指令详解

FROM 和 RUN 指令的作用

FROM：定制的镜像都是基于 FROM 的镜像，这里的 Nginx 就是定制需要的基础镜像。后续的操作都是基于 Nginx。

RUN：用于执行后面跟着的命令行命令。有以下俩种格式

shell格式

RUN <命令行命令>
# <命令行命令> 等同于，在终端操作的 shell 命令。

exec格式

RUN ["可执行文件","参数2"]
# 例如：
# RUN ["./test.PHP","dev","offline"] 等价于 RUN ./test.PHP dev offline

注意: Dockerfile的指令是每执行一次都会在docker上新建一层,所以过多无意义的层,会造成镜像膨胀过大,上面提到过,可以用&&符号链接命令,这样执行后,只会创建一层镜像

copY复制文件

# 格式:
# copY <源路径>...<目标路径>
copY ["<源路径1>",..."<目标路径>"]
# 和RUN指令一样，也有两种格式，一种类似于命令行，一种类似于函数调用.
copY指令将从构建上下文目录中<源路径>的文件/目录复制到新的一层的镜像内的<目标路径> 位置，比如.
copY package.json  /usr/src/app/
# <源路径> 可以是多个，甚至可以是通配符，其通配符规则要满足Go的filepath.Match规则，如:
copY  hom* /mydir/
copY hom?.txt  /mydir/
# <目标路径> 可以是容器内的绝对路径，也可以是相对于工作目录的相对路径.工作目录可以 用 workdir 指令来指定).
# 目标路径不需要事先创建，如果目录不存在会在复制文件前先行 创建缺失目录
# 此外，还需要注意一点，使用 copY 指令，源文件的各种元数据都会保留。比如读、写、执 行权限、文件变更时间等.
# 这个特性对于镜像定制很有用。特别是构建相关文件都在使用 Git 进行管理的时候。

ADD

ADD 指令和 copY 的使用格式一致（同样需求下，官方推荐使用 copY）。功能也类似，不同之处如下：

ADD 的优点：在执行 <源文件> 为 tar 压缩文件的话，压缩格式为 gzip,bzip2 以及 xz 的情况下，会自动复制并解压到 <目标路径>。

ADD 的缺点：在不解压的前提下，无法复制 tar 压缩文件。会令镜像构建缓存失效，从而可能会令镜像构建变得比较缓慢。具体是否使用，可以根据是否需要自动解压来决定。

CMD

类似于 RUN 指令，用于运行程序，但二者运行的时间点不同:

CMD 在docker run 时运行。

RUN 是在 docker build。

作用：为启动的容器指定默认要运行的程序，程序运行结束，容器也就结束。CMD 指令指定的程序可被 docker run 命令行参数中指定要运行的程序所覆盖。

注意：如果 Dockerfile 中如果存在多个 CMD 指令，仅最后一个生效。

格式：

CMD <shell 命令> 
CMD ["<可执行文件或命令>","<param1>","<param2>",...] 
CMD ["<param1>",...]  # 该写法是为 ENTRYPOINT 指令指定的程序提供默认参数

ENTRYPOINT

类似于 CMD 指令，但其不会被 docker run 的命令行参数指定的指令所覆盖，而且这些命令行参数会被当作参数送给 ENTRYPOINT 指令指定的程序。

但是,如果运行 docker run 时使用了 --entrypoint 选项，此选项的参数可当作要运行的程序覆盖 ENTRYPOINT 指令指定的程序。

优点：在执行 docker run 的时候可以指定 ENTRYPOINT 运行所需的参数。

注意：如果 Dockerfile 中如果存在多个 ENTRYPOINT 指令，仅最后一个生效。

格式：

ENTRYPOINT ["<executeable>",...]

可以搭配 CMD 命令使用：一般是变参才会使用 CMD ，这里的 CMD 等于是在给 ENTRYPOINT 传参，以下示例会提到。

示例：

假设已通过 Dockerfile 构建了 Nginx:test 镜像：

FROM Nginx

ENTRYPOINT ["Nginx","-c"] # 定参
CMD ["/etc/Nginx/Nginx.conf"] # 变参

不传参运行

docker run  Nginx:test

# 容器内会默认运行以下命令,启动主进程
Nginx -c etc/Nginx/Nginx.conf

传参运行

docker run  Nginx:test -c /etc/Nginx/new.conf

# 容器内会默认运行以下命令，启动主进程(/etc/Nginx/new.conf:假设容器内已有此文件)

ENV

设置环境变量，定义了环境变量，那么在后续的指令中，就可以使用这个环境变量。

格式：

ENV <key> <value>
ENV <key1>=<value1> <key2>=<value2>...

以下示例设置 NODE_VERSION = 7.2.0 ，在后续的指令中可以通过 $NODE_VERSION 引用：

ENV NODE_VERSION 7.2.0

RUN curl -SLO "https://nodejs.org/dist/v$NODE_VERSION/node-v$NODE_VERSION-linux-x64.tar.xz" \
  && curl -SLO "https://nodejs.org/dist/v$NODE_VERSION/SHASUMS256.txt.asc"

ARG

构建参数，与 ENV 作用一至。不过作用域不一样。ARG 设置的环境变量仅对 Dockerfile 内有效，也就是说只有 docker build 的过程中有效，构建好的镜像内不存在此环境变量。

构建命令 docker build 中可以用 --build-arg <参数名>=<值> 来覆盖。

格式：

ARG <参数名>[=<默认值>]

VOLUME

定义匿名数据卷。在启动容器时忘记挂载数据卷，会自动挂载到匿名卷。

作用：

避免重要的数据，因容器重启而丢失，这是非常致命的。

避免容器不断变大。

格式

VOLUME ["<路径1>","<路径2>"...]
VOLUME <路径>
# 在启动容器 docker run 的时候，我们可以通过 -v 参数修改挂载点。

EXPOSE

仅仅只是声明端口。

作用：

帮助镜像使用者理解这个镜像服务的守护端口，以方便配置映射。

在运行时使用随机端口映射时，也就是 docker run -P 时，会自动随机映射 EXPOSE 的端口。

格式：

EXPOSE <端口1> [<端口2>...]

workdir

指定工作目录。用 workdir 指定的工作目录，会在构建镜像的每一层中都存在。（workdir 指定的工作目录，必须是提前创建好的）。

docker build 构建镜像过程中的，每一个 RUN 命令都是新建的一层。只有通过 workdir 创建的目录才会一直存在。

格式：

workdir <工作目录路径>

USER

用于指定执行后续命令的用户和用户组，这边只是切换后续命令执行的用户（用户和用户组必须提前已经存在）。

格式：

USER <用户名>[:<用户组>]

HEALTHCHECK

用于指定某个程序或者指令来监控 docker 容器服务的运行状态。

格式：

# HEALTHCHECK [选项] CMD <命令>：设置检查容器健康状况的命令
# HEALTHCHECK NONE：如果基础镜像有健康检查指令，使用这行可以屏蔽掉其健康检查指令

# HEALTHCHECK [选项] CMD <命令> : 这边 CMD 后面跟随的命令使用，可以参考 CMD 的用法。

ONBUILD

用于延迟构建命令的执行。简单的说，就是 Dockerfile 里用 ONBUILD 指定的命令，在本次构建镜像的过程中不会执行（假设镜像为 test-build）。当有新的 Dockerfile 使用了之前构建的镜像 FROM test-build ，这是执行新镜像的 Dockerfile 构建时候，会执行 test-build 的 Dockerfile 里的 ONBUILD 指定的命令。

格式

ONBUILD <其它指令>

Docker仓库

访问仓库

仓库（Repository）是集中存放镜像的地方

一个容易混淆的概念是注册服务器（ Registry ）。实际上注册服务器是管理仓库的具体服务器，每个服务器上可以有多个仓库，而每个仓库下面有多个镜像。从这方面来说，仓库可以被认为是一个具体的项目或目录。例如对于仓库地址 dl.dockerpool.com/ubuntu 来说， dl.dockerpool.com 是注册服务器地址， Ubuntu 是仓库名。

大部分时候，并不需要这两者的概念.

Docker Hub

目前Docker官方维护了一个公共仓库Docker Hub,其中包括了数量超过15000的镜像，大部分需求都可以通过在Docker Hub中直接下载镜像来实现.

注册，可以直接在https://cloud.docker.com免费注册一个Docker Hub账号.

登陆

可以通过执行docker login 命令交互式的输入用户名及密码来完成命令行界面登陆Docker Hub。docker logout退出登陆.

拉取镜像

可以通过docker search命令来查找官方仓库中的镜像，并利用docker pull命令将他下载到本地.

docker search centos
NAME                 DESCRIPTION                        STARS            OFFICIAL    AUTOMATED
centos               The official build of CentOS.                         5717          [OK]    
ansible/centos7-ansible     Ansible on Centos7                              126        [OK]
jdeathe/centos-ssh       OpenSSH / Supervisor / EPEL/IUS/SCL Repos - …      114        [OK]
consol/centos-xfce-vnc    Centos container with "headless" VNC session…     101       [OK]

可以看到返回了很多包含关键字的镜像，其中包括镜像名字、描述、收藏数（表示该镜像的受关注程度），是否官方创建、是否自动创建.

根据是否是官方提供，可将镜像资源分为两类.

一种是类似centos这样的镜像,被称为基础镜像或根镜像，这些基础镜像由Docker公司创建、验证、支持、提供。这样的镜像往往使用单个单词作为名字.

还有一种类型，比如tianon/centos镜像，他是由Docker的用户创建并维护的，往往带有用户名称前缀，可以通过前缀username/来指定某个用户提供的镜像，比如tianon用户.

另外，在查找的时候可以通过--filter=stars=N参数可以显示收藏数量为N以上的镜像.

推送镜像

用户可以在登陆后通过docker push命令将自己的镜像推送到Docker Hub。

以下命令的flyingdreams请替换为你的Docker账号用户名.

docker login		# 登陆自己的账号
docker tag Nginx:v2 flyingdreams/Nginx:v2
docker push flyingdreams/Nginx:v2

自动创建

自动创建（Automated Builds）功能对于需要经常升级镜像内程序来说，十分方便.

有时候，用户创建了镜像，安装了某个软件，如果程序发布新版本则需要手动更新镜像.

而自动创建允许用户Docker Hub指定跟踪一个目标网站（目前支持GitHub或BitBucket）上的项目，一旦项目发生新的提交或者创建新的标签（tag）,Docker Hub会自动构建镜像并推送到Docker Hub中.

要配置自动创建，包括如下的步骤:

# 1. 创建并登陆Docker Hub，以及目标网站:
# 2. 在目标网站中连接账户到Docker Hub;
# 3. 在Docker Hub中配置一个自动连接:
# 4. 选取一个目标网站中的项目（需要含Dockerfile）和分支
# 5. 指定Dockerfile的位置，并提交创建.

# 之后，可以在Docker Hub的自动创建页面中跟踪每次创建的状态.

私有仓库docker-registry

有时候使用Docker Hub这样的公共仓库可能不安全，用户可以创建一个本地仓库供私人使用.

通过官方提供的私有仓库镜像registry来搭建私有仓库。通过 humpback 快速搭建轻量级的Docker容器云管理平台

此外还有像Harbor，rancher等私有仓库。

安装运行docker-registry

# 自定义存储位置$HOME,一般是root
docker run -d \
  -p 5000:5000 \
  --restart=always \
  --name registry \
  -v $HOME/_docker/registry:/var/lib/registry \
  registry:2.6
# 从官方仓库拉去一个镜像
docker  pull Nginx
docker tag Nginx:latest 47.92.24.137:5000/test_Nginx:latest

# 在推送到的时候报错误，默认是使用`https`提交，这个搭建的默认使用的是 `http`，解决方法两个：

# 创建一个https映射
# 将仓库地址加入到不安全的仓库列表中

# 我们使用第二种方法，加入到不安全的仓库列表中，修改docker配置文件
# `vi /etc/docker/daemon.json` 添加 `insecure-registries`配置信息
docker push 47.92.24.137:5000/test_Nginx:latest 
The push refers to repository [47.92.24.137:5000/test_Nginx]
Get https://47.92.24.137:5000/v2/: http: server gave HTTP response to HTTPS client

cat /etc/docker/daemon.json 
{
"insecure-registries":[ 
    "47.92.24.137:5000"
  ]
}
systemctl stop docker
systemctl daemon-reload
systemctl start docker

# 推送到私有仓库中
docker push 47.92.24.137:5000/test_Nginx:latest 

ls /root/_docker/registry/docker/registry/v2/repositories/test_Nginx/
_layers  _manifests  _uploads

安装运行harbor（http方式）

Harbor(港口,港湾)是一个用于存储和分发Docker镜像的企业级Registry服务器

Harbor 可帮助用户迅速搭建企业级的 Registry 服务,它提供了管理图形界面,基于角色的访问控制 ( Role Based Access Control),镜像远程复制 (同步),AD/LDAP 集成,以及审计日志等企业用户需求的功能,同时还原生支持中文,深受中国用户的喜爱;

Harbor相比于Registry有以下优势

提供分层传输机制,优化网络传输,Docker镜像是分层的,而如果每次传输都使用全量文件,显然效率不是很高,必须提供识别分层传输的机制,以层的UUID为标识,确认传输的对象.

提供WEB界面,优化用户体验,只用镜像的名字来进行上传下载显然很不方便,需要有一个用户界面可以支持登录,搜索功能,包括区分公有,私有镜像

支持水平扩展集群,当有用户对镜像的上传下载操作集中在某服务器,需要对相应的访问压力工作分解.

良好的安全机制,企业中的开发团队有很多不同的职位,对于不通的职位人员,分配不通的权限,具有更好的安全性.

安装harbor

是 VMware 公司开源了企业级 Registry 项目,其的目标是帮助用户迅速搭建一个企业级的 Docker registry 服务。

由于 Harbor 是基于 Docker Registry V2 版本，所以 docker 版本必须 >=1.10.0 docker-compose >=1.6.0

下载最新版 Docker Compose
curl -L "https://github.com/docker/compose/releases/download/1.22.0/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

下载最新版Docker Harbor
wget https://github.com/goharbor/harbor/releases/download/v1.10.0-rc1/harbor-offline-installer-v1.10.0-rc1.tgz

# 对二进制文件应用可执行权限：
sudo chmod +x /usr/local/bin/docker-compose
# 测试是否安装成功
docker-compose --version
# 按照上面给的docker harbor地址，下载离线安装包
tar xvf harbor-offline-installer-v1.8.1.tgz -C  /usr/local/
vim  /usr/local/harbor/harbor.yml
hostname: 47.92.24.137

# 运行安装脚本
./install.sh 
[Step 0]: checking installation environment ...
Note: docker version: 19.03.4
Note: docker-compose version: 1.22.0
[Step 1]: loading Harbor images ...
Loaded image: goharbor/harbor-core:v1.8.1
Loaded image: goharbor/harbor-registryctl:v1.8.1
Loaded image: goharbor/redis-photon:v1.8.1
Loaded image: goharbor/notary-server-photon:v0.6.1-v1.8.1
Loaded image: goharbor/chartmuseum-photon:v0.8.1-v1.8.1
Loaded image: goharbor/harbor-db:v1.8.1
Loaded image: goharbor/harbor-jobservice:v1.8.1
Loaded image: goharbor/Nginx-photon:v1.8.1
Loaded image: goharbor/registry-photon:v2.7.1-patch-2819-v1.8.1
Loaded image: goharbor/harbor-migrator:v1.8.1
Loaded image: goharbor/prepare:v1.8.1
Loaded image: goharbor/harbor-portal:v1.8.1
Loaded image: goharbor/harbor-log:v1.8.1
Loaded image: goharbor/notary-signer-photon:v0.6.1-v1.8.1
Loaded image: goharbor/clair-photon:v2.0.8-v1.8.1
[Step 2]: preparing environment ...
prepare base dir is set to /usr/local/harbor
Generated configuration file: /config/log/logrotate.conf
Generated configuration file: /config/Nginx/Nginx.conf
Generated configuration file: /config/core/env
Generated configuration file: /config/core/app.conf
Generated configuration file: /config/registry/config.yml
Generated configuration file: /config/registryctl/env
Generated configuration file: /config/db/env
Generated configuration file: /config/jobservice/env
Generated configuration file: /config/jobservice/config.yml
Generated and saved secret to file: /secret/keys/secretkey
Generated certificate,key file:/secret/core/private_key.pem,cert file:/secret/registry/root.crt
Generated configuration file: /compose_location/docker-compose.yml
Clean up the input dir
[Step 3]: starting Harbor ...
✔ ----Harbor has been installed and started successfully.----
Now you should be able to visit the admin portal at http://47.92.24.137. 
For more details,please visit https://github.com/goharbor/harbor

接下来我们可以直接浏览器访问配置文件定义的IP或者域名加端口

修改harbor端口

# 因为harbor默认端口是80，而大多数时候是不希望使用80端口，修改方法如下
# vim harbor.yml
# 找到port选项修改端口，然后执行./install 就会使用配置文件端口

# 还有一种情况就是更改已有harbor的配置
vim docker-compose.yml
    dns_search: .
    ports:
      - 99:80

auth:
  token:
    issuer: harbor-token-issuer
    realm: http://47.92.24.137:99/service/token
    rootcertbundle: /etc/registry/root.crt
    service: harbor-registry

docker-compose down -v
docker-compose up -d

使用harbor

为了体现出效果，建议使用非harbor的另一台机器

# 镜像推送
docker login 47.92.24.137:99 -u admin -p youmen
vim  /etc/docker/daemon.jsonyml
{
  "insecure-registries":["47.92.24.137"]
}
systemctl daemon-reload
systemctl restart docker
# 因为docker默认使用的是https协议，而搭建harbor是http提供服务的，
# 所以要配置可信任,或者强制docker login和docker push 走http的80端口，而不是443端口.
docker tag Nginx:latest 47.92.24.137:99/library/Nginx:latest
docker push 47.92.24.137:99/library/Nginx:latest

安装harbor（https方式）

DNS服务器安装dnsmasq

yum -y install dnsmasq
mkdir -p /data/ssl && cd /data/ssl

vim harbor.cfg
hostname = harbor.youmen.com                 
ui_url_protocol = https                          
db_password = root123   
harbor_admin_password = baiyongjie               
ssl_cert = /usr/local/harbor/cert/harbor.youmen.com.crt 　    
ssl_cert_key = /usr/local/harbor/cert/harbor.youmen.com.key 

# grep -Ev ''#|^$'' harbor.yml 
hostname: harbor.youmen.com     # 本机外网IP或域名，该地址供用户通过UI进行访问，不要使用127.0.0.1
https:                             # 用户访问私仓时使用的协议，默认时http，配置成https
  port: 443                        # https使用的端口
  certificate: /usr/local/harbor/cert/harbor.youmen.com.crt    # 设置证书文件路径
  private_key: /usr/local/harbor/cert/harbor.youmen.com.key    # 设置证书密钥文件路径
harbor_admin_password: youmen   # harbor的管理员账户密码
database:
  password: root123     # 指定MysqL数据库管理员密码
data_volume: /data      # image存储目录
clair: 
  updaters_interval: 12
  http_proxy:
  https_proxy:
  no_proxy: 127.0.0.1,localhost,core,registry
jobservice:
  max_job_workers: 10
chart:
  absolute_url: disabled
log:
  level: info
  rotate_count: 50
  rotate_size: 200M
  location: /var/log/harbor
_version: 1.8.0

生成harbor证书

mkdir /usr/local/harbor/cert/
cd /usr/local/harbor/cert/

#生成根证书
openssl req  -newkey rsa:4096 -nodes -sha256 -keyout ca.key -x509 -days 3650 -out ca.crt -subj "/C=CN/L=ShanghaI/O=harbor/CN=harbor-registry"

#生成一个证书签名,设置访问域名为 harbor.baiyongjie.com
openssl req -newkey rsa:4096 -nodes -sha256 -keyout harbor.youmen.com.key -out server.csr -subj "/C=CN/L=ShanghaI/O=harbor/CN=harbor.youmen.com"

#生成主机证书
openssl x509 -req -days 3650 -in server.csr -CA ca.crt -CAkey ca.key -CAcreateserial  -out harbor.youmen.com.crt

# 接下来执行自动安装脚本即可.
 添加本地解析到hosts
#echo "192.168.1.155 harbor.baiyongjie.com" >> /etc/hosts

#cd /usr/local/harbor
# ./install.sh

官方建议不要在Harbor上启用https,而是将Harbor放置到一个SLB的后边，配置SLB的端口转发进行访问，或者再装一个Nginx，进行Nginx的端口转发.

如果想做一个HA方案的话，可以按照如下方式构建一个（主从模式个人感觉很不靠谱

负载均衡同时还要承担检查的任务，而Redis用于数据的缓存和消息队列的实现，MysqL存储用户信息和仓库信息，云存储用来存储Docker镜像.

总结

以上是小编为你收集整理的02 . DockerFile构建镜像和Docker仓库全部内容。

如果觉得小编网站内容还不错，欢迎将小编网站推荐给好友。

docker - dockerfile构建一个简单的springboot应用镜像

在前面的《docker - 构建一个简单的docker镜像》中，介绍了两种构建镜像的方法，其中，通过dockerfile文件构建镜像是在实际生产中常用的；除此之外，还通过 docker - Dockerfile常用指令和 docker - 常用命令两篇文章介绍了dockerfile的指令和docker的常用命令，接下来，我们将会使用所学的知识构建一个简单的springboot应用。

该springboot应用对外暴露了一个api，对外暴露8080端口，日志文件写在应用当前目录，部分代码以及配置文件如下：

@Slf4j
@SpringBootApplication
@RestController
public class SpringbootDockerApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootDockerApplication.class, args);
    }

    @RequestMapping("/docker")
    public String docker() {
        log.info("access docker home at " + LocalTime.now());
        return "Hello Docker!";
    }
}

application.properties

spring.application.name=springboot-docker
server.port=8080
logging.file=app.log

把jar和dockerfile文件上传到一个springboot-docker目录中

[root@localhost springboot-docker]# ls
Dockerfile  springboot-docker-1.0.jar

Dockerfile：

FROM openjdk:8u181-jdk-alpine
ARG workdir=/app
VOLUME ${workdir}
WORKDIR ${workdir}
ADD springboot-docker-1.0.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","app.jar"]

FROM openjdk:8u181-jdk-alpine ： 从docker仓库中获取基础镜像
ARG workdir=/app ：添加变量，该变量只在当前的dockerfile中有效，如果换成ENV，则在容器中生效。这里需要注意的是，ARG和ENV对哪些指令是起效的，可以参考 docker - Dockerfile常用指令
VOLUME ${workdir} ：把宿主机的目录（该目录可以通过docker inspect dockerName查看）挂载到容器中的/app这个目录，这样可以在宿主机中查看该目录的内容。还有一个很重要的原因，就是数据持久化，如果不挂载，当容器关闭删除后，数据将会跟着被删除。这里因为/app是应用所在的目录，该目录会产生日志等其它内容。
WORKDIR ${workdir} ：指定工作目录，下面的指令操作将在这个指定目录中执行。还有一点是，当通过交互模式的exec命令进入到该容器时，默认当前路径是/app
ADD springboot-docker-1.0.jar app.jar ： 添加文件到WORKDIR
EXPOSE 8080 ： 暴露8080端口，需要通过容器IP和端口访问应用。如果想通过宿主机的IP和端口访问应用，需要在RUN容器的时候绑定。可以参考docker - Dockerfile常用指令的run命令
ENTRYPOINT： 运行容器后执行的第一条命令，这里通过java -jar命令运行应用。

接下通过BUILD命令构建镜像

[root@localhost springboot-docker]# docker build -t springboot-docker:1.0 .

Sending build context to Docker daemon  17.85MB
Step 1/7 : FROM openjdk:8u181-jdk-alpine
 ---> 97bc1352afde
Step 2/7 : ARG workdir=/app
 ---> Using cache
 ---> a3818e8696c2
Step 3/7 : VOLUME ${workdir}
 ---> Using cache
 ---> e2faefe34aa6
Step 4/7 : WORKDIR ${workdir}
 ---> Using cache
 ---> 144b537c1b57
Step 5/7 : ADD springboot-docker-1.0.jar app.jar
 ---> Using cache
 ---> daca849e1012
Step 6/7 : EXPOSE 8080
 ---> Using cache
 ---> 123da0847dd3
Step 7/7 : ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","app.jar"]
 ---> Using cache
 ---> de46a3f96d91
Successfully built de46a3f96d91
Successfully tagged springboot-docker:1.0

查看当前本地仓库的镜像，已经构建springboot-docker:1.0镜像

[root@localhost springboot-docker]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
springboot-docker   1.0                 de46a3f96d91        38 minutes ago      121MB
openjdk             8u181-jdk-alpine    97bc1352afde        5 weeks ago         103MB

运行镜像

docker run -p 8080:8080 -d --name springboot-docker springboot-docker:1.0

通过-p参数，把容器中的8080端口映射到宿主机中的8080端口。--name，给容器起一个名字

可以查看springboot应用的启动情况

docker logs -f springboot-docker

查看容器的运行情况

docker inspect springboot-docker

只看一些关键的信息

"Mounts": [
            {
                "Type": "volume",
                "Name": "90df5c82f11290eddfc86faead12e4a79649672845b2a816e04f868da76851a3",
                "Source": "/var/lib/docker/volumes/90df5c82f11290eddfc86faead12e4a79649672845b2a816e04f868da76851a3/_data",
                "Destination": "/app",
                "Driver": "local",
            }
        ],
"Networks": {
	"bridge": {
		"Gateway": "172.17.0.1",
		"IPAddress": "172.17.0.2",
	}
}

宿主机中的 /var/lib/docker/volumes/90df5c82f11290eddfc86faead12e4a79649672845b2a816e04f868da76851a3/_data 目录挂载到容器的 /app目录

容器的IP地址 172.17.0.2

运行成功后，在宿主机中通过命令访问服务

curl 172.17.0.2:8080/docker

也可以通过宿主机的IP或者localhost访问，因为已经绑定

curl 127.0.0.1:8080/docker

Docker build Dockerfile 构建镜像 - 二

Dockerfile 制作镜像

https://hub.docker.com/  搜索需要镜像；

https://hub.docker.com/_/centos/

官方示例：

centos:6

1、这里把需要文件放置在同一个 centos6 文件夹下

2、下载 centos-6-docker.tar.xz 文件；

wget https://raw.githubusercontent.com/CentOS/sig-cloud-instance-images/da050e2fc6c28d8d72d8bf78c49537247b5ddf76/docker/centos-6-docker.tar.xz

3、创建 Dockerfile 文件 ( D 必须大写)

cat Dockerfile

FROM scratch
MAINTAINER https://github.com/CentOS/sig-cloud-instance-images
ADD centos-6-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="20181208"

RUN yum install openssh-server -y

EXPOSE 22

CMD ["/bin/bash"]

Dockerfile 一些参数：

FROM 指定镜像源
ADD 添加上传文件到容器 / 目录下
RUN 安装执行命令
EXPOSE 开放暴露端口
CMD 执行环境变量

4、build 构建镜像

docker build -t centos6.1  .

-t 镜像命名  
. Dockerfile 当前目录；

5、查看构建的镜像：

centos:7 的 centos-7-docker.tar.xz 可以在这里下载：

https://github.com/CentOS/sig-cloud-instance-images/tree/a77b36c6c55559b0db5bf9e74e61d32ea709a179/docker
wget https://raw.githubusercontent.com/CentOS/sig-cloud-instance-images/a77b36c6c55559b0db5bf9e74e61d32ea709a179/docker/centos-7-docker.tar.xz

centos 7 创建Dockerfile

# cat Dockerfile

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="20181205"

CMD ["/bin/bash"]

6、进入到容器：

# docker exec -it centos6.3 /bin/bash

另一种进入方式：
docker attach centos6.3

7、查看网络

8、宿主机上测试 ssh 远程：

关于SpringCloud 整合 Dockerfile 构建镜像和springcloud+docker的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于(干货)构建镜像之Dockerfile、02 . DockerFile构建镜像和Docker仓库、docker - dockerfile构建一个简单的springboot应用镜像、Docker build Dockerfile 构建镜像 - 二等相关知识的信息别忘了在本站进行查找喔。

本文标签：