Docker 进阶指南（上）- 使用Dockerfile自定义镜像

已于 2022-08-22 16:49:35 修改
阅读量3k 收藏 7
点赞数 6
分类专栏： docker 文章标签： docker 容器 运维
于 2022-08-22 16:43:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011035397/article/details/126015074
版权

前言

大家好，我是洋子。上一篇文章《docker 快速入门指南》介绍了Docker的概念，安装Docker方法以及Docker的常用命令，并且在上篇内容当中，我们都是使用docker pull命令直接拉取阿里云镜像仓库里面提供的官方镜像

比如拉取mysql镜像就使用docker pull mysql，拉取centos镜像就使用docker pull centos，拉取tomcat镜像就使用docker pull tomcat

然而官方提供的tomcat镜像，因为webapps目录为空而不能直接使用，还需要在其生成的tomcat容器做相应文件修改后才能正常使用

所以实际使用当中，免不了对官方镜像进行修改后，制作成我们自己的镜像，用自己更改过的镜像创建的容器才能做到即开即用

那如何修改并制作docker镜像呢，下面教大家两个方法，一个是使用docker commit命令，另一个是使用Dockerfile文件

使用docker commit命令

使用docker commit 命令可以从正在运行的容器当中创建一个新的镜像，这个运行的容器已经安装好我们必要的环境或者修改好相应的配置，这样生成的镜像就可以直接使用

以修改tomcat镜像为例，说明docker commit命令的用法

  1. 拉取tomcat镜像
docker pull tomcat
  1. 查看已经拉取的镜像，使用docker images命令，可以看到列表当中已经出现刚下载的tomcat镜像
[root@yangzi ~]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED         SIZE
tomcat        latest    fb5657adc892   7 months ago    680MB
  1. 创建容器，使用docker run命令启动tomcat，并将本机的8080端口映射到容器里面的8080端口
# 从Docker Hub 下载tomcat镜像到本地并运行 -it 交互终端 -p 端口映射 
docker run -it -p 8080:8080 tomcat

#运行结果（看到如下信息说明Tomcat启动成功）
13-Aug-2022 09:30:24.586 INFO [main] org.apache.catalina.startup.Catalina.load Server initialization in [1519] milliseconds
13-Aug-2022 09:30:24.728 INFO [main] org.apache.catalina.core.StandardService.startInternal Starting service [Catalina]
13-Aug-2022 09:30:24.728 INFO [main] org.apache.catalina.core.StandardEngine.startInternal Starting Servlet engine: [Apache Tomcat/10.0.14]
13-Aug-2022 09:30:24.752 INFO [main] org.apache.coyote.AbstractProtocol.start Starting ProtocolHandler ["http-nio-8080"]
13-Aug-2022 09:30:24.780 INFO [main] org.apache.catalina.startup.Catalina.start Server startup in [193] milliseconds
  1. 现在我们用浏览器访问一下，并没有出现熟悉的tomcat欢迎页面，而是报了404，说明直接运行官方提供的tomcat镜像生成的容器存在问题
    在这里插入图片描述
  2. 用ctrl+c终端命令行，加上-d参数，重新以后台方式运行tomcat容器，这样我们就能进入到容器，对容器进行修改
# 后台方式启动tomcat容器
docker run -d -p 8080:8080 --name tomcat01 tomcat

# 进入tomcat容器
docker exec -it tomcat01 /bin/bash
  1. 经过排查是发现webpapps目录为空，但webapps.dist里有对应文件，处理方式是拷贝webapps.dist里对应文件到webpapps目录即可
    在这里插入图片描述
  2. 在tomcat根目录执行拷贝命令cp -r webapps.dist/* webapps
    在这里插入图片描述
  3. 在浏览器再次输入ip和8080端口访问，发现tomcat欢迎页面有了
    在这里插入图片描述
  4. 最后使用docker commit命令生成新的镜像
docker commit -a="yangzi" -m="new tomcat" d6cd9ac49dc2 tomcat02:1.1
 
#参数含义
-a : 提交的镜像作者 
-m : 提交时的说明文字
d6cd9ac49dc2 ：容器id，可以使用docker ps命令获取 
tomcat02:1.1 ： 镜像名以及版本tag
  1. 使用docker images查看镜像列表，可以看到名字叫tomcat02即为我们新创建的镜像
[root@yangzi ~]# docker commit -a="yangzi" -m="new tomcat" d6cd9ac49dc2 tomcat02:1.1
sha256:147e2244bc3912d60b33cc16c07b81eead8099bdfd35365b8b1ef37846896a94
[root@yangzi ~]# docker images
REPOSITORY    TAG       IMAGE ID       CREATED          SIZE
tomcat02      1.1       147e2244bc39   31 seconds ago   684MB
tomcat        latest    fb5657adc892   7 months ago     680MB
hello-world   latest    feb5d9fea6a5   10 months ago    13.3kB
centos        latest    5d0da3dc9764   11 months ago    231MB
  1. 验证效果，将之前运行的tomcat容器停止（不然会占用8080端口），停止容器使用命令docker stop 容器id ，容器id 用docker ps命令查看
    需要先停止之前的tomcat容器
    然后运行新创建tomcat02镜像所生成的容器，注意一点就是docker run命令tomcat02名字后面得带上版本Tag 1.1（因为我们在docker commit的时候设置了版本tag为1.1），不然默认拉取的是名为tomcat02镜像的latest版本会提示无法找到该镜像
docker run -it -p 8080:8080 tomcat02:1.1

这一次无需做任何修改，在浏览器访问，就能看到Tomcat的欢迎页面
在这里插入图片描述
这就是使用docker commit命令修改镜像的方法，不过使用该命令还是有些繁琐和局限性，因为docker commit命令的前提是必须有运行当中的容器，而使用DockerFile文件就不需要正在运行的容器，也能自定义创建镜像，在企业实际工作当中，我们也一般使用DockerFile来构建镜像

使用Dockerfile

如果说容器是现成的商品房，镜像就是样板房，那么DockerFile文件就是构建房子的设计图纸，它来规定如何建造地基、铺设水电、开窗搭门等动作

比起容器、镜像来说，Dockerfile 非常普通，它就是一个纯文本，里面记录了一系列的构建指令，比如选择基础镜像、拷贝文件、运行脚本等等，而 Docker 顺序执行这个文件里的所有步骤，最后就会创建出一个新的镜像出来

写Dockerfile文件就像是我们操作Linux系统来部署服务一样，Dockerfile的每个命令基本都有类似功能的Shell命令，大家可以把写Dockerfile当做是手动构建环境和部署应用，把我们在Linux上需要做的事情使用Dockerfile的语法翻译一遍，Dockerfile就基本完成了，这样就很容易理解Dockerfile真正要做的是什么事情了

我们来看一个简单的 Dockerfile 实例：

# 文件名为 Dockerfile

# 选择基础镜像
FROM centos
# 启动容器时默认运行的命令                  
CMD echo "hello world"

写好Dockerfile文件后，使用 docker build 命令来创建出镜像

docker build -f Dockerfile -t "yangzi_centos" .
# 参数含义
-t 镜像名:tag
.  表示当前路径的Dockerfile文件

看到Successfully built信息就说明构建镜像成功了

[root@yangzi work]# docker build -f Dockerfile -t "yangzi_centos" .
Sending build context to Docker daemon  2.048kB
Step 1/2 : FROM centos
 ---> 5d0da3dc9764
Step 2/2 : CMD echo "hello world"
 ---> Using cache
 ---> 5a9ec5ee43d3
Successfully built 5a9ec5ee43d3
Successfully tagged yangzi_centos:latest

使用 docker images 可以查看到刚刚使用Dockerfile构建的镜像

[root@yangzi work]# docker images
REPOSITORY      TAG       IMAGE ID       CREATED         SIZE
yangzi_centos   latest    5a9ec5ee43d3   6 minutes ago   231MB

运行一下这个镜像生成的容器，CMD命令的参数是指定容器启动时要执行的命令，所以这里打印了Hello World

注意在Dockerfile里面允许有多个CMD命令，但只有最后一个会执行（比如有两个CMD命令，只会执行最后一个），另外CMD里命令可以被 docker run 之后的参数替换，如下面在docker run命令追加了ls命令，就只会执行ls命令，不再执行CMD里的echo命令

[root@yangzi work]# docker run -it 5a9ec5ee43d3
hello world

[root@yangzi work]# docker run -it 5a9ec5ee43d3 ls
bin  etc   lib	  lost+found  mnt  proc  run   srv  tmp  var
dev  home  lib64  media       opt  root  sbin  sys  usr

避免这种情况可以在Dockerfile里面使用ENTRYPOINT命令，它就不会像CMD里面的命令一样被覆盖，而是可以docker run时追加命令，具体用法可以百度，这里不再展开

Dockerfile命令总结

在Dockerfile当中，除非上述例子里提到的FROM、CMD、ENTRYPOINT命令，还包含了许多其他命令，下面是一些常用命令总结

FROM：
#指定基础镜像，所有构建的镜像都必须有一个基础镜像，且 FROM 命令必须是 Dockerfile 的第一个命令
FROM <image> [AS <name>] 指定从一个镜像构建起一个新的镜像名字
FROM <image>[:<tag>] [AS <name>] 指定镜像的版本 Tag
示例：FROM mysql:5.0 AS database

MAINTAINER：
#镜像维护人的信息
MAINTAINER <name>
示例：MAINTAINER Yangzi Yangzi@qq.com

RUN：
#构建镜像时要执行的命令，RUN 通常会是 Dockerfile 里最复杂的指令，会包含很多的 Shell 命令，但 Dockerfile 里一条指令只能是一行，所以有的 RUN 指令会在每行的末尾使用续行符 \，命令之间也会用 && 来连接
RUN <command>
示例：RUN [executable, param1, param2]

RUN例子
RUN apt-get update \
    && apt-get install -y \
        build-essential \
        curl \
        make \
        unzip \
    && cd /tmp \
    && curl -fSL xxx.tar.gz -o xxx.tar.gz \
    && tar xzf xxx.tar.gz \
    && cd xxx \
    && ./config \
    && make \
    && make clean

=
ADD：
#将本地服务器的文件添加复制到容器中去，压缩包会解压，可以访问网络上的文件，会自动下载
ADD <src> <dest>
示例：ADD *.js /app 添加 js 文件到容器中的 app 目录下

COPY：
#功能和 ADD 一样（类似linux当中的cp命令），只是复制，不会解压或者下载文件

CMD：
#启动容器后执行的命令，和 RUN 不一样，RUN 是在构建镜像是要运行的命令
当使用 docker run 运行容器的时候，这个可以在命令行被覆盖
示例：CMD [executable, param1, param2]

ENTRYPOINT：
#也是执行命令，和 CMD 一样，只是这个命令不会被命令行覆盖
ENTRYPOINT [executable, param1, param2]
示例：ENTRYPOINT [donnet, myapp.dll]

LABEL：
#为镜像添加元数据，key-value 形式
LABEL <key>=<value> <key>=<value> ...
示例：LABEL version=1.0 description=这是一个web应用

EXPOSE：
#暴露对外的端口（容器内部程序的端口，虽然会和宿主机的一样，但是其实是两个端口）
EXPOSE <port>
示例：EXPOSE 80
容器运行时，需要用 -p 映射外部端口才能访问到容器内的端口

VOLUME：
#指定数据持久化的目录，官方语言叫做挂载
VOLUME /var/log 
#指定容器中需要被挂载的目录，会把这个目录映射到宿主机的一个随机目录上，实现数据的持久化和同步
VOLUME [/var/log,/var/test.....] 
#指定容器中多个需要被挂载的目录，会把这些目录映射到宿主机的多个随机目录上，实现数据的持久化和同步

VOLUME /var/data var/log 
#指定容器中的 var/log 目录挂载到宿主机上的 /var/data 目录，这种形式可以手动指定宿主机上的目录

WORKDIR：
#设置工作目录，设置之后 ，RUN、CMD、COPY、ADD 的工作目录都会同步变更
WORKDIR <path>
示例：WORKDIR /app/test

USER：
#指定运行命令时所使用的用户，为了安全和权限起见，根据要执行的命令选择不同用户
USER <user>:[<group>]
示例：USER test

ENV：
#设置环境变量，有些容器运行时会需要某些环境变量
ENV <key> <value> 一次设置一个环境变量
ENV <key>=<value> <key>=<value> <key>=<value> 设置多个环境变量
示例：ENV JAVA_HOME /usr/java1.8/

ARG：
#设置构建镜像是要传递的参数，ARG指令定义的参数，在docker build命令中以--build-arg a_name=a_value形式赋值
ARG <name>[=<value>]
ARG a_name=sss

ENV与ARG的区别：
ARG 创建的变量只在镜像构建过程中可见，容器运行时不可见，而 ENV 创建的变量不仅能够在构建镜像的过程中使用，在容器运行时也能够以环境变量的形式被应用程序使用

Dockerfile官方文档参考
https://docs.docker.com/engine/reference/builder/

Dockerfile 综合案例

再来看一个Dockerfile文件的综合性例子，用来自定义镜像tomcat，步骤如下

  1. linux终端下新建目录 mkdir -p yangzi/build/tomcat
  2. 在上述目录下新建文件 touch read.txt(此步骤仅仅为了测试Dockerfile 里的COPY命令)
  3. 将 JDK 和 tomcat 安装的压缩包拷贝进上一步目录（ JDK可从Oracle官网下载
    https://www.oracle.com/java/technologies/javase-downloads.html，选择Linux x64 Compressed Archive版本）
    在这里插入图片描述

Apache官网下载Tomcat路径：https://tomcat.apache.org
在这里插入图片描述
下载到本地计算机后，使用FileZilla或者Linux rz命令上传到远程服务器上

  1. 在 /yangzi/build/tomcat 目录下新建一个Dockerfile文件，Dockerfile文件内容如下:
# 需要打上镜像tag,拉取centos 7的镜像
FROM centos:7   
MAINTAINER yangzi<12345678@qq.com> #把宿主机当前上下文的read.txt拷贝到容器/usr/local/路径下
COPY read.txt /usr/local/cincontainer.txt
#把java与tomcat添加到容器中
ADD jdk-18_linux-x64_bin.tar.gz /usr/local/
ADD apache-tomcat-10.0.23.tar.gz /usr/local/
#安装vim编辑器
RUN yum -y install vim
#设置工作访问时候的WORKDIR路径，登录落脚点
ENV MYPATH /usr/local
WORKDIR $MYPATH
#配置java与tomcat环境变量
ENV JAVA_HOME /usr/local/jdk-18.0.2.1
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-10.0.23
ENV CATALINA_BASE /usr/local/apache-tomcat-10.0.23
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin #容器运行时监听的端口
EXPOSE 8080
#启动时运行tomcat，以下3种启动方式任意选择一种，startup.sh底层也是调用了catalina.sh
# ENTRYPOINT ["/usr/local/apache-tomcat-10.0.23/bin/startup.sh" ]
# CMD ["/usr/local/apache-tomcat-10.0.23/bin/catalina.sh","run"]
CMD /usr/local/apache-tomcat-10.0.23/bin/startup.sh && tail -F /usr/local/apache-tomcat-10.0.23/logs/catalina.out

踩坑问题汇总：

（1）在Dockerfile当中，不要直接使用FROM centos命令，会拉取到centos 8镜像，但镜像列表当中会找不到appstream，会报以下错误，所以需要打上tag，使用FROM centos:7命令，拉取 centos7镜像

Step 6/15 : RUN yum -y install vim
 ---> Running in ea1aca98f262
CentOS Linux 8 - AppStream                       62  B/s |  38  B     00:00
Error: Failed to download metadata for repo 'appstream': Cannot prepare internal mirrorlist: No URLs in mirrorlist

（2）有可能大家下载的tomcat和jdk版本跟我在Dockerfile里面写的不一样，在Dockerfile当中，涉及tomcat和jdk版本，均需要进行替换，如对应的压缩包名称，以及环境变量路径

  1. 编译Dockerfile文件，在本目录执行可以不写Dockerfile文件名称，以下命令执行后，会生成一个名为diytomcat的镜像，可以使用docker images查看
docker build -t diytomcat .

看到下面的信息，说明镜像已经构建成功

[root@yangzi tomcat]# docker build -t diytomcat .
Sending build context to Docker daemon  193.1MB
Step 1/15 : FROM centos:7
7: Pulling from library/centos
2d473b07cdd5: Pull complete
Digest: sha256:9d4bcbbb213dfd745b58be38b13b996ebb5ac315fe75711bd618426a630e0987
Status: Downloaded newer image for centos:7
 ---> eeb6ee3f44bd
Step 2/15 : MAINTAINER yangzi<12345678@qq.com> #把宿主机当前上下文的read.txt拷贝到容器/usr/local/路径下
 ---> Running in dedcf313686f
Removing intermediate container dedcf313686f
 ---> 15188be5ddaa

...

Step 14/15 : EXPOSE 8080
 ---> Running in ec11bd1062bf
Removing intermediate container ec11bd1062bf
 ---> 5629d69f3d78
Step 15/15 : CMD /usr/local/apache-tomcat-10.0.23/bin/startup.sh && tail -F /usr/local/apache-tomcat-10.0.23/bin/logs/catalina.out
 ---> Running in 5e71fd77264f
Removing intermediate container 5e71fd77264f
 ---> cdbc8478b7b6
Successfully built cdbc8478b7b6
Successfully tagged diytomcat:latest
  1. docker run命令运行容器
docker run -d -p 9090:8080 --name mydiytomcat -v /root/yangzi/build/tomcat/test:/usr/local/apache-tomcat-10.0.23/webapps/test -v /root/yangzi/build/tomcat/tomcat9logs/:/usr/local/apache-tomcat-10.0.23/logs --privileged=true diytomcat

  • --name 表示容器名

  • -d参数表示后台运行

  • -v 参数后面跟表示本地持久化保存容器数据的挂载目录，挂载目录共有两个，一个是webapps目录下的test服务，另一个是存放log文件，容器里产生的数据会自动同步到本地的指定目录下，即使容器被删除，本地目录还是可以找到相应的数据，防止数据丢失

  • 命令最后的diytomcat表示为镜像名

  • 注意Docker挂载主机目录Docker访问出现cannot open directory .: Permission denied的解决办法:在挂载目录后多加一个--privileged=true参数即可（上面的命令已添加）

  1. 在linux服务器上测试访问 curl localhost:9090，看到正常返回tomcat的HTML网页即可
    在这里插入图片描述

  • 若无法正常返回，可以查看日志目录下文件catalina.out排查问题，路径为/root/yangzi/build/tomcat/tomcat9logs/catalina.out

  • 我自己遇到过下载JDK版本错误（误下载为Arm 64版本，需要下载x64版本），导致无法执行二进制文件/usr/local/apache-tomcat-10.0.23/bin/catalina.sh: line 491: /usr/local/jdk-18.0.2.1/bin/java: cannot execute binary file

  1. 最后可以进行Web服务test的发布，创建WEB-INF目录填写web.xml，添加相应的jsp文件
[root@yangzi test]# pwd
/root/yangzi/build/tomcat/test
[root@yangzi test]# mkdir WEB-INF
[root@yangzi test]# cd WEB-INF
[root@yangzi WEB-INF]# vim web.xml
[root@yangzi WEB-INF]# cd ..
[root@yangzi test]# vim a.jsp

web.xml的内容如下

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
<display-name>test</display-name> 

</web-app>

a.jsp的内容如下

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
  <head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>hello，yangzi</title> </head>
<body>
-----------welcome------------
<%=" my docker tomcat，yangzi "%>
<br>
<br>
<% System.out.println("-------my docker tomcat-------");%>
  </body>
</html>
  1. 在服务器上测试验证test服务curl localhost:9090/test/a.jsp，正常返回jsp当中的内容即可，也可进入本地挂载日志目录/root/yangzi/build/tomcat/tomcat9logs/下，查看tomcat访问日志cat catalina.out

在这里插入图片描述

结束语

本文介绍了使用DockerFile自定义Docker镜像方法，但它始终操作的是单个镜像，并生成单个容器，在实际工作当中，我们需要使用到多个容器（如Mysql容器，Nginx容器等），去部署完整的Web服务，这时候需要用到Docker-Compose容器编排工具，下期继续为大家介绍

学习到这里Docker里面的大部分命令大家都基本使用过了，下篇文章也是Docker系列的最后一篇，会完整的给大家总结Docker命令

这篇文章耗时比较长但干货内容真的很多，坑基本洋子都替大家踩过了，麻烦大家点个【赞】和【在看】，你的支持就是我前进的动力

Bug 挖掘机
关注
专栏目录
dockerfile拉取私库镜像_从私有仓库拉取镜像
weixin_39566593的博客
12-19 1797
从私有仓库拉取镜像浏览 0扫码分享2019-10-27 17:16:54origin_last_modified:2019-06-06 06:18(#14740) 译文原文 英文原文版权声明：本文为 码农文档 原创译文，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。公告：如果您也想加入翻译队伍，或者您有相关中文文档想要贡献给大家，请联系coderdocument@...
dockerfile拉取私库镜像_Dockerfile From 私有库认证问题
weixin_39873356的博客
12-19 2850
一、 写作背景近期折腾 Docker、K8S，在 K8S 集群上搭建了 Harbor 等应用，在使用过程中发现一些问题记录一下。此次问题是向私库传输镜像后，在 dockerfile 中使用该镜像系统报认证错误。二、问题描述在 Dockerfile 内使用自建 Harbor 中的私有镜像，docker build 时，部分运行 Docker 的服务器上出现认证失败的问题，而在同一台服务器上使用 do...
自定义镜像
qq_57907966的博客
08-19 570
外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xXaqwPBd-1660868710785)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20220814165631860.png)]镜像结构：镜像是将应用程序及所需要的系统函数库，环境，配置，依赖打包而成。基于Ubuntu镜像构建一个新的镜像，运行一个java项目。基于java:8-alpine镜像。修改Dockfile。...
Docker 镜像制作（Dockerfile）
m0_74358683的博客
09-17 1290
Dockerfile 是什么？镜像的定制实际上就是定制每一层所添加的配置、文件。如果我们可以把每一层修改、安装、构建、操作的命令都写入一个脚本，用这个脚本来构建、定制镜像,这个脚本就是 Dockerfile。Dockerfile 是一个文本文件，其内包含了一条条的指令(Instruction)， 每一条指令构建一层，因此每一条指令的内容，就是描述该层应当如何构建。为什么需要 Dockerfile？可以按照需求自定义镜像。
Docker——自定义镜像
weixin_51351637的博客
12-08 1578
镜像：将应用程序及其需要的系统函数库、环境、配置、依赖打包而成 镜像是分层结构，每一层称为一个Layer Entrypoint：入口，是镜像中应用启动的命令 其他：在BaseImage基础上添加依赖、安装程序、完成整个应用的安装和配置
自定义镜像-镜像结构
Leon_Jinhai_Sun的博客
11-11 786
Dockerfile自定义镜像 常见的镜像在DockerHub就能找到，但是我们自己写的项目就必须自己构建镜像了。 而要自定义镜像，就必须先了解镜像的结构才行。 镜像结构 镜像是将应用程序及其需要的系统函数库、环境、配置、依赖打包而成。 我们以MySQL为例，来看看镜像的组成结构： 简单来说，镜像就是在系统函数库、运行环境基础上，添加应用程序文件、配置文件、依赖文件等组合，然后编写好启动脚本打包在一起形成的文件。 我们要构建镜像，其实就是实现上述打包的过程。 ...
Docker进阶指南：Dockerfile的编写与优化
最新发布
11-05
使用场景及目标：适用于需要构建和优化Docker镜像的项目，帮助读者掌握Dockerfile的最佳实践，提高镜像的构建速度和安全性。 其他说明：文章还包括详细的调试与测试方法，以及Dockerfile编写时需要注意的一些最佳...
Docker进阶---编写自己的第一个dockerfile并上传到远程仓库
Min_Monk的博客
01-09 432
Dockerfile进阶 编写第一个dockerfile 预期结果：基于CentOS镜像，安装JDK，搭建自己的tomcat镜像 结合上一章节中介绍的全部指令，写了一个dockerfile的Demo，如下： ################################################################################################...
Docker进阶-Dockerfile高阶使用指南及镜像优化
Seven Coding
05-13 667
通过本次 Chat 我们学习到了关于 Docker builder 的概念，以及了解到了下一代版本的 BuildKit；学习了 Docker 19.03 中多实例的构建，以及对构建缓存的垃圾回收配置等；学习了 Dockerfile 的高阶特性，并通过这些特性来管理密码和密钥等信息；学习了如何发现并优化镜像的体积。以上内容中虽然没有具体到它们的全部功能，也没有深入到源码级的分析，但已经涵盖了 Docker 构建系统的最新特性，希望能对你有所帮助。
云原生Docker和K8S 02-Docker进阶
08-08
云原生Docker和K8S 02-Docker进阶 本资源主要讲解了如何使用Jenkins和Docker进行自动化构建和部署，涵盖了从连接服务器到安装Jenkins和Docker的所有步骤。以下是本资源的知识点总结： 1. 连接服务器：使用ssh命令...
【狂神说】Docker【进阶篇】
weixin_46703850的博客
02-07 2680
[【狂神说Java】Docker进阶篇超详细版教程通俗易懂_哔哩哔哩_bilibili](https://www.bilibili.com/video/BV1kv411q7Qc/?spm_id_from=autoNext) 官网：https://www.docker.com/ 文档地址： https://docs.docker.com/ （Docker 官网文档超级详细） 仓库地址：https://hub.docker.com/ 容器单独没有什么意义，有意义的是容器编排
1.1.4 利用Dockerfile 构建私有镜像
weixin_43871142的博客
04-08 162
文章目录使用 Dockerfile 定制镜像FROM 指定基础镜像RUN 执行命令构建镜像Dockerfile 指令详解COPY 复制文件ADD 更高级的复制文件CMD 容器启动命令ENTRYPOINT 入口点ENV 设置环境变量ARG 构建参数VOLUME 定义匿名卷EXPOSE 声明端口WORKDIR 指定工作目录原因USER 指定当前用户HEALYHCHECK 健康检查ONBUILD 为他人...
Docker运维教程（5）本地镜像制作与dockerfile
weixin_42073629的博客
05-20 2475
虽然Docker仓库中提供了大量镜像，但是当我们找不到现成镜像或者需要在镜像中满足特定功能时，就需要自己来制作一套镜像。Docker提供了三种制作镜像的方式：docker save/load、docker commit命令和Dockerfile构建文件 一、使用Docker save保存本地镜像 该方式可以直接将本地已经做好的镜像保存好，然后在另外的主机上载入，如下： docker save -o myimages.gz tanglu/centos:v1.1 tanglu/nginx:v14 #保
32、自定义镜像
weixin_40968009的博客
11-12 355
通过 Dockerfile 自定义镜像
如何指定dockerfile中From后的基础镜像从本地获取
muwan2900的博客
06-17 3777
在 Dockerfile 中，FROM指令用于指定基础镜像。如果你想要指定从本地获取基础镜像，而不是从远程仓库（如 Docker Hub）拉取，你可以使用命令的参数配合ARG指令在Dockerfile中动态设置FROM指令。以下是具体步骤：首先确保你已经在本地拥有想要使用的镜像。在 Dockerfile 中，使用ARG指令定义一个参数，然后用该参数作为FROM指令的一部分。
Docker(二) 自定义镜像
笑不语的博客
07-02 264
一、前言 记得上半年有一个需求是给服务(mysql)兼容oracle数据库，之前没有怎么接触过oracle数据库，也没有安装过，于是从同事那里要来了安装包（windows）的，结果按照步骤安装了好久也启动不起来，然后想卸载掉安装到虚拟机中，按照步骤卸载也卸载不掉，至今还保留在公司的电脑上，恶心的要死。 后来经过公司同事的介绍就开始使用docker了，别说还真的很方便，只要下载oracle镜像，然后通过该镜像创建容器，开箱即用，非常方便。之后陆续下载了redis、mysql、mycat、tomcat和zook
15-自定义镜像-镜像结构
m0_63464979的博客
06-11 269
1.镜像结构镜像是将应用程序及其需要的系统函数库、环境、配置、依赖打包而成。​ 入口（Entrypoint）：镜像运行入口，一般是程序启动的脚本和参数​ 层（ Layer ）：在BaseImage基础上添加安装包、依赖、配置等，每次操作都形成新的一层。​ 基础镜像（BaseImage）：应用依赖的系统函数库、环境、配置、文件等解释：“镜像是将应用程序及其需要的系统函数库、环境、配置、依赖打包而成。
Dockerfile自定义镜像
weixin_57128596的博客
05-11 473
目录 镜像结构 什么是Dockerfile 常见的镜像在DockerHub能找到，但是我们自己写项目得自己构造镜像； 镜像结构 作用：提高复用性，当应用需要更新时，不再是整个系统重装进行更新，而是对需要更新的部分进行更新，其他地方不动——>这就是分层的好处 每做一次新的操作会产生新的一层 简单来说，镜像就是在系统函数库、运行环境的基础上添加应用程序文件、配置文件，然后合并后+编写好的启动脚本（镜像运行的入口）一起形成的文件 所以说，构建镜像，就是实现上述打包过程；...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Bug 挖掘机

支持洋子

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值