dockerfile文件编写,dockerfile不配置基础镜像

dockerfile文件编写,dockerfile不配置基础镜像详细介绍

本文目录一览： 如何基于docker构建和发布Python应用程序？

Docker是一个开源的容器平台，可以用于构建、发布和运行Python应用程序。下面是一个大致的构建和发布Python应用程序的步骤：
构建Docker镜像：首先需要构建Docker镜像，它是用于打包应用程序及其所有依赖项的容器。Docker镜像是通过Dockerfile定义的，Dockerfile是一个文本文件，包含了容器如何被构建的说明。
在Docker中运行应用程序：通过运行Docker镜像创建Docker容器，在Docker容器中运行Python应用程序。
发布Docker镜像：将Docker镜像上传到Docker仓库，供他人使用。可以使用Docker Hub或私有Docker仓库等。
部署Docker容器：将Docker镜像从仓库下载到生产环境，并在生产环境中运行Docker容器，以部署Python应用程序。
这些步骤可以通过脚本自动化来完成，例如使用CI/CD工具（如Jenkins、Travis CI等）。这样，每次代码提交时，可以自动构建、测试、发布和部署应用程序，从而实现快速和高效的交付。
基于 Docker 构建和发布 Python 应用程序通常需要以下步骤：
编写 Python 应用程序代码。可以使用任何你熟悉的 Python 框架，如 Flask、Django 等。
创建一个 Dockerfile，用于定义 Docker 镜像的构建过程。在 Dockerfile 中，需要指定基础镜像、安装 Python 库、将应用程序代码复制到镜像中等操作。以下是一个示例 Dockerfile：
# 使用 Python 3.9 作为基础镜像
FROM python:3.9
# 设置工作目录
WORKDIR /app
# 复制应用程序代码到镜像中
COPY . /app
# 安装依赖库
RUN pip install --no-cache-dir -r requirements.txt
# 暴露端口号
EXPOSE 8000
# 设置启动命令
CMD ["python", "app.py"]
构建 Docker 镜像。在 Dockerfile 所在的目录下，运行以下命令：
docker build -t my-python-app .
其中，my-python-app 是镜像的名称，. 表示使用当前目录中的 Dockerfile 进行构建。构建完成后，你可以使用以下命令查看镜像列表：
docker images
运行容器。在运行容器时，你需要指定容器名称、端口映射等参数。以下是一个示例命令：
docker run -d --name my-app -p 8000:8000 my-python-app
其中，my-app 是容器的名称，8000:8000 表示将容器的 8000 端口映射到宿主机的 8000 端口，my-python-app 是镜像的名称。
访问应用程序。运行容器后，你可以在浏览器中访问应用程序。如果应用程序使用了 Flask 等框架，你需要在应用程序代码中指定监听的端口号为 0.0.0.0。
以上就是基于 Docker 构建和发布 Python 应用程序的一般步骤。需要注意的是，在实际应用中，可能还需要进行日志管理、数据备份等操作，以确保应用程序的可靠性和安全性。

docker如何编写网页？

pull一个web服务器
例如nginx
后面启动一下nginx
启动容器
用vim编辑 html文件
把文件传到nginx容器内
完工
Docker 是一种流行的容器化技术，可以帮助开发人员快速创建和部署应用程序。如果您想在 Docker 中编写网页，可以按照以下步骤：
1. 选择一个适合您的 Web 开发框架，例如 Node.js、Ruby on Rails 或 Flask 等。
2. 创建一个 Dockerfile 文件，用于构建 Docker 镜像。您可以在 Dockerfile 中指定所需的操作系统、安装所需的软件包、将应用程序复制到容器中等。
3. 在 Dockerfile 中设置端口映射。这将允许您将容器内部的端口映射到主机上的端口，以便您可以通过 Web 浏览器访问您的网页。
4. 在 Dockerfile 中设置 CMD 指令，以便在容器启动时运行您的应用程序。
5. 使用 docker build 命令构建 Docker 镜像。
6. 使用 docker run 命令启动 Docker 容器，并将主机端口与容器端口进行映射。
7. 在 Web 浏览器中访问您的网页，以确保它可以正常工作。
需要注意的是，Docker 可以帮助您轻松地创建和部署应用程序，但是网页的编写和设计仍然需要您自己完成。

jar包打成docker镜像部署

1.编写dockerfile文件

内容如下：

FROM openjdk:8-jdk-alpine

VOLUME /tmp

ADDruoyi-auth.jar app.jar

ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]

2.把可运行jar放在与dockerfile同一文件夹下，如图:

3.linux进入到这个目录下，开始执行打镜像命令:(注意下边最后那个.前边有个空格)

docker build -t ruoyi/ruoyi-auth:latest .

4.运行镜像

docker run -d --restart=always --name ruoyi-auth -p 9001:9001 ruoyi/ruoyi-auth

查看日志是否运行成功

docker logs -f ruoyi-auth

DockeFIile知识点总结和发布自己的镜像

1. dockerfile 的基本定义
2. dockerfile 的基本结构
3. dockerfile 的常用指令
FROM :指定基础镜像,必须是第一个命令
MAINTAINER :维护者信息
RUN :构建镜像时执行的命令
ADD :将本地文件添加到容器中
COPY 功能和 ADD 类似,区别如下
CMD :构建容器这后使用
ENTRYPOINT :配置容器,与CMD类似
LABEL :用于为镜像添加元数据
ENV :设置环境变量
EXPOSE :指定与外界交互的端口
VOLUME :用于指定持久化目录
WORKDIR :工作目录,类似于 CD 命令
USER :指定运行容器时的用户名或UID,后面的RUN也会使用指定用户,当服务不需要管理员权限时,可以通过该命令指定运行用户
ARG :用于指定传递给构建运行时的变量
ONBUILD :用于设置镜像触发器
编写dockerfile文件
通过dockerfile构建镜像
查看镜像构建的过程,可以使用 docker history 镜像id 来查看
创建完命名空间后，打开镜像仓库，创建镜像仓库，选择本地仓库
根据官方给的文档开始提交就可以，这里就不截图了

详解Docker——你需要知道的Docker进阶知识五

Dockerfile 是一个文本文件，其中包含了构建 Docker 镜像需要执行的命令序列。使用 docker build 命令从 Dockerfile 中读取指令来构建镜像。

构建镜像时，该过程的第一件事是将 Dockerfile 文件所在目录下的所有内容发送给 Docker 守护进程。所以大多数情况下，最好创建一个新的目录，在其中保存 Dockerfile ，以及构建镜像所需的其它文件。Dockerfile 文件所在目录也被称为构建上下文（context）。

使用 FROM 指令指定一个基础镜像，后续指令将在此镜像基础上运行：

在 Dockerfile 中可以指定一个用户，后续的 RUN ， CMD 以及 ENTRYPOINT 指令都会使用该用户身份去执行，该用户必须已存在。

除了指定用户之外，还可以使用 WORKDIR 指定当前工作目录（CWD）， RUN ， CMD ， COPY ， ADD 指令将在指定的工作目录中执行。

RUN 指令用于执行命令，该指令有两种形式：

例如我们执行更新命令：

CMD 的使用方式跟 RUN 类似，不过在一个 Dockerfile 文件中只能有一个 CMD 指令，如果有多个，则只有最后一个会生效。该指令指定了启动容器时要执行的命令，例如：

可以在 docker run 时指定命令来覆盖默认的 CMD 命令，比如 docker run image echo"hello shiyanlou" 。

CMD 指令还有一种特殊用法。在 Dockerfile 中，如果使用 ENTRYPOINT 指令指定了入口命令，则 CMD 指令的内容会作为 ENTRYPOINT 指令的参数：

ENTRYPOINT 指令会覆盖 CMD 指令作为容器运行时的默认指令，并且该指令不会被 docker run 时指定的指令覆盖，如下示例：

上述文件构建出来的镜像，使用 docker run image 等同于 docker run image ls-a-l 。使用 docker run image-i-s 等同于 docker run image ls-a-i-s 。即 CMD 指令的值会被当作 ENTRYPOINT 指令的参数附加到 ENTRYPOINT 指令的后面，只有 CMD 指令可以被覆盖。

COPY 和 ADD 都用于将构建上下文中的文件，目录等复制到镜像中。使用方式如下：

`` 可以指定多个，但是其路径不能超出构建上下文范围，即必须在 Dockerfile 同级或子目录中。

不需要预先存在，不存在时会自动创建，如果使用相对路径，则 为相对于工作目录的路径。

COPY 和 ADD 的不同之处在于，ADD 可以添加远程文件，并且 `` 可以是 gzip 或 tar 等格式的压缩文件，添加时会自动进行解压。

ENV 指令用于设置环境变量：

VOLUME 指令指定要创建的挂载路径，在容器运行时，将为每个挂载路径创建一个匿名卷并挂载上去：

上述指令将会在容器运行时，创建两个匿名卷，并分别挂载到容器中的 /data1 和 /data2 路径。

学习了上面这些常见的 Dockerfile 指令之后，可以使用这些指令来构建一个镜像。如下所示，构建一个提供 ssh 服务的镜像:

构建镜像

查看镜像

启动容器

查看已经启动的容器

测试远程登录

Compose 是运行由多个容器组成的 Docker 应用的工具，使用 Compose 可以一次启动一组有关联的服务，每个服务由来自同一镜像的单个或多个容器组成。

在复杂应用中，应用一般由多个服务（service）组成，例如一个网站后台通常包含 Web 服务、数据库服务、缓存服务、消息队列服务等。

使用 Compose 的步骤如下：

目前有三种版本的 Compose 文件格式：

下载 docker-compose-Linux-x86_64

下载成功后，为了方便使用，可以将其添加到 PATH 路径下

执行完成后，就能够在终端下直接使用 docker-compose 命令了：

接下来我们将创建一个 Web 应用，该应用包含两个容器：

项目目录结构如下：

首先编辑 app/web/web.py 文件，写入下面的内容：

上述代码创建了一个简单的 Web 应用。该应用会连接 redis 服务，在访问 / 页面时，自动将变量 number 加 1。

编辑 app/web/requirements.txt 文件，输入如下内容：

requirements.txt 文件存放了 Web 应用依赖的第三方库包的名称和版本信息。

编辑 app/web/Dockerfile 文件，添加如下内容

上述 Dockerfile 定义了 Web 应用镜像，该镜像基于 python:2.7 基础镜像，在其基础上安装了应用依赖的库包，并通过 CMD 指令指定了应用的启动命令。

编辑 app/docker-compose.yml 文件：

该 docker-compose.yml 文件定义了两个服务，分别为 web 和 redis 服务，并且配置了 web 服务的端口映射和挂载目录。 depends_on 定义了依赖关系，被依赖的服会先启动。

进入 app 目录，执行 docker-compose up 命令来启动应用：

启动成功后，就可以打开网址 127.0.0.1:8001 来访问 Web 应用了。

另外一些命令：

dockerfile不配置基础镜像

当想让一个容器做两件事情，或者使一个Docker镜像包含来自两个不同镜像的依赖库时，就需要知道每个镜像的Dockerfile。本文介绍了如何通过dockerhistory命令来对Docker镜像进行反向工程，得到它们的Dockerfile，并组织到一个Dockerfile里然后build，从而实现想做的事情。
常言道，“不要重复发明轮子！”
在使用Docker时，构建自己的镜像之前，最好在DockerHub寻找一些可以直接使用的镜像做练习。把软件架构分布到一系列容器中，每一个容器只做一件事情，这样的效果非常好。构建分布式应用的最好的基石是使用来自DockerHub的官方镜像，因为可以信任它们的质量。
在某些情况下，可能想让一个容器做两件不同的事情。而在另外一些情况下，可能想让一个Docker镜像包含来自两个不同镜像的依赖库。如果有每个镜像的Dockerfile，这是非常简单的。将它们组织到一个Dockerfile里然后build就行。
然而，大多数时间都在使用DockerHub上准备好的镜像，不会有它们的源Dockerfile。我花时间找一个可以合并（或flatten）两个不同Docker镜像的工具，当然没有它们的Dockerfile。也就是说在找一个能做下面这件事的东西：
image1--

--->merged_image_12
/
image2--
此前在GitHub上有两个相关的讨论（1、2），尽管它们都被关闭了。
这可能吗？
那么，是否存在工具能够像这样做吗：dockermergeimage2image2merged_image？
没有！
你甚至不可以用下面的方式来构建Dockerfile：
FROMimage1
FROMimage2
简而言之，在一个Dockerfile里不能有多个基础镜像。
但是我需要这个功能！
唯一的解决办法是取得这些镜像的Dockerfile，然后把它们组织到一个文件中，再进行构建。那么，我能在DockerHub上获得一个镜像的Dockerfile吗？幸运的是可以。它不能离线获取（译注：原文是online，但显然online时对于来自GitHub的自动构建镜像是可以直接获取的），但是你可以使用dockerhistory命令，通过反向工程获取。
怎么来使用？
在你的机器上使用dockerpull从DockerHub下载镜像。
dockerpullimage1
dockerpullimage2
然后使用dockerhistory来取得构建这两个容器时运行的命令。
dockerhistory--no-trunc=trueimage>image1-dockerfile
dockerhistory--no-trunc=trueimage2>image2-dockerfile
接下来打开这两个文件，你可以看到每个镜像的命令堆栈。这是因为Docker镜像通过层（阅读更多）的方式来构建。即你在Dockerfile中键入的每一个命令所构建的新镜像，都是在之前的命令产生的镜像之上。所以你可以对镜像进行逆向工程。
限制
不能对镜像进行反向工程的唯一场景，是镜像的维护者在他的Dockerfile中使用了ADD或COPY命令。你会看到这样一行：
ADDfile:1ac56373f7983caf22
或ADDdir:cf6fe659e9d21535844
这是因为不知道维护者在他自己的机器上，包括镜像里使用了什么本地文件。

超值一篇分享，Docker：从入门到实战过程全记录

作者 | 天元浪子
来源 | CSDN博客
想要真正理解Docker，就不得不从虚拟化技术的发展历程说起。普遍认为虚拟化技术经历了物理机时代、虚拟机时代，目前已经进入到了容器化时代。可以说，Docker是虚拟化技术不断发展的必然结果。
那么，什么是容器呢？容器和虚拟机有什么不同？Docker和容器又是什么关系呢？搞明白这几个问题，Docker的概念就清晰了。
1.1 虚拟机和容器
借助于VMWare等软件，可以在一台计算机上创建多个虚拟机，每个虚拟机都拥有独立的操作系统，可以各自独立的运行程序。这种分身术虽然隔离度高（操作系统级），使用方便（类似物理机），但占用存储资源多（GB级）、启动速度慢（分钟级）的缺点也是显而易见的。
相较于虚拟机，容器（Container）是一种轻量型的虚拟化技术，它虚拟的是最简运行环境（类似于沙盒）而非操作系统，启动速度快（秒级）、占用存储资源少（KB级或MB级），容器间隔离度为进程级。在一台计算机上可以运行上千个容器，这是容器技术对虚拟机的碾压式优势。
1.2 容器、镜像和Docker
Docker是一个开源的应用容器引擎，可以创建容器以及基于容器运行的程序。Docker可以让开发者打包他们的应用和依赖包到一个轻量级、可移植的容器中，然后发布到任何流行的Linux机器上，也可以实现虚拟化。
听起来很简单，但是在Docker和容器之间，还隐藏着一个镜像的概念，令初学者颇感困惑。本质上，Docker镜像是一个特殊的文件系统，它提供容器运行时所需的程序、库、资源、配置等文件。Docker镜像类似于一个py文件，它需要Docker的运行时（类似于Python解释器）运行。镜像被运行时，即创建了一个镜像的实例，一个实例就是一个容器。
1.3 Docker 和 k8s
作为容器引擎，Docker为容器化的应用程序提供了开放的标准，使得开发者可以用管理应用程序的方式来管理基础架构，实现快速交付、测试和部署代码。随着容器的大量使用，又产生了如何协调、调度和管理容器的问题，Docker的容器编排应运而生。
k8s是Google开源的一个容器编排引擎，它支持自动化部署、大规模可伸缩、应用容器化管理，是一个开源的，用于管理云平台中多个主机上的容器化的应用，k8s的目标是让部署容器化的应用简单并且高效，k8s提供了应用部署、规划、更新、维护的一种机制。
Docker和k8sr都是以containerd（容器化标准）作为运行时，因此使用Docker创建的镜像完全可以在k8s中无障碍的使用。

2.1 在ubuntu中安装
在linux系统中安装Docker非常简单，官方为我们提供了一键安装脚本。这个方法也适用于Debian或CentOS等发行版。
安装过程如果出现超时，不要灰心，多试几次，总会成功的。安装完成后，Docker只能被root用户使用，可以使用下面的命令取消权限限制：
然后，重启docker服务：
最后，关闭当前的命令行，重新打开新的命令行就可以了。
顺便提一下，如果在CentOS下安装，可能会出现一堆类似于下面的错误：
这是由于docker和Podman冲突造成的，需要先卸载Podman：
2.2 在Win10中安装
Docker的运行，依赖linux的环境，官方提供了Docker Desktop for Windows，但是它需要安装Hyper-V，Hyper-V是微软开发的虚拟机，类似于 VMWare 或 VirtualBox，仅适用于 Windows 10。这个虚拟机一旦启用，QEMU、VirtualBox 或 VMWare Workstation 15 及以下版本将无法使用！如果你必须在电脑上使用其他虚拟机（例如开发 Android 应用必须使用的模拟器），请不要使用 Hyper-V！
我的电脑是win10家庭版，不能直接安装hyper-v，需要将下面的命令保存到cmd文件中：
然后在cmd文件上点击右键，选择使用管理员运行。执行完毕后会重启，在重启的过程中进行安装。
2.3 Hello world
docker服务启动的情况下，运行下面的命令：
此命令的含义是：
第一次运行时，因为本地没有ubuntu:20.04镜像，docker会自动从镜像服务器下载。下载过程可能需要多试几次，只要成功一次，以后执行就不再需要下载了。
docker官方还提供了一个hello-world镜像，可以直接运行：
此命令省略了镜像版本和运行参数，docker使用latest作为版本，即最新版本。
从hello world的例子中，也可以体验到，docker实例的运行是非常快的。

docker官方的镜像库比较慢，在进行镜像操作之前，需要将镜像源设置为国内的站点。
新建文件/etc/docker/daemon.json，输入如下内容：
然后重启docker的服务：
3.1 列出本地所有镜像
执行命令 docker images 可以查看
当前我本地只有刚才安装的两个镜像。
3.2 从镜像库中查找镜像
执行命令 docker search 镜像名称可以从docker镜像库中查找镜像。
最好选择官方（OFFICIAL）的镜像，这样的镜像最稳定一些。
3.3 下载新的镜像
执行命令docker pull 镜像名称:版本号即可下载新的镜像。
镜像下载后，就可以使用镜像来创建容器了。

4.1 启动容器
执行命令docker run即可启动容器，也就是创建某个镜像的实例。docker run命令非常复杂，可以先执行一个docker run --help来查看帮助：
比如我们要执行python的shell，需要添加-it参数，即：docker run -it python:3.8
4.2 将宿主机的文件挂载到容器
docker容器与宿主机是隔离的，要想让容器内的程序能访问宿主机上的文件，需要通过-v参数将宿主机的文件挂载到容器中。
比如我们在宿主机上有一个hello.py，可以打印hello，想要在python容器中执行，就需要进行挂载。-v后还需要接两个参数，分别是宿主机的目录和容器内的目录，两者使用:分隔，路径必须都是绝对路径。
我的hello.py保存在主目录的/docker_test目录中，将这个目录挂载到容器的/docker_test目录，然后在容器内执行python /docker_test/hello.py：
4.3 容器的端口映射
我们修改一下hello.py，创建一个socket服务端，并监听5000端口，当有客户端连接时，打印客户端的地址，先客户端发送hello，然后关闭连接：
在容器内执行：
接下来，尝试用telnet命令连接，结果却是失败的。原因是，127.0.0.1是宿主机的ip地址，5000是容器的端口，这与我们的习惯稍微有些不同。事实上，docker的容器是非常轻量的，它并没有自己的网络，要想访问容器的端口，需要进行端口映射，将容器的某端口映射到宿主机的端口，客户端连接时，只要与宿主机的端口进行连接就可以了。
需要注意的是，上面的代码创建的服务器，无论如何也不可能被客户端连接，因为代码中绑定了127.0.0.1的ip，在容器中运行时，需要绑定所有ip，即0.0.0.0。
然后，再使用-p参数，-p还需要三个参数，即宿主机的ip地址、宿主机的端口、容器的端口，三者之间使用:分隔。一般的，可以将宿主机的ip地址省略，只写宿主机的端口：容器的端口即可。
这样，就将容器的5000端口映射到了宿主机的5001端口，使用：
即可与容器中的服务器进行连接。
4.4 容器管理
上面的服务运行之后，可以使用docker ps命令，查看运行中的容器：
显示的内容有下面几列：
要想结束容器，可以使用docker kill 容器ID命令。

一般而言，当我们的程序开发完成后，会连同程序文件与运行环境一起制作成一个新的镜像。
要制作镜像，需要编写Dockerfile。DockeFile由多个命令组成，常用的命令有：
注意，Docker镜像中有一个层的概念，每执行一个RUN命令，就会创建一个层，层过多会导致镜像文件体积增大。尽量在RUN命令中使用&&连接多条shell命令，减少RUN命令的个数，可以有效减小镜像文件的体积。
5.1 自制显示文本文件内容镜像
编写cat.py，接收一个文件名，由python读取文件并显示文件的内容：
这个例子比较简单，缩写Dockerfile如下：
这个Dockerfile的含义是：
需要说明的是，ENTRYPOINT有两种写法：
这里采用第二种写法，是因为我们要在外部给容器传递参数。执行命令编译Docker镜像：
这个命令中，-t的含义是目标，即生成的镜像名为hello，版本号为1.0，别忘了最后那个.，这叫到上下文路径，是指 docker 在构建镜像，有时候想要使用到本机的文件（比如复制），docker build 命令得知这个路径后，会将路径下的所有内容打包。
这样，我们的第一个镜像就制作完成了，使用下面的命令执行它：
即可看到~/docker_test/cat/files/test.txt的内容。
5.2 自制web服务器镜像
我们使用tornado开发一个网站，而python的官方镜像是没有tornado库的，这就需要在制作镜像时进行安装。
测试的ws.py如下：
编写Dockerfile文件如下：
在此我们验证一下CMD与ENTRYPOINT的区别。在Dockerfile所在有目录下执行如下命令：
执行完成后，再使用docker images使用就可以看到生成的镜像了，然后使用下面的命令运行：
在浏览器中输入宿主机的ip和8000端口，就可以看到页面了。
在这个例子中，我使用的运行命令是CMD，如果在docker run中指定的其他的命令，此命令就不会被执行，如：
此时，容器中被执行的是python命令，而不是我们的服务。在更多情况下，我们希望在docker run命令中为我们的服务传参，而不是覆盖执行命令，那么，我们应该使用ENTRYPOINT而不是CMD：
上面这种写法，是不支持传递参数的，ENTRYPOINT和CMD还支持另一种写法：
使用这种写法，docker run命令中的参数才可以传递给hello.py：
这个命令中，--port=9000被作为参数传递到hello.py中，因此容器内的端口就成了9000。
在生产环境中运行时，不会使用-it选项，而是使用-d选项，让容器在后台运行：
这种方式下，即使当前的控制台被关闭，该容器也不会停止。
5.3 自制apscheduler服务镜像
接下来，制作一个使用apscheduler编写的服务镜像，代码如下：
Dockerfile也是信手拈来：
生成镜像：
应该可以运行了，文件复制需要两个目录，在运行时，可以使用两次-v来挂载不同的目录：

前面用到的官方python镜像大小足足882MB，在这个基础上，再安装用到的第三方库，添加项目需要的图片等资源，大小很容易就超过1个G，这么大的镜像，网络传给客户非常的不方便，因此，减小镜像的体积是非常必要的工作。

docker hub上有个一python:3.8-alpine镜像，大小只有44.5MB。之所以小，是因为alpine是一个采用了busybox架构的操作系统，一般用于嵌入式应用。我尝试使用这个镜像，发现安装一般的库还好，但如果想安装numpy等就会困难重重，甚至网上都找不到解决方案。
还是很回到基本的路线上来，主流的操作系统镜像，ubuntu的大小为72.9MB，centos的大小为209MB——这也算是我更喜欢使用ubuntu的一个重要原因吧！使用ubuntu作为基础镜像，安装python后的大小为139MB，再安装pip后的大小一下子上升到了407MB，要是再安装点其他东西，很容易就赶上或超过python官方镜像的大小了。
看来，寻常路线是很难压缩镜像文件体积了。幸好，还有一条曲线救国的路可走，这就是多阶段构建法。
多阶段构建的思想其实很简单，先构建一个大而全的镜像，然后只把镜像中有用的部分拿出来，放在一个新的镜像里。在我们的场景下，pip只在构建镜像的过程中需要，而对运行我们的程序却一点用处也没有。我们只需要安装pip，再用pip安装第三方库，然后将第三方库从这个镜像中复制到一个只有python，没有pip的镜像中，这样，pip占用的268MB空间就可以被节省出来了。
1、在ubuntu镜像的基础上安装python：
然后运行：
这样，就生成了python:3.8-ubuntu镜像。
2、在python:3.8-ubuntu的基础上安装pip：
然后运行：
这样，就生成了python:3.8-ubuntu-pip镜像。
3、多阶段构建目标镜像：
这个dockerfile需要解释一下了，因为它有两个FROM命令。
第一个是以python:3.8-ubuntu-pip镜像为基础，安装numpy，当然，在实际应用中，把所有用到的第三方库出写在这里。
第二个FROM是以FROM python:3.8-ubuntu镜像为基础，将第三方库统统复制过来，COPY命令后的–from=0的意思是从第0阶段进行复制。实际应用中再从上下文中复制程序代码，添加需要的ENTRYPOINT等。
最后，再运行：
这然，用于我们项目的镜像就做好了。比使用官方python镜像构建的版本，小了大约750MB。

到此，我们的镜像已经制作好了，可是，镜像文件在哪，如何在生产环境下运行呢？
刚才使用docker images命令时，已经看到了生成的镜像：
我们可以使用docker save命令将镜像保存到指定的文件中，保存的文件是一个.tar格式的压缩文件：
将hello.tar复制到生产环境的机器上，然后执行导入命令：
就可以使用了。

docker镜像构建

基本的构建命令为： docker build -t name:tag -f Dockerfile .
-t : 表示构建出来的镜像名称
-f : 表示构建使用的dockerfile文件名称
. : 表示构建使用当前路径作为上下文（contex），如果你是在根目录 / 下面构建，不建议使用 . （不建议使用根路径作为上下文），因为根路径下面有虚拟文件系统，如 /proc 之类的，构建的时候会报找不到文件的错误。

镜像构建流程为首先将指定的上下文（contextpath）路径下的文件打包，发送到服务端。服务端再将收到的文件解压，然后以解压后的路径作为上下文，进行镜像构建。

docker构建命令中如果没有以 -f 指定Dockerfile，则以上下文中的Dockerfile文件作为构建文件；如果通过 -f 指定了Dockerfile文件路径及名称，则在构建上下文中寻找指定的文件。

docker build的时候，如果某一层无法使用上一次的构建缓存，则后续层均无法使用，故若大多数层均未改变，建议将未改动的层放在前面。如 RUN apt get install -y tmux 命令，如果tmux版本有变化，则无法继续使用构建缓存，建议将该语句放到后面。
参考： https://blog.orenoid.com/2019/12/17/docker-build-optimize/ 。
--no-cache=true 可以不使用缓存，不知道能否解决构建时提示缓存不足的问题。

可以直接编译得到最终镜像： docker build -t go/helloworld:3 .

也可以只构建 builder 阶段的镜像： docker build --target builder -t username/imagename:tag .

构建时，可以复制上一阶段的镜像中的文件，也可以复制任意镜像中的文件。

COPY --from=nginx:latest /etc/nginx/nginx.conf /nginx.conf

as 后面的名字可以任意填写，主要作用是作为一个标识，方便单独构建其中一个镜像，或者是其他镜像从中获取部分文件。

参考： https://yeasy.gitbook.io/docker_practice/image/multistage-builds/laravel

没有守护进程，不需要 root 特权，而且生成的是符合 OCI 的镜像，因此你的镜像的运行方式与使用 Docker 构建的镜像完全相同。它还能使用 Dockerfile 或 Containerfile 构建镜像， Dockerfile 与 Containerfile 实际上是同一个东西，只是叫法不同罢了。除此之外，Buildah 还提供了对镜像层更精细的控制，支持提交大量的变更到单个层。我认为，它与 Docker 之间有一个出乎意料的区别（但这个区别是好事），那就是使用 Buildah 构建的镜像特定于用户，因此你可以只列出自己构建的镜像。

Google 发布了“ Kaniko ”，一种用于在未授权容器或 Kubernetes 集群中构建容器镜像的开源工具。虽然 Kaniko 也是根据用户给定的 Dockerfile 构建镜像，但是并不依赖于 Docker 守护进程，而是在用户空间中完全执行每个命令，并对所导致的文件系统更改做快照。一般多用于在流水线中执行的编译构建。它与 Buildah 的主要区别在于，Kaniko 更加侧重于 Kubernetes 中的镜像构建。

另外需要制定镜像仓库名字，从而自动推送到目标仓库。

--context ：指定构建上下文（可以挂载本地目录，也可以指定git地址，如 git://github.com/mycorp/my-app.git ），

--destination ：指定要推送的仓库地址，

--dockerfile ：指定dockerfile文件。存在一个问题是，tag是写死的，每次得到的镜像会覆盖。

k8s中使用： https://segmentfault.com/a/1138003484

并行构建、跳过未使用的阶段、更好的增量构建以及不需要 root 权限等构建。但是，它仍然需要运行守护进程 (buildkitd)。因此，如果你不想摆脱 Docker，同时又想要一些新的功能和改进，那么可以考虑一下 buildkit。

如何编写 docker dockerfile

如何使用
Dockerfile用来创建一个自定义的image,包含了用户指定的软件依赖等。当前目录下包含Dockerfile,使用命令build来创建新的image,并命名为edwardsbean/centos6-jdk1.7:
docker build -t edwardsbean/centos6-jdk1.7 .
Dockerfile关键字
如何编写一个Dockerfile,格式如下：
# CommentINSTRUCTION arguments
FROM
基于哪个镜像
RUN
安装软件用
MAINTAINER
镜像创建者
CMD
container启动时执行的命令，但是一个Dockerfile中只能有一条CMD命令，多条则只执行最后一条CMD.
CMD主要用于container时启动指定的服务，当docker run command的命令匹配到CMD command时，会替换CMD执行的命令。如:
Dockerfile:
CMD echo hello world
运行一下试试:
edwardsbean@ed-pc:~/software/docker-image/centos-add-test$ docker run centos-cmd
hello world
一旦命令匹配：
edwardsbean@ed-pc:~/software/docker-image/centos-add-test$ docker run centos-cmd echo hello edwardsbean
hello edwardsbean
ENTRYPOINT
container启动时执行的命令，但是一个Dockerfile中只能有一条ENTRYPOINT命令，如果多条，则只执行最后一条
ENTRYPOINT没有CMD的可替换特性
USER
使用哪个用户跑container
如：
ENTRYPOINT ["memcached"]
USER daemon
EXPOSE
container内部服务开启的端口。主机上要用还得在启动container时，做host-container的端口映射：
docker run -d -p 127.0.0.1:33301:22 centos6-ssh
container ssh服务的22端口被映射到主机的33301端口
ENV
用来设置环境变量，比如：
ENV LANG en_US.UTF-8
ENV LC_ALL en_US.UTF-8
ADD
将文件

拷贝到container的文件系统对应的路径

所有拷贝到container中的文件和文件夹权限为0755,uid和gid为0

如果文件是可识别的压缩格式，则docker会帮忙解压缩

如果要ADD本地文件，则本地文件必须在 docker build

，指定的

目录下

如果要ADD远程文件，则远程文件必须在 docker build

，指定的

目录下。比如:

docker build github.com/creack/docker-firefox

docker-firefox目录下必须有Dockerfile和要ADD的文件

注意:使用docker build - < somefile方式进行build，是不能直接将本地文件ADD到container中。只能ADD

url file.

ADD只有在build镜像的时候运行一次，后面运行container的时候不会再重新加载了。

VOLUME

可以将本地文件夹或者其他container的文件夹挂载到container中。

WORKDIR

切换目录用，可以多次切换(相当于cd命令)，对RUN,CMD,ENTRYPOINT生效

ONBUILD

ONBUILD 指定的命令在构建镜像时并不执行，而是在它的子镜像中执行