Docker基础系列之DockerFile

Docker基础系列之Dockerfile

文章目录

Docker基础系列之Dockerfile
- [1. Dockerfile是什么？](#1. Dockerfile是什么？)
- - [1.1 Dockerfile概述](#1.1 Dockerfile概述)
  - [1.2 构建三步骤](#1.2 构建三步骤)
- [2. Dockerfile构建过程解析](#2. Dockerfile构建过程解析)
- - [2.1 Dockerfile内容基础知识](#2.1 Dockerfile内容基础知识)
  - [2.2 执行Dockerfile的大致流程](#2.2 执行Dockerfile的大致流程)
- [3. DockerFile体系结构(保留字指令)](#3. DockerFile体系结构(保留字指令))
- [4. 案例](#4. 案例)
- - [4.1 首先创建一个sprigboot项目](#4.1 首先创建一个sprigboot项目)
  - [4.2 创建 Dockerfile文件](#4.2 创建 Dockerfile文件)
  - [4.3 构建镜像，也可以把构建镜像的命令编写成脚本](#4.3 构建镜像，也可以把构建镜像的命令编写成脚本)
  - [4.4 实例化容器](#4.4 实例化容器)
- [5. 参考和感谢](#5. 参考和感谢)

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 关键字的完整列表和说明：

关键字	说明
FROM	基础镜像，当前新镜像是基于哪个镜像的
MAINTAINER	镜像维护者的姓名和邮箱地址
RUN	在镜像内部执行命令，用于安装软件包、设置环境等
EXPOSE	当前容器对外暴露出的端口
ENV	设置环境变量
ADD	将宿主机目录下的文件拷贝进镜像且ADD命令会自动处理URL和解压tar压缩包
COPY	类似ADD，拷贝文件和目录到镜像中。 `COPY src dest` `COPY ["src", "dest"]`
ENTRYPOINT	指定容器启动时要运行的命令，不会被 Docker run 命令覆盖
CMD	指定容器启动时要运行的命令，可以被 Docker run 命令覆盖
VOLUME	声明容器挂载的文件卷
USER	指定运行镜像的用户和用户组
WORKDIR	设置工作目录，后续命令将在该目录下执行
ARG	定义构建时的参数。
ONBUILD	在当前镜像被用作其他镜像的基础镜像时执行一些命令，通常用于构建通用的基础镜像
STOPSIGNAL	指定容器停止时发送的信号
HEALTHCHECK	指定容器健康检查命令，判断容器是否存活并运行
SHELL	定义默认的 shell，或者在 RUN 指令中覆盖默认 shell

4. 案例

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

4.1 首先创建一个sprigboot项目

pom.xml

复制代码

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.5</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.xmc</groupId>
    <artifactId>spring-boot-hello-world</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>spring-boot-hello-world</name>
    <description>spring-boot-hello-world</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>


        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.8.9</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

application.yml

复制代码

server:
  port: 8080

启动类

复制代码

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);
    }

}

定义一个测试接口

复制代码

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 ######";
    }
}

验证这个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"]

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

vim docker.build.sh

复制代码

#!/bin/bash

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

构建镜像

复制代码

//赋予执行权限
chmod +x docker.build.sh
//执行
./docker.build.sh

构建过程日志

复制代码

[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

4.4 实例化容器

vim docker.run.sh

复制代码

docker run -d \
-p 8088:8080 \
--name=springboot-dockerfile-docker \
springboot-dockerfile-image:1.0

创建容器并运行

复制代码

//赋予执行权限
chmod +x docker.run.sh
//执行
./docker.run.sh

查看容器

通过接口验证

复制代码

http://192.168.10.110:8088/test/hello

服务器部署截图

5. 参考和感谢

尚硅谷阳哥Docker课程