Docker基础系列之DockerFile

Docker基础系列之Dockerfile

1. Dockerfile是什么？

1.1 Dockerfile概述

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

1.2 构建三步骤

• 编写Dockerfile文件
• 构建镜像docker build
• 实例化容器docker run

2. Dockerfile构建过程解析

2.1 Dockerfile内容基础知识

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

2.2 执行Dockerfile的大致流程

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

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

以下是常用的 Dockerfile 关键字的完整列表和说明：

4. 案例

使用docker容器部署一个springboot项目

4.1 首先创建一个sprigboot项目

pom.xml

    4.0.0
    
        org.springframework.boot
        spring-boot-starter-parent
        2.7.5
         
    
    com.xmc
    spring-boot-hello-world
    0.0.1-SNAPSHOT
    spring-boot-hello-world
    spring-boot-hello-world
    
        1.8
    
    
        
            org.springframework.boot
            spring-boot-starter-web
        


        
            org.springframework.boot
            spring-boot-starter-test
            test
        

        
            org.projectlombok
            lombok
        

        
            cn.hutool
            hutool-all
            5.8.9
        
    

    
        
            
                org.springframework.boot
                spring-boot-maven-plugin
                
                    
                        
                            org.projectlombok
                            lombok
                        
                    
                
            
        
    



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
55
56
57
58
59
60
61
62

application.yml

server:
  port: 8080
1
2

启动类

package com.xmc.hello;

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

/**
 * @author xiaomuchong
 */
@SpringBootApplication
public class SpringBootHelloWorldApplication {

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

}

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

定义一个测试接口

package com.xmc.hello.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author xiaomuchong
 */
@RequestMapping("test")
@RestController
public class HelloWorldController {

    @GetMapping("hello")
    public String  sayHello() {
        return "Hello Dockerfile ######";
    }
}

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

验证这个springboot项目正确之后，打包spring-boot-hello-world-0.0.1-SNAPSHOT.jar

4.2 创建 Dockerfile文件

vim Dockerfile

#指定基镜像
FROM openjdk:latest
#指定数据卷
VOLUME ["/tmp"]
#作者
MAINTAINER 小木虫 <1750xxxx@qq.com>

#添加项目
COPY *.jar /usr/local/app/app.jar

#定义时区参数
ENV WORK_DIR = /usr/local/app


#修改这个文件的访问时间为当前时间
RUN sh -c 'touch /app.jar'

# 工作目录(docker内部目录)
WORKDIR $WORK_DIR

#暴露端口
EXPOSE 8080
#指定执行启动项目
ENTRYPOINT ["java","-jar","/usr/local/app/app.jar"]

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

4.3 构建镜像，也可以把构建镜像的命令编写成脚本

vim docker.build.sh

#!/bin/bash

docker build --rm -t springboot-dockerfile-image:1.0 .

1
2
3
4

构建镜像

//赋予执行权限
chmod +x docker.build.sh
//执行
./docker.build.sh
1
2
3
4

构建过程日志

[root@Docker110 dockerfile]# ./docker.build.sh 
[+] Building 2.3s (9/9) FINISHED                                                          docker:default
 => [internal] load .dockerignore                                                                   0.0s
 => => transferring context: 2B                                                                     0.0s
 => [internal] load build definition from Dockerfile                                                0.0s
 => => transferring dockerfile: 573B                                                                0.0s
 => [internal] load metadata for docker.io/library/openjdk:latest                                   0.0s
 => [internal] load build context                                                                   0.3s
 => => transferring context: 20.05MB                                                                0.2s
 => [1/4] FROM docker.io/library/openjdk:latest                                                     0.1s
 => [2/4] COPY *.jar /usr/local/app/app.jar                                                         0.1s
 => [3/4] RUN sh -c 'touch /app.jar'                                                                1.4s
 => [4/4] WORKDIR = /usr/local/app                                                                  0.0s
 => exporting to image                                                                              0.3s
 => => exporting layers                                                                             0.3s
 => => writing image sha256:a8ae4d1222bad9a074e8ac165728910eeda46bd9e938e297ec9e81e958f582d9        0.0s
 => => naming to docker.io/library/springboot-dockerfile-image:1.0                                  0.0s

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

4.4 实例化容器

vim docker.run.sh

docker run -d \
-p 8088:8080 \
--name=springboot-dockerfile-docker \
springboot-dockerfile-image:1.0
1
2
3
4

创建容器并运行

//赋予执行权限
chmod +x docker.run.sh
//执行
./docker.run.sh
1
2
3
4

查看容器

通过接口验证

http://192.168.10.110:8088/test/hello
1

服务器部署截图

5. 参考和感谢

尚硅谷阳哥Docker课程