Docker 学习笔记 - 进阶三 DockerFile解析及微服务实战_docker教程 github

笔记记录尚硅谷周阳老师的 docker 教程
链接地址： https://www.bilibili.com/video/BV1gr4y1U7CY?p=1

3. Docker File

3.1 概述

Dockerfile是用来构建Docker镜像的文本文件，是由一条条构建镜像所需的指令和参数构成的脚本。

官网位置： https://docs.docker.com/engine/reference/builder/

构建三步骤：

• 编写Dockerfile文件
• docker build命令构建镜像
• docker run依镜像运行容器实例

3.2 DockerFile 构建过程解析

3.2.1 DockerFile 内容基础知识

• (1)：每条保留字指令都必须为大写字母且后面要跟随至少一个参数
• (2)：指令按照从上到下，顺序执行
• (3)：#表示注释
• (4)：每条指令都会创建一个新的镜像层并对镜像进行提交

3.2.2 Docker 执行 DockerFile 的大致流程

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

3.2.3 小总结

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

• Dockerfile是软件的原材料
• Docker镜像是软件的交付品
• Docker容器则可以认为是软件镜像的运行态，也即依照镜像运行的容器实例

Dockerfile面向开发，Docker镜像成为交付标准，Docker容器则涉及部署与运维，三者缺一不可，合力充当Docker体系的基石。

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

3.3 DockerFile常用保留字指令

参考tomcat8的dockerfile入门: https://github.com/docker-library/tomcat
https://github.com/docker-library/tomcat/blob/master/10.0/jdk8/corretto/Dockerfile

3.3.1 FROM

FROM: 基础镜像，当前新镜像是基于哪个镜像的，
	指定一个已经存在的镜像作为模板，第一条必须是FROM
1
2

3.3.2 MAINTAINER

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

3.3.3 RUN

RUN: 容器构建时需要运行的命令
	两种格式： 
		1. shell 格式: RUN <命令行命令>
		# <命令行命令> 等同于 在终端操作的shell命令
		# 例如： RUN yum -y install vim
		2. exec 格式： run ["可执行文件","参数1","参数2"]  
		# 例如：
		# RUN ["./test.php","dev","offline"] 等价于 RUN ./test.php dev offline
RUN 是在 docker build 时运行
1
2
3
4
5
6
7
8
9

3.3.4 EXPOSE

EXPOSE: 当前容器对外暴露出的端口
1

3.3.5 WORKDIR

WORKDIR: 指定在创建容器后，终端默认登陆的进来工作目录，一个落脚点
	[root@vm001 admin]# docker start redis-node-1
	redis-node-1
	[root@vm001 admin]# docker exec -it redis-node-1 /bin/bash
	root@vm001:/data# pwd
	## 这里的WORKDIR就是/data
	/data
1
2
3
4
5
6
7

3.3.6 USER

USER: 指定该镜像以什么样的用户去执行，如果都不指定，默认是root
1

3.3.7 ENV

ENV: 用来在构建镜像过程中设置环境变量
	ENV MY_PATH /usr/mytest
	# 这个环境变量可以在后续的任何RUN指令中使用，这就如同在命令前面指定了环境变量前缀一样；
	# 也可以在其他指令中直接使用这些环境变量, 例如： 
	WORKDIR $MY_PATH
1
2
3
4
5

3.3.8 ADD

ADD: 将宿主机目录下的文件拷贝进镜像且会自动处理URL和解压tar压缩包
	等同于 COPY 加上解压
1
2

3.3.9 COPY

COPY: 类似ADD，拷贝文件和目录到镜像中。
	将从构建上下文目录中 <源路径> 的文件/目录复制到新的一层的镜像内的 <目标路径> 位置
	1. COPY src dest
	2. COPY ["src", "dest"]
		<src源路径>：源文件或者源目录
		<dest目标路径>：容器内的指定路径，该路径不用事先建好，路径不存在的话，会自动创建。
1
2
3
4
5
6

3.3.10 VOLUME

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

3.3.11 CMD

CMD: 指定容器启动后的要干的事情
	CMD 指令和RUN相似，也有两种格式：
		shell格式： CMD <命令>
		exec格式： CMD ["可执行文件","参数1","参数2",...]
	参数列表格式： CMD ["参数1","参数2",...]，在指定了ENTRYPOINT指令后，用CMD指定具体的参数
	
	Dockerfile 中可以有多个 CMD 指令，但只有最后一个生效，CMD 会被 docker run 之后的参数替换
	如： 参考官网Tomcat的dockerfile演示讲解, 官网最后一行命令
		157			EXPOSE 8080
		158			CMD ["catalina.sh","run"]
	我们演示自己的覆盖操作
		docker run -it -p 8080:8080 myTomcat /bin/bash
		# 添加的 /bin/bash 会变成  CMD ["/bin/bash","run"]，也即覆盖掉上面的 CMD ["catalina.sh","run"]
		# 导致启动出现不必要的问题
		
	它和前面RUN命令的区别
		CMD是在 docker run 时运行。
		RUN是在 docker build时运行。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

3.3.12 ENTRYPOINT

ENTRYPOINT: 也是用来指定一个容器启动时要运行的命令
	类似于 CMD 指令，但是ENTRYPOINT 不会被docker run后面的命令覆盖，
	而且这些命令行参数会被当作参数送给 ENTRYPOINT 指令指定的程序
命令格式和案例说明
	命令格式：ENTRYPOINT ["<executeable>","param1","param2", ...]
	A. ENTRYPOINT可以和CMD一起用，一般是变参才会使用 CMD，
		这里的 CMD 等于是在给 ENTRYPOINT 传参。
	B. 当指定了ENTRYPOINT后，CMD的含义就发生了变化，不再是直接运行其命令而是将CMD
		的内容作为参数传递给ENTRYPOINT指令，他两个组合会变成
		<ENTRYPOINT> "<CMD>"

	案例如下：假设已通过 Dockerfile 构建了 nginx:test 镜像：
	FROM nginx 
	ENTRYPOINT ["nginx","-c"] # 定参
	CMD ["/etc/nginx/nginx.conf"] # 变参
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

上面的ENTRYPOINT案例解析

优点：在执行docker run的时候可以指定 ENTRYPOINT 运行所需的参数。
注意：如果 Dockerfile 中如果存在多个 ENTRYPOINT 指令，仅最后一个生效。

小总结：

From XXX（基于什么镜像）
WORKDIR（指定shell语句运行在那个路径下）
COPY（将宿主机的文件拷贝到某路径下）
RUN（运行shell语句，只要构建就会运行，如echo 321 >> 1.txt）
CMD （指定镜像启动运行的脚本，只有容器真正运行的时候才会运行的脚本，执行后容器的生命周期即结束，且一般为阻塞式语句，如tail语句）
一般语句为：
FROM WORKDIR COPY-ADD RUN CMD-ENTRYPOINT
ENTRYPOINT非json则以ENTRYPOT为准，如果ENTRYPOINT和CMD都是JSON则ENTRYPOINT+CMD拼接成shell

EXPOSE—暴露镜像的指定端口
VOLUME—指定映射文件
ENV—指定doker的环境变量，运行时一直生效
ARG—构建参数，运行时无效，可以构建时候临时修改变量
LABEL—指定元数据，便于找到docker
ONBUILD—当前镜像构建的时候不会执行，基于当前镜像的镜像去构建的时候才会执行
STOPSIGNAL—指定容器使用什么信号，一般指定信号名
HEALTHCHECK—检查容易的健康状态
SHELL—指定linux为/bin/sh，windows为cmd

3.4 DockerFile 案例

3.4.1 Centos7镜像具备vim+ifconfig+jdk8

3.4.1.1 准备材料

下载centos7：
注意：如果使用最新的centos 打包会有问题(centos 的官方镜像源停止了,需要用centos7来构建)，需要指定前面一两个版本的版本号

https://hub.docker.com/_/centos?tab=tags

# 指令：  docker pull centos:centos7
[root@vm001 mydockerfiles]# docker pull centos:centos7
centos7: Pulling from library/centos
2d473b07cdd5: Pull complete 
Digest: sha256:9d4bcbbb213dfd745b58be38b13b996ebb5ac315fe75711bd618426a630e0987
Status: Downloaded newer image for centos:centos7
docker.io/library/centos:centos7

1
2
3
4
5
6
7
8
9
10

JDK的下载地址：

https://www.oracle.com/java/technologies/downloads/#java8
https://mirrors.yangxingzhen.com/jdk/
1
2

默认下载最新的版本，这里使用 jdk-8u321-linux-x64.tar.gz

下载到128 机器的目录 /usr/local/tardir

3.4.1.2 编写 DockerFile 文件

新建dockerfile 文件：
--------注意： DockerFile文件夹开头大写字母 (D)
Dockerfile/ dockerfile 都可以
DockerFile 会报错
命名出错参考：https://blog.csdn.net/weixin_40542507/article/details/104817503

[root@vm001 /]# pwd
/
# 根目录下新建文件夹
[root@vm001 /]# mkdir mydockerfiles
[root@vm001 /]# cd mydockerfiles/
# 把jdk包移动到目录下
[root@vm001 mydockerfiles]# mv /usr/local/tardir/jdk-8u321-linux-x64.tar.gz /mydockerfiles/
# 新建文本 Dockerfile
[root@vm001 mydockerfiles]# vim Dockerfile
[root@vm001 mydockerfiles]# ll
总用量 143376
-rw-r--r--. 1 root root         0 5月   7 18:12 Dockerfile
-rw-r--r--. 1 root root 146815279 5月   7 17:39 jdk-8u321-linux-x64.tar.gz
1
2
3
4
5
6
7
8
9
10
11
12
13

Docker file 文件具体内容：注意： 全篇精华所在

# centos7 是版本号
# FROM centos:centos7 否则yum无法使用，安装报错，
# 原因是系统版本为8导致yum找不到对应版本的镜像库
FROM centos:centos7
MAINTAINER bogerpeng@gmail.com
# 环境变量
ENV MYPATH /usr/local
# 创建容器后，终端默认登陆的进来的工作目录
WORKDIR $MYPATH
 
#安装vim编辑器
RUN yum -y install vim
#安装ifconfig命令查看网络IP
RUN yum -y install net-tools
#安装java8及lib库
RUN yum -y install glibc.i686
RUN mkdir /usr/local/java
# ADD 是相对路径jar,把jdk-8u321-linux-x64.tar.gz添加到容器中,安装包必须要和Dockerfile文件在同一位置
# add命令支持将远程URL的资源，但是docker官方不建议直接用远程url，所以还是先下载到主机
ADD jdk-8u321-linux-x64.tar.gz /usr/local/java/
#配置java环境变量
ENV JAVA_HOME /usr/local/java/jdk1.8.0_321
ENV JRE_HOME $JAVA_HOME/jre
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib:$CLASSPATH
ENV PATH $JAVA_HOME/bin:$PATH
 
EXPOSE 80

# 三个CMD 命令，三个都会执行，但是只有最后一个命令会被挂载 
CMD echo $MYPATH
CMD echo "success--------------ok"
# 启动一个伪终端来供客户使用
CMD /bin/bash
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

3.4.1.3 构建新镜像

在包含dockerfile的目录下执行以下脚本：

# 命令
docker build -t 新镜像名字:TAG .
docker build -t centosjava8:6.66 .
1
2
3

注意，上面TAG后面有个空格，有个点

具体执行情况：

# 构建镜像
[root@vm001 mydockerfiles]# docker build -t centosjava8:6.66 .
Sending build context to Docker daemon  146.8MB
# 提示一共有17个步骤
Step 1/17 : FROM centos:centos7
 ---> eeb6ee3f44bd
Step 2/17 : MAINTAINER bogerpeng@gmail.com
 ---> Running in 9428ab39d484
Removing intermediate container 9428ab39d484
 ---> 5298c5f4b6b4
Step 3/17 : ENV MYPATH /usr/local
 ---> Running in c0a5901a6976
Removing intermediate container c0a5901a6976
 ---> 4feb4045da99
Step 4/17 : WORKDIR $MYPATH
 ---> Running in 8f59da5d6751
Removing intermediate container 8f59da5d6751
 ---> e25de6332278
Step 5/17 : RUN yum -y install vim
 ---> Running in fe388f91f512
######    中间省略部分代码
......
######    中间省略部分代码
Step 16/17 : CMD echo "success--------------ok"
 ---> Running in c775d6eaac5e
Removing intermediate container c775d6eaac5e
 ---> 6b6bc4100970
Step 17/17 : CMD /bin/bash
 ---> Running in b047ab3a32e3
Removing intermediate container b047ab3a32e3
 ---> e71536af5fd2
Successfully built e71536af5fd2
Successfully tagged centosjava8:6.66

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

查看 images：

[root@vm001 mydockerfiles]# docker images
REPOSITORY                                                    TAG          IMAGE ID       CREATED         SIZE
centosjava8                                                   6.66         e71536af5fd2   8 minutes ago   1.16GB
1
2
3

3.4.1.4 运行新镜像，测试添加的功能

docker run -it 新镜像名字:TAG​
docker run -it centosjava8:6.66 /bin/bash

[root@vm001 mydockerfiles]# docker run -it centosjava8:6.66 /bin/bash
# WORKDIR 设置的目录
[root@23db6e7563a6 local]# pwd
/usr/local
# 拥有 vim 功能
[root@23db6e7563a6 local]# vim a.txt
[root@23db6e7563a6 local]# cat a.txt 
# centos7 jdk8 vim net combined
# 拥有 ifconfig 功能
[root@23db6e7563a6 local]# ifconfig
eth0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet 172.17.0.5  netmask 255.255.0.0  broadcast 172.17.255.255
        ether 02:42:ac:11:00:05  txqueuelen 0  (Ethernet)
        RX packets 8  bytes 656 (656.0 B)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 0  bytes 0 (0.0 B)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

lo: flags=73<UP,LOOPBACK,RUNNING>  mtu 65536
        inet 127.0.0.1  netmask 255.0.0.0
        loop  txqueuelen 1000  (Local Loopback)
        RX packets 0  bytes 0 (0.0 B)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 0  bytes 0 (0.0 B)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0
# 拥有 jdk8
[root@23db6e7563a6 local]# java -version
java version "1.8.0_321"
Java(TM) SE Runtime Environment (build 1.8.0_321-b07)
Java HotSpot(TM) 64-Bit Server VM (build 25.321-b07, mixed mode)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

3.4.1.5 再体会下UnionFS（联合文件系统）

UnionFS（联合文件系统）：Union文件系统（UnionFS）是一种分层、轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时可以将不同目录挂载到同一个虚拟文件系统下(unite several directories into a single virtual filesystem)。Union 文件系统是 Docker 镜像的基础。镜像可以通过分层来进行继承，基于基础镜像（没有父镜像），可以制作各种具体的应用镜像。

特性： 一次同时加载多个文件系统，但从外面看起来，只能看到一个文件系统，联合加载会把各层文件系统叠加起来，这样最终的文件系统会包含所有底层的文件和目录

3.4.2 虚悬镜像

3.4.2.1 定义

仓库名、标签都是的镜像，俗称dangling image
一般都是由于编写出错或者删除出错导致的，发现了就要删除

3.4.2.2 dockerfile 写一个

• (1). vim Dockerfile

FROM ubuntu
CMD echo 'action is success'
1
2

# dockerfile的内容
[root@vm001 mydockerfiles]# mkdir /danglingimage
[root@vm001 mydockerfiles]# cd ..
[root@vm001 /]# cd /danglingimage/
[root@vm001 danglingimage]# pwd
/danglingimage
[root@vm001 danglingimage]# vim dockerfile
[root@vm001 danglingimage]# cat dockerfile
FROM ubuntu
CMD echo 'action is success'
1
2
3
4
5
6
7
8
9
10

• (2). docker build .

## 注意 build . 后面有个小数点 
[root@vm001 danglingimage]# docker build .
Sending build context to Docker daemon  3.072kB
Step 1/2 : FROM ubuntu
 ---> ba6acccedd29
Step 2/2 : CMD echo 'action is success'
 ---> Running in 6aa617360932
Removing intermediate container 6aa617360932
 ---> 27c469251c8f
Successfully built 27c469251c8f
# 虚悬镜像
[root@vm001 danglingimage]# docker images
REPOSITORY                                                    TAG          IMAGE ID       CREATED              SIZE
<none>                                                        <none>       27c469251c8f   About a minute ago   72.8MB
1
2
3
4
5
6
7
8
9
10
11
12
13
14

3.4.2.3 查询虚悬镜像

# docker image ls -f dangling=true
[root@vm001 danglingimage]# docker image ls -f dangling=true
REPOSITORY   TAG       IMAGE ID       CREATED         SIZE
<none>       <none>    27c469251c8f   6 minutes ago   72.8MB
1
2
3
4

3.4.2.4 删除虚悬镜像

虚悬镜像已经失去存在价值，可以删除

# docker image prune
[root@vm001 danglingimage]# docker image prune
WARNING! This will remove all dangling images.
Are you sure you want to continue? [y/N] y
Deleted Images:
deleted: sha256:27c469251c8f459188a50aa81444e90153eecaa175d1daec461342b66a01ad6b

Total reclaimed space: 0B
1
2
3
4
5
6
7
8

3.4.3 自定义一个myubuntu

待有空补。。。

4. docker微服务实战

目的：打包一个可执行的微服务模块 （jar包）

4.1 通过IDEA新建一个普通微服务模块

4.1.1 服务名称 docker-boot

4.1.2 pom

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <!-- 这里是我自己新建的could主项目，这里可以忽略 -->
    <parent>
        <artifactId>cloud2020</artifactId>
        <groupId>com.pyh.springcloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>docker-boot</artifactId>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>
        <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <executable>true</executable>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <!--可以把依赖的包都打包到生成的Jar包中-->
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <version>3.1.0</version>
            </plugin>
        </plugins>
    </build>
</project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

4.1.3 yaml

server:
  port: 6001
1
2

4.1.4 主启动类

package com.pyh.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

1
2
3
4
5
6
7
8
9
10
11
12
13

4.1.5 controller

package com.pyh.springcloud.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import java.util.UUID;

@RestController
public class OrderController {
    @Value("${server.port}")
    private String port;

    @RequestMapping("/order/docker")
    public String helloDocker()
    {
        return "hello docker"+"\t"+port+"\t"+ UUID.randomUUID().toString();
    }

    @RequestMapping(value ="/order/index",method = RequestMethod.GET)
    public String index()
    {
        return "服务端口号: "+"\t"+port+"\t"+UUID.randomUUID().toString();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

4.1.6 测试

4.1.7 生成 jar 包

在maven选中本项目docker-boot，通过package功能build包

## ideal的输出日志
[INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ docker-boot ---
[INFO] Building jar: D:\EclipseWorkspace\tempworkspace\cacheapp\cloud2020\docker-boot\target\docker-boot-1.0-SNAPSHOT.jar
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
1
2
3
4
5
6

4.2 通过dockerfile发布微服务部署到docker容器

4.2.1 新建文件夹，并把打包好的 jar 包上传

[root@vm001 /]# mkdir dockerfiles
[root@vm001 /]# chmod 777 dockerfiles/
[root@vm001 /]# cd dockerfiles/
[root@vm001 dockerfiles]# ll
总用量 0
[root@vm001 dockerfiles]# vim readme.txt
[root@vm001 dockerfiles]# ll
总用量 4
-rw-r--r--. 1 root root 48 5月   8 23:40 readme.txt
[root@vm001 dockerfiles]# mkdir dockertest20220508
[root@vm001 dockerfiles]# chmod 777 dockertest20220508/
[root@vm001 dockerfiles]# cd dockertest20220508/

## jar 包上传之后
[root@vm001 dockertest20220508]# ll
总用量 4
-rw-r--r--. 1 root root 3625 5月   8 23:44 docker-boot-1.0-SNAPSHOT.jar

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

4.2.2 编写 Dockerfile

[root@vm001 dockertest20220508]# cat Dockerfile 
# 注意：jar 包基于jdk8t，所以这里直接 FROM java:8
# 基础镜像使用java
FROM java:8

# 作者
MAINTAINER pyh

# VOLUME 指定临时文件目录为/tmp，在主机/var/lib/docker目录下创建了一个临时文件并链接到容器的/tmp
VOLUME /tmp

# 将jar包添加到容器中并更名为 OrderService6001.jar
ADD docker-boot-1.0-SNAPSHOT.jar OrderService6001.jar

# 运行jar包
RUN bash -c 'touch /OrderService6001.jar'
ENTRYPOINT ["java","-jar","/OrderService6001.jar"]

#暴露6001端口作为微服务
EXPOSE 6001

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

4.2.3 构建镜像

## docker build -t orderservice6001:v1.1 .
[root@vm001 dockertest20220508]# docker build -t orderservice6001:v1.1 .
Sending build context to Docker daemon  6.656kB
Step 1/7 : FROM java:8
8: Pulling from library/java
5040bd298390: Pull complete 
fce5728aad85: Pull complete 
76610ec20bf5: Pull complete 
60170fec2151: Pull complete 
e98f73de8f0d: Pull complete 
11f7af24ed9c: Pull complete 
49e2d6393f32: Pull complete 
bb9cdec9c7f3: Pull complete 
Digest: sha256:c1ff613e8ba25833d2e1940da0940c3824f03f802c449f3d1815a66b7f8c0e9d
Status: Downloaded newer image for java:8
 ---> d23bdf5b1b1b
Step 2/7 : MAINTAINER pyh
 ---> Running in a789cec29678
Removing intermediate container a789cec29678
 ---> c269e36c2c80
Step 3/7 : VOLUME /tmp
 ---> Running in fba548b8a8c1
Removing intermediate container fba548b8a8c1
 ---> da8dc54264fa
Step 4/7 : ADD docker-boot-1.0-SNAPSHOT.jar OrderService6001.jar
 ---> 105fa7009abb
Step 5/7 : RUN bash -c 'touch /OrderService6001.jar'
 ---> Running in 9c263a3aed62
Removing intermediate container 9c263a3aed62
 ---> 18369395d385
Step 6/7 : ENTRYPOINT ["java","-jar","/OrderService6001.jar"]
 ---> Running in 7156e75c17ab
Removing intermediate container 7156e75c17ab
 ---> 625fc90170c4
Step 7/7 : EXPOSE 6001
 ---> Running in 46f0baf80ce1
Removing intermediate container 46f0baf80ce1
 ---> 67a7ba9f1552
Successfully built 67a7ba9f1552
Successfully tagged orderservice6001:v1.1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

查询镜像：

[root@vm001 dockertest20220508]# docker images
REPOSITORY                                                    TAG          IMAGE ID       CREATED         SIZE
orderservice6001                                              v1.1         67a7ba9f1552   6 minutes ago   643MB

1
2
3
4

4.2.4 启动镜像并测试

docker run -d --name orderservice6001 -p 6001:6001

[root@vm001 dockertest20220508]# docker run -d --name orderservice6001 -p 6001:6001 orderservice6001:v1.1 
ff071420a2088b298c02904be04515c9c8e1959a815724e2312f746ce7cc794f
## 查看结果-- 启动成功了
[root@vm001 dockertest20220508]# docker ps
CONTAINER ID   IMAGE                   COMMAND                  CREATED         STATUS        PORTS                                                                                         NAMES
ff071420a208   orderservice6001:v1.1   "java -jar /OrderSer…"   2 seconds ago   Up 1 second   0.0.0.0:6001->6001/tcp, :::6001->6001/tcp                                                     orderservice6001

1
2
3
4
5
6
7

调用网页连接查看结果，成功了