从0到1构建springboot web应用镜像并使用容器部署

Posted 2023-03-20

文章目录

• ​​一、生成镜像的两种方法​​

• ​​1.1、使用commit生成镜像​​

• ​​1.1.1、拉取Centos基础镜像​​
• ​​1.1.2、启动Centos容器并安装Go​​
• ​​1.1.3、commit生成新镜像​​
• ​​1.1.4、使用新镜像验证Golang环境​​

• ​​1.2、使用Dockerfile生成镜像​​

• ​​二、基于Dockerfile生成一个springboot镜像​​

• ​​2.1、准备springboot应用jar包​​
• ​​2.2、编写Dockerfile​​

• ​​三、运行容器服务，验证镜像的可用性​​

我们知道Docker三大概念：镜像、容器、仓库，其中镜像是容器运行的基础，我们一般来说的开发流程是从Docker Hub获取基础镜像，基于基础镜像进行一定的定制化开发（例如将应用程序放到镜像中），产生新的镜像，基于这个新的镜像启动容器，从而运行应用程序。

所以如何将一个应用程序生成一个镜像是非常关键的，本文以生成一个springboot镜像为例，展示如何生成一个镜像，以及基于这个镜像运行容器。

一、生成镜像的两种方法

Docker镜像的制作一般有两种方法，一种基于dockerfile配置文件，使用​​docker build​​​进行，这是最推荐的正宗的镜像制作方法；第二种是通过使用​​docker commit​​这样的命令，手动将修改后的内容生成新的镜像。

1.1、使用commit生成镜像

这种方式不太适合大规模的镜像生成，一是对于镜像的构建内容无法回溯，二是操作效率比较低，但是在某些临时情况下却也有其方便之处，特别是开发测试时，如果临时需要安装一些新的软件，可以快捷生成新的镜像。

这里以生成一个自带Golang的镜像为例，演示如何使用commit生成镜像。

1.1.1、拉取Centos基础镜像

首先我们需要拉去一个Centos的基础镜像，Golang的安装将基于这个基础镜像进行操作。

搜索centos镜像：

[root@node1 ~]# docker search centos
INDEX       NAME                                                   DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
docker.io   docker.io/centos                                       DEPRECATED; The official build of CentOS.       7529      [OK]
docker.io   docker.io/kasmweb/centos-7-desktop                     CentOS 7 desktop for Kasm Workspaces            33
docker.io   docker.io/couchbase/centos7-systemd                    centos7-systemd images with additional deb...   7                    [OK]

拉取STARS数量最高的官方镜像

[root@node1 ~]# docker pull centos
Using default tag: latest
Trying to pull repository docker.io/library/centos ...
latest: Pulling from docker.io/library/centos
a1d0c7532777: Pull complete
Digest: sha256:a27fd8080b517143cbbbab9dfb7c8571c40d67d534bbdee55bd6c473f432b177
Status: Downloaded newer image for docker.io/centos:latest

1.1.2、启动Centos容器并安装Go

[root@node1 ~]# docker run -it centos /bin/bash
[root@311c53f54f2f /]#
[root@311c53f54f2f /]# go version
bash: go: command not found

这里证明基础的centos里面是没有golang的。

使用yum安装golang，发现如下错误提示

[root@311c53f54f2f /]# yum install go
Failed to set locale, defaulting to C.UTF-8
CentOS Linux 8 - AppStream                                                                                            71  B/s |  38  B     00:00
Error: Failed to download metadata for repo appstream: Cannot prepare internal mirrorlist: No URLs in mirrorlist

这是因为yum源的问题，执行以下命令可以解决：

[root@311c53f54f2f yum.repos.d]# sed -i s/mirrorlist/#mirrorlist/g /etc/yum.repos.d/CentOS-*
[root@311c53f54f2f yum.repos.d]# sed -i s|#baseurl=http://mirror.centos.org|baseurl=http://vault.centos.org|g /etc/yum.repos.d/CentOS-*
[root@311c53f54f2f yum.repos.d]# yum clean all
Failed to set locale, defaulting to C.UTF-8
0 files removed
[root@311c53f54f2f yum.repos.d]# yum makecache
Failed to set locale, defaulting to C.UTF-8
CentOS Linux 8 - AppStream                                                                                           2.6 MB/s | 8.4 MB     00:03
CentOS Linux 8 - BaseOS                                                                                              2.0 MB/s | 4.6 MB     00:02
CentOS Linux 8 - Extras                                                                                              7.7 kB/s |  10 kB     00:01
Metadata cache created.

正常成功安装golang

[root@311c53f54f2f yum.repos.d]# yum install go
[root@311c53f54f2f yum.repos.d]# go version
go version go1.16.12 linux/amd64

1.1.3、commit生成新镜像

首先使用​​docker ps​​​查看当前的容器container id，这里是​​311c53f54f2f​​。

[root@node1 ~]# docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
311c53f54f2f        centos              "/bin/bash"         13 minutes ago      Up 13 minutes

使用​​docker commit​​命令生成新的镜像

[root@node1 ~]# docker commit -a "lucas" -m "install golang" 311c53f54f2f centos-go:v1
sha256:019ab02d451defb75e2ee03948289ed008036ba7ec8a355cae28bdf7fbce07d2

再次使用​​docker image​​可以看到我们生成的centos-go的新镜像。

[root@node1 ~]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
centos-go           v1                  019ab02d451d        2 minutes ago       805 MB
docker.io/busybox   latest              bab98d58e29e        8 days ago          4.86 MB
docker.io/nginx     latest              904b8cb13b93        13 days ago         142 MB
docker.io/centos    latest              5d0da3dc9764        18 months ago       231 MB

1.1.4、使用新镜像验证Golang环境

[root@node1 ~]# docker run -it centos-go:v1 /bin/bash
[root@daff0519f2ca /]# go version
go version go1.16.12 linux/amd64

1.2、使用Dockerfile生成镜像

Dockerfile是一个包含Docker镜像构建指令的文本文件，用于自动化Docker镜像的构建过程。Dockerfile通过一系列指令来描述镜像的构建过程，包括基础镜像、依赖安装、文件拷贝、环境变量配置、启动命令等。Dockerfile的语法是类似于Shell脚本的语言。

Dockerfile由4个部分组成：基础镜像信息、维护者信息、镜像操作指令和容器启动指令。Dockerfile中的注释以#开头，可以用于描述指令的作用或者提供其他注释信息。

以下是一些常见的Dockerfile命令：

1. FROM：指定基础镜像，例如​​FROM ubuntu:latest​​,FROM指令必须是除了注释意外的第一条指令，后续紧跟维护者信息指令。
2. MAINTAINER：指定维护者的信息，例如​​MAINTAINER lucas​​。
3. RUN：在镜像中运行命令，例如​​RUN apt-get update && apt-get install -y nginx​​。
4. CMD：指定容器启动时要运行的命令，例如CMD [“nginx”, “-g”, “daemon off;”]。
5. EXPOSE：声明容器要监听的端口，例如​​EXPOSE 80​​。
6. ENV：设置环境变量，例如​​ENV NODE_ENV production​​。
7. ADD：将文件复制到镜像中，例如​​ADD app.js /app.js​​。
8. COPY：将文件复制到镜像中，例如​​COPY app.js /app.js​​。
9. WORKDIR：设置工作目录，例如​​WORKDIR /app​​。
10. USER：设置容器启动时要使用的用户，例如​​USER nginx​​。
11. VOLUME：声明容器数据卷，例如​​VOLUME /data​​。
12. ENTRYPOINT：指定容器启动时要运行的命令，例如​​ENTRYPOINT ["nginx", "-g", "daemon off;"]​​。

这些命令是常用的，但Dockerfile还有其他命令可以使用。可以查看Docker官方文档以获取更多信息。

完成了dockerfile的配置以后，使用​​docker build​​​就可以构建镜像了。​​docker build​​​命令可以通过指定不同的参数来自定义构建过程。例如，你可以使用​​--no-cache​​​选项来强制Docker在构建镜像时不使用缓存，或者使用​​--build-arg​​​选项来传递构建时需要的环境变量。可以通过​​docker build --help​​命令查看所有可用的选项。

二、基于Dockerfile生成一个springboot镜像

这里我们演示一下如何使用dockerfile构建一个springboot web应用镜像，并使用docker启动容器。

2.1、准备springboot应用jar包

我们准备一个基于springboot开发的应用服务，这个服务开放8080端口，访问是返回一个用户的姓名信息。

为了方便，可以使用spring initializr 在线生成demo代码，在demo代码的基础上开发一个controller返回一个User对象的name信息，由于这块代码比较简单，这里就不详述过程了。

代码完成以后使用​​mvn clean package​​​进行打包，这里打包成功以后生成了demo-0.0.1-SNAPSHOT.jar，我们使用​​java -jar demo-0.0.1-SNAPSHOT.jar​​就可以运行这个应用程序。

2.2、编写Dockerfile

在项目根目录下创建一个名为​​Dockerfile​​的文件，并在其中添加以下内容：

FROM openjdk:18-jdk-alpine
MAINTAINER lucas
COPY target/demo-0.0.1-SNAPSHOT.jar /usr/app/
WORKDIR /usr/app
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "demo-0.0.1-SNAPSHOT.jar"]

在上面的Dockerfile中，​​FROM​​​指令指定了基础镜像为​​openjdk:18-jdk-alpine​​​，​​COPY​​​指令将构建好的可执行jar包复制到容器中，​​WORKDIR​​​指令设置工作目录为​​/usr/app​​​，​​EXPOSE​​​指令指定了容器运行的端口为​​8080​​​，​​ENTRYPOINT​​​指令指定了容器启动时要执行的命令为​​java -jar demo-0.0.1-SNAPSHOT.jar​​。

在终端中进入项目根目录，然后执行以下命令构建镜像：

docker build -t demo:latest .

其中，​​-t​​​参数指定了镜像的名称和版本号，​​.​​参数指定了Dockerfile所在的目录。

[root@node1 docker]# docker build -t demo:latest .
Sending build context to Docker daemon 51.05 MB
Step 1/6 : FROM openjdk:18-jdk-alpine
 ---> c89120dcca4c
Step 2/6 : MAINTAINER lucas
 ---> Running in 3d0ae6d2a813
 ---> 085b9066ca7b
Removing intermediate container 3d0ae6d2a813
Step 3/6 : COPY target/demo-0.0.1-SNAPSHOT.jar /usr/app/
 ---> c5c77f80f179
Removing intermediate container 00228e4b0aed
Step 4/6 : WORKDIR /usr/app
 ---> bdb555e3fb18
Removing intermediate container 35682266f140
Step 5/6 : EXPOSE 8080
 ---> Running in 499d9888fa01
 ---> 0fca023e8f23
Removing intermediate container 499d9888fa01
Step 6/6 : ENTRYPOINT java -jar demo-0.0.1-SNAPSHOT.jar
 ---> Running in 661fdaafa31d
 ---> 61e80950d665
Removing intermediate container 661fdaafa31d
Successfully built 61e80950d665

可以看到构建成功，使用​​docker images ​​可以查看到构建成功的镜像。

三、运行容器服务，验证镜像的可用性

以上步骤已经使用docker build生成了镜像，接下来就可以使用这个镜像启动容器，启动后会自动启动应用程序。

在终端中执行以下命令启动容器：

docker run -d -p 8080:8080 demo:latest

其中，​​-d​​​参数指定了容器在后台运行，​​-p​​​参数指定了容器的端口映射，​​demo:latest​​参数指定了要运行的镜像名称和版本号。

访问对应的web服务进行访问验证，结果如下：

Docker + SpringBoot2.0快速构建镜像

博文链接

Docker 是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖包到一个可移植的镜像中，然后发布到任何流行的 Linux或Windows 机器上，也可以实现虚拟化。容器是完全使用沙箱机制，相互之间不会有任何接口。(引用官方概念，本文注重docker+springboot2.0快速构建镜像，对docker更细节的知识不在做赘述)

Docker

本文使用的是CentOs7

docker 安装：

yum install docker
systemctl start docker 开启docker

docker ：修改拉取镜像地址，docker使用默认的公用仓库，在国内下载会比较慢

建议使用ustc拉取
编辑宿主机器文件 ： vi /etc/docker/daemon.json
没有该文件，请先创建一个。
{
"registry-mirrors": ["https://docker.mirrors.ustc.edu.cn"]
}
最后：重启dokcer容器 systemctl restart docker

docker ：常用命令

docker images 列出镜像
docker rmi 镜像 删除镜像
docker rm 容器id 移除容器
docker run -d --name 容器名称 -p 端口 镜像
docker start/stop 容器id 开启/停止容器
docker rm \'docker ps -a -q\' 删除所有的容器
docker ps 查看正在运行的容器
docker ps -a 查看历史运行过的容器
docker ps -l 查看最近运行过的容器

安装私有仓库

执行以下命令，会启动一个registry容器，该容器用于提供私有仓库的服务
没有挂载目录请先创建
docker run --name docker-registry -d -p 5000:5000 -v /usr/local/work/registry:/tmp/registry registry

使用curl -X GET http://192.168.15.129:5000/v2/_catalog 查看私有仓库的镜像信息
如果之前没有创建过，则为空
{"repositories":[]}

使docker 支持http推送镜像
在/etc/docker/daemon.json中配置以下属性，如果多个以逗号分隔。
{"insecure-registries":["192.168.15.129:5000","192.168.15.129"]}
在 /etc/containers/registries.conf中配置
[registries.search] registries = [\'docker.io\',\'registry.centos.org\',\'registry.access.redhat.com\',\'192.168.15.129:5000\',\'192.168.15.129\']

[registries.insecure] registries =["192.168.15.129:5000","192.168.15.129"]
地址是配置自己搭建的docker仓库私服地址和域名
重新启动Docker
systemctl restart docker .
从hub.docker.com中下载一个Tomcat镜像。
使用docker images 查看镜像信息，包括 IMAGE ID。

给该镜像添加一个带有私有仓库的ip的tag
docker tag tomcat镜像id 192.168.15.129:5000/tomcat

查看docker images 镜像，多出一个打了tag的tomcat镜像

推送镜像
docker push 192.168.15.129:5000/tomcat

删除从hub.docker.com中pull的镜像

启动私有仓库镜像
docker run --name tomcatpri -d -p 8080:8080 192.168.15.129:5000/tomcat

关闭防火墙，访问Tomcat，成功！

使用docker部署SpringBoot

搭建一个简单的SpringBoot 项目与Docker技术进行整合，使用maven来构建docker镜像并推送至本地docker registry，最后对想不部署时只需要根据对应得镜像启动容器即可。

环境搭建

JDK1.8
SpringBoot2.0.6.RELEASE
Maven 3.6.0
Docker

创建一个SpringBoot项目
自行创建一个maven quicker-starter项目。

引入依赖配置

<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>2.0.6.RELEASE</version>
</parent>
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     <docker.registry>192.168.15.129:5000</docker.registry>
  </properties>

  <dependencies>
  <dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-web</artifactId>
</dependency>

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <scope>test</scope>
    </dependency>
  </dependencies>
  
  <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <!-- Docker maven plugin -->
            <plugin>
                <groupId>com.spotify</groupId>
                <artifactId>docker-maven-plugin</artifactId>
                <version>1.0.0</version>
                <configuration>
                    <!-- docker私服的地址 -->
                    <dockerHost>http://192.168.15.129:2375</dockerHost>
                    <!--镜像名称以及版本号-->
                    <imageName>${docker.registry}/${project.artifactId}:${project.version}</imageName>
                    <!--依赖的基础镜像-->
                    <baseImage>java</baseImage>
                    <!--Dockerfile的位置 -->
                 <dockerDirectory>${project.basedir}/src/main/docker</dockerDirectory>
                    <!-- 这里是复制 jar 包到 docker 容器指定目录配置 -->
                    <resources>
                        <resource>
                            <targetPath>/</targetPath>
                            <directory>${project.build.directory}</directory>
                            <include>${project.build.finalName}.jar</include>
                        </resource>
                    </resources>
                </configuration>
            </plugin>
            <!-- Docker maven plugin -->
        </plugins>
    </build>

编写启动类

编写控制类，用于接收http请求

需要在src/main下面新建一个docker目录，并新建一个Dockerfile文件

  FROM java:8
    
    MAINTAINER lvy [e-mail]
    
    VOLUME /tmp
    
    ADD docker_registry-0.0.1-RELEASE.jar docker_registry.jar
    
    RUN cp /usr/share/zoneinfo/Asia/Shanghai /etc/localtime \\
    && echo \'Asia/Shanghai\' >/etc/timezone
    
    EXPOSE 9000
    
    ENTRYPOINT ["java", "-jar", "docker_registry.jar"]

对Dockerfile里面的内容做一个简单的介绍:

1.FROM:指明当前镜像继承的基础镜像,编译当前镜像时候会自动下载基镜像
2.MAINTAINER:当前镜像的作者和邮箱,使用空格隔开
3.VOLUME:挂载目录
4.ADD:从当前工作目录复制文件到镜像目录中并重新命名
5.RUN:在当前镜像上执行Linux命令,,第二个run指令是为了解决容器和宿主机时间不一致的问题
6.EXPOSE:监听的端口号
7.ENTRYPOINT:让容器像一个可执行程序一样运行

项目构建

使用docker build对项目打包构建
mvn clean install -DskipTests docker:build

这时会报出一个错误
问题1：如果在pom文件里面添加了<dockerHost>节点，并配置了地址是我们搭建的私服地址的话，会报出404 NOT PAGE，如果没有配置该节点会报出链接被拒绝的异常(Connection refused)

解决方案：添加一个``<dockerHost>``节点，值为docker所在机器ip:2375，至于为什么要配置2375，后面会介绍。

问题2：这时在进行 ``mvn clean install -DskipTests docker:build``命令会报出同样的错误，链接被拒绝。
导致原因：
在默认情况下Docker守护进程``Unit socket(/var/run/docker.sock)``来进行本地进程通信，而不会监听任何端口，因此只能在本地使用docker客户端或者使用docker api进行操作。如果想在其他主机上操作docker主机，就需要让docker守护进程打开一个http socket，这样才能实现远程通信，我们是在windows上打包构建的，所以需要让centos7的docker服务开启远程访问。
解决方案：
开启docker远程访问，进入docker私服所在的服务器，编辑配置文件
``vim /usr/lib/systemd/system/docker.service``
在``docker.service``的``[Service]``下增加如下内容
```shell
ExecStart=
ExecStart=/usr/bin/dockerd -H tcp://0.0.0.0:2375 -H unix://var/run/docker.sock
```
注意，该端口不是docker私服所在的服务端口，是新开的远程访问端口。进行远程通信的。

同样基于2的基础上，我们还要简历两个软连接，不然执行会报出找不到该命令

 ln -s /usr/libexec/docker/docker-proxy-current /usr/bin/docker-proxy
 
 cd /usr/libexec/docker/
 ln -s docker-runc-current docker-runc

启动

重新读取配置文件并启动docker

systemctl daemon-reload
systemctl restart docker

再次构建

mvn clean install -DskipTests docker:build
发现居然成功了。对！就是这么简单。

查看镜像，运行

使用docker images查看镜像，就会发现刚刚的服务已被打包成镜像了。
使用docker run命令就可以启动容器服务啦！
启动时需要docker名称+版本号为镜像名称。不然可能找不到(本人机器上如此)

访问服务成功

补充一点： maven 内置变量说明

${basedir} 项目根目录
${project.build.directory} 构建目录，缺省为target
${project.build.outputDirectory} 构建过程输出目录，缺省为target/classes
${project.build.finalName} 产出物名称，缺省为${project.artifactId}-${project.version} 当前版本
${project.packaging} 打包类型，缺省为jar