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


笔记记录尚硅谷周阳老师的 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

3.3.2 MAINTAINER

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

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 时运行

3.3.4 EXPOSE

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

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

3.3.6 USER

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

3.3.7 ENV

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

3.3.8 ADD

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

3.3.9 COPY

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

3.3.10 VOLUME

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

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时运行。

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"] # 变参

上面的ENTRYPOINT案例解析

是否传参按照dockerfile编写执行传参运行
docker命令docker run nginx:testdocker run nginx:test -c /etc/nginx/new.conf
衍生出的实际命令nginx -c /etc/nginx/nginx.confnginx -c /etc/nginx/new.conf

优点:在执行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

JDK的下载地址:

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

默认下载最新的版本,这里使用 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

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
3.4.1.3 构建新镜像

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

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

注意,上面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

查看 images:

[root@vm001 mydockerfiles]# docker images
REPOSITORY                                                    TAG          IMAGE ID       CREATED         SIZE
centosjava8                                                   6.66         e71536af5fd2   8 minutes ago   1.16GB
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)
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'
# 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'
  • (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
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
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

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>

4.1.3 yaml

server:
  port: 6001

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

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

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] ------------------------------------------------------------------------

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

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

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

查询镜像:

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

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

调用网页连接查看结果,成功了
在这里插入图片描述

  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Docker是一种开源的容器化平台,它可以帮助开发者将应用程序和服务以容器的形式进行打包、分发和部署。而Gluster是一个分布式存储系统,它可以将多个服务器的存储空间整合在一起,形成一个统一的、可扩展的存储池。 CentOS是一种基于Red Hat Enterprise Linux(RHEL)的开源操作系统,它提供了稳定性和安全性,并且具备广泛的应用支持。 Dockerfile是用于构建Docker镜像的脚本文件,它可以定义容器的运行环境、设置启动命令等。 那么,docker-gluster-centos Dockerfile是指在CentOS系统上构建一个包含Gluster分布式存储系统的Docker镜像的脚本文件。 在docker-gluster-centos Dockerfile中,我们可以使用CentOS的官方镜像作为基础镜像,并在此基础上安装和配置Gluster分布式存储系统。可以通过使用适当的软件包管理工具(如yum)来安装Gluster软件包和依赖项。然后,可以使用Dockerfile中的指令来启动和配置Gluster节点、创建Gluster卷以及设置其他必要的参数和选项。 通过构建docker-gluster-centos Docker镜像,我们可以在任何支持Docker的环境中快速部署和运行Gluster分布式存储系统,而无需手动安装和配置。这样可以大大简化Gluster的部署过程,提高运维效率,并且能够实现更加轻量级、可移植和可扩展的存储解决方案。 总而言之,docker-gluster-centos Dockerfile是用于在CentOS系统上构建包含Gluster分布式存储系统的Docker镜像的脚本文件,使得Gluster的部署和运行变得更加简单、可靠和可扩展。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值