如何开发一个基于 Docker 的 Python 应用（开发docker教程）

25-02-13 21

在这篇文章中，我们将为您详细介绍如何开发一个基于Docker的Python应用的内容，并且讨论关于开发docker教程的相关问题。此外，我们还会涉及一些关于5分钟，教你用Docker部署一个Pytho

在这篇文章中，我们将为您详细介绍如何开发一个基于 Docker 的 Python 应用的内容，并且讨论关于开发docker教程的相关问题。此外，我们还会涉及一些关于5 分钟，教你用 Docker 部署一个 Python 应用！、5分钟教会你用Docker部署一个Python应用、Docker | 多图预警 | 配置Docker下Python开发环境、Docker 容器化部署 Python 应用的知识，以帮助您更全面地了解这个主题。

本文目录一览：

如何开发一个基于 Docker 的 Python 应用（开发docker教程）
5 分钟，教你用 Docker 部署一个 Python 应用！
5分钟教会你用Docker部署一个Python应用
Docker | 多图预警 | 配置Docker下Python开发环境
Docker 容器化部署 Python 应用

如何开发一个基于 Docker 的 Python 应用（开发docker教程）

前言

Python 家族成员繁多，解决五花八门的业务需求。这里将通过 Python 明星项目 IPython Notebook，使其容器化，让大家掌握基础的 Docker 使用方法。

IPython Notebook 目前已经成为用 Python 做教学、计算、科研的一个重要工具。

Docker 化应用的关键元素

镜像是 Docker 应用的静态表示，是应用的交付件，镜像中包含了应用运行所需的所有依赖：包括应用代码、应用依赖库、应用运行时和操作系统。
Dockerfile 是一个描述文件，描述了产生 Docker 镜像的过程，详细文档可以参见官方文档 Dockerfile reference。
容器是镜像运行时的动态表示，如果把镜像想象为一个 Class 那么容器就是这个 Class 的一个实例。

一个应用 Docker 化的第一步就是通过 Dockerfile 产生应用镜像。

编写 Dockerfile

选择 Python 2.7 版本为我们依赖的系统镜像。

FROM python:2.7

因所有官方镜像均位于境外服务器，为了确保所有示例能正常运行，可以使用与官方镜像保持同步的 DaoCloud 境内镜像：FROM daocloud.io/python:2.7。

也推荐通过 DaoCloud Toolbox 极速下载官方镜像！

设置镜像的维护者，相当于镜像的作者或发行方。

MAINTAINER Captain Dao <support@daocloud.io>

向镜像中添加文件并安装依赖。

RUN mkdir -p /app  
WORKDIR /app ADD requirements.txt requirements.txt RUN pip install -r requirements.txt COPY docker-entrypoint.sh /usr/local/bin/

ADD 与 COPY 的区别

总体来说 ADD 和 COPY 都是添加文件的操作，其中 ADD 比 COPY 功能更多，ADD 允许后面的参数为 URL，还有 ADD 添加的文件为压缩包的话，它将自动解压。

使用 RUN 命令调用 pip 包管理器安装 App 的依赖包

在编写 Dockerfile 时尽量将安装依赖的过程提前以提高镜像层的复用率。

启动应用进程

EXPOSE 8888  
ENTRYPOINT ["docker-entrypoint.sh"] CMD [""]

通过 EXPOSE 指定该镜像需要公开的端口。

ENTRYPOINT 与 CMD 的区别

ENTRYPOINT 指定了该镜像启动时的入口，CMD 则指定了容器启动时的命令，当两者共用时，完整的启动命令像是 ENTRYPOINT + CMD 这样。使用 ENTRYPOINT 的好处是在我们启动镜像就像是启动了一个可执行程序，在 CMD 上仅需要指定参数；另外在我们需要自定义 CMD 时不容易出错。

制作启动脚本（docker-entrypoint.sh）

#!/bin/bash
# Strict mode
set -euo pipefail

# Create the hash to pass to the IPython notebook, but don''t export it so it doesn''t appear # as an environment variable within IPython kernels themselves HASH=$(python -c "from IPython.lib import passwd; print(passwd(''${PASSWORD:-admin}''))") echo "========================================================================" echo "You can now connect to this Ipython Notebook server using, for example:" echo "" echo " docker run -d -p <your-port>:8888 -e password=<your-password> ipython/noetebook" echo "" echo " use password: ${PASSWORD:-admin} to login" echo "" echo "========================================================================" unset PASSWORD ipython notebook --no-browser --port 8888 --ip=* --NotebookApp.password="$HASH"

一般我们会将初始化应用的过程编写成一个启动脚本，在脚本里以环境变量或命令行参数的形式获取应用初始化所必须的信息，然后配置并启动应用。

启动容器

有了 Dockerfile 以后，我们可以运行下面的命令构建 Python 应用镜像并命名为 ipython/notebook：

通过指令建立镜像

docker build -t ipython/notebook .

通过以下指令启动容器

docker run -d -p 8888:8888 -e PASSWORD=admin ipython/notebook

注意哦，我们将初始登录密码以环境变量的形式传入容器并告知应用。

打开游览器，访问 8888 端口，就可以看到 IPython Notebook 了。

ipython login

wph95

5 分钟，教你用 Docker 部署一个 Python 应用！

我们在写完 python 程序之后，如果想要运行在服务器上，你会如何操作？

今天我就来和大家聊聊这个话题。

我们在使用传统物理机或云服务器上部署项目都会存在一些痛点，比如：项目部署速度慢、资源浪费、迁移难且扩展低。

而使用 Docker 部署项目的优势包含：

高效利用系统资源
服务启动更快
环境一致，迁移更加方便

今天将给大家介绍 Docker 部署一个 Python 项目的常规流程。

1. Dockerfile 描述文件

Dockerfile 是一个放置在项目根目录下的描述文件，可以利用 Docker 命令基于该文件构建一个镜像常用的指令包含：

FROM
用于定义基础镜像
MAINTAINER
指定维护者信息，可以省略不写
RUN
和「安装命令」连接在一起，可用于安装工具依赖包
ADD
将宿主机的文件，并进行解压
COPY
和 ADD 指令功能一样，但是不会进行解压操作
WORKDIR
用于切换工作目录
VOLUME
配置宿主机与容器的目录映射
EXPOSE
配置容器内项目对外暴露的端口号
CMD
指定容器启动后，运行的命令
比如，可以运行某个命令启动项目

2. 实战一下

使用 Docker 部署应用的常规流程是：

开发项目并本地测试通过
编写 Dockerfile 放置到项目根目录
打包镜像文件
运行镜像容器
测试

为了演示方便，这里以一个简单的 Flask 项目为例进行讲解

2-1 项目开发

from flask import Flask

# 安装依赖
# pip3 install -U flask

app = Flask(__name__)


@app.route(''/'')
def index():
    return "测试容器部署!"


if __name__ == ''__main__'':
    app.run(host=''0.0.0.0'', port=8888)

# 浏览器访问测试
# http://127.0.0.1:8888/

项目开发完成，并在本地测试通过后就可以编写 Dockerfile 文件了

2-2 编写 Dockerfile

在项目根目录下，创建一个 Dockerfile 文件，使用上面的指令编写描述脚本需要注意的是，这里使用「 EXPOSE 」指令暴露的端口号与入口文件定义的端口号保持一致

# Dockerfile

FROM centos:7.9.2009
RUN yum makecache fast;
RUN yum install python3-devel python3-pip -y
RUN pip3 install -i https://pypi.douban.com/simple flask
COPY main.py /opt
WORKDIR /opt
EXPOSE 8888
CMD ["python3","main.py"]

2-3 构建镜像

# 在当前文件夹下，根据Dockerfile文件构建一个镜像
# 镜像名称：xag/my_flask_web
# --no-cache：不使用旧的缓存进行镜像构建
docker build --no-cache -t "xag/my_flask_web" .

2-4 运行镜像容器

使用 docker run 命令基于镜像运行一个容器

其中

-d：代表容器在后台运行，不是基于前台运行
--name：用于执行容器的别名
-p：用于配置宿主机与容器的端口映射

# -d：后台运行
# 宿主机（9999）映射容器内的8888（上面Dockerfile已经暴露了8888端口）
docker run -d --name flask_web -p 9999:8888 xag/my_flask_web

2-5 测试一下

最后在浏览器中，通过宿主机暴露的端口号 9999 访问项目了

3. 总结

今天的文章我们以一个简单的 Web 项目阐述了利用 Docker 部署项目的常规流程。

实际上，Dockerfile 非常的灵活，它还支持 ARG/ENV 设置环境变量，VOlUME 指令挂载目录，ENTRYPOINT 配置启动程序和参数等。

以上就是本次分享的所有内容，如果你觉得文章还不错，欢迎关注公众号：Python编程学习圈，每日干货分享，发送“J”还可领取大量学习资料。或是前往编程学习网，了解更多编程技术知识。

5分钟教会你用Docker部署一个Python应用

前言

在使用传统物理机或云服务器上部署项目都会存在一些痛点

比如：项目部署速度慢、资源浪费、迁移难且扩展低

而使用 Docker 部署项目的优势包含：

高效利用系统资源
服务启动更快
环境一致，迁移更加方便

本篇文章将介绍 Docker 部署一个 Python 项目的常规流程

1. Dockerfile 描述文件

Dockerfile 是一个放置在项目根目录下的描述文件，可以利用 Docker 命令基于该文件构建一个镜像

常用的指令包含：

FROM

用于定义基础镜像

MAINTAINER

指定维护者信息，可以省略不写

RUN

和「安装命令」连接在一起，可用于安装工具依赖包

ADD

将宿主机的文件，并进行解压

COPY

和 ADD 指令功能一样，但是不会进行解压操作

WORKDIR

用于切换工作目录

VOLUME

配置宿主机与容器的目录映射

EXPOSE

配置容器内项目对外暴露的端口号

CMD

指定容器启动后，运行的命令

比如，可以运行某个命令启动项目

2. 实战一下

使用 Docker 部署应用的常规流程是：

开发项目并本地测试通过

编写 Dockerfile 放置到项目根目录

打包镜像文件

运行镜像容器

测试

为了演示方便，这里以一个简单的 Flask 项目为例进行讲解

2-1 项目开发

from flask import Flask

# 安装依赖
# pip3 install -U flask

app = Flask(__name__)

@app.route(''/'')
def index():
    return "测试容器部署!"

if __name__ == ''__main__'':
    app.run(host=''0.0.0.0'', port=8888)

# 浏览器访问测试
# http://127.0.0.1:8888/

项目开发完成，并在本地测试通过后就可以编写 Dockerfile 文件了

2-2 编写 Dockerfile

在项目根目录下，创建一个 Dockerfile 文件，使用上面的指令编写描述脚本

需要注意的是，这里使用「 EXPOSE 」指令暴露的端口号与入口文件定义的端口号保持一致

# Dockerfile

FROM centos:7.9.2009
RUN yum makecache fast;
RUN yum install python3-devel python3-pip -y
RUN pip3 install -i https://pypi.douban.com/simple flask
COPY main.py /opt
WORKDIR /opt
EXPOSE 8888
CMD ["python3","main.py"]

2-3 构建镜像

# 在当前文件夹下，根据Dockerfile文件构建一个镜像
# 镜像名称：xag/my_flask_web
# --no-cache：不使用旧的缓存进行镜像构建
docker build --no-cache -t "xag/my_flask_web" .

2-4 运行镜像容器

使用 docker run 命令基于镜像运行一个容器

其中

-d：代表容器在后台运行，不是基于前台运行

–name：用于执行容器的别名

-p：用于配置宿主机与容器的端口映射

# -d：后台运行
# 宿主机（9999）映射容器内的8888（上面Dockerfile已经暴露了8888端口）
docker run -d --name flask_web -p 9999:8888 xag/my_flask_web

2-5 测试一下

最后在浏览器中，通过宿主机暴露的端口号 9999 访问项目了

访问地址：http://127.0.0.1:9999/

3. 总结

文章中以一个简单的 Web 项目阐述了利用 Docker 部署项目的常规流程

实际上，Dockerfile 非常的灵活，它还支持 ARG/ENV 设置环境变量，VOlUME 指令挂载目录，ENTRYPOINT 配置启动程序和参数等，这部分内容大家可以根据官网介绍自行进行扩展

到此这篇关于用Docker部署一个Python应用的文章就介绍到这了,更多相关Docker部署Python应用内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！

您可能感兴趣的文章:

在Docker上开始部署Python应用的教程
在Docker上部署Python的Flask框架的教程
Docker部署Python爬虫项目的方法步骤
Docker如何部署Python项目的实现详解
python开发之Docker入门安装部署教程

Docker | 多图预警 | 配置Docker下Python开发环境

有不少的朋友读了之前的一系列的Docker文章一脸懵逼，这和Python有什么关系？

Docker可以用来减轻我们搭建环境的繁琐步骤，我们完全可以把类似selenium等环境用Docker容器部署好，在代码里直接使用远端的selenium,简单方便。

使用Docker容器中的Python环境进行开发

环境准备:腾讯云CentOS 7 + Docker

修改Docker配置

简易版本:

编辑Docker相关配置文件:

vi /etc/docker/daemon.json

插入下面的配置:

注意这里是标准的json格式,格式出错Docker重启不了

{
  "hosts": ["tcp://0.0.0.0:2375","unix:///var/run/docker.sock"]
}

重载Docker配置:systemctl daemon-reload

重启Docker:systemctl restart docker

复杂版本:
这版本用于使用上面的配置修改之后依旧无法连接的情况,咸鱼第一次配置就出现了这个情况，咸鱼在某课网的手记板块找到了答案。

这里贴一下原文地址:

参考链接：https://www.jb51.cc/article/details/id/28426

具体操作如下:
编辑下面的文件:

vi /lib/systemd/system/docker.service

将文件对应配置项修改后保存:

将
ExecStart=/usr/bin/dockerd
改为
ExecStart=/usr/bin/dockerd -H unix:///var/run/docker.sock -H tcp://0.0.0.0:2375

配置Pycharm

首先打开Pycharm中Docker的显示项:

修改Docker配置:

在下图对应的地方填入你之前编辑的Docker配置:

这里注意格式: tcp://host:ports

配置好后提示连接成功即可。

配置远程Docker的镜像作为Pycharm的解释器

点开配置,点击新增配置:

在新增项中选择Docker，这里会自动加载你连接的Docker服务中包含Python的全部镜像:

配置代码的自动上传

你以为到上面就结束了吗？解释器是配置好了，但是你的代码还在本地，所以需要配置代码自动上传到云服务器。

首先找到对应的选项,之前没有配置过的话这里选项是灰色的，需要先配置, 点击 configuration :

点击加号，填入对应的配置，填完可以测试一下是否可用:

如果不能使用，建议登录控制台，配置相关的安全组配置。

切换到隔壁的mapping选项卡,按照下图配置相关的路径和要上传到服务器上的路径:

以上都做完之后，返回本小节的第一张图，有自动上传选项将它勾起，之后当你的文件有更改就会自动上传至服务器指定的路径下。

到这里，你以为结束了那就太天真了。

解决代码自动上传后运行报错

当你上传代码后，运行后报错“无法找到对应的文件夹/文件”,这是因为这个时候我们的代码仅仅上传到了服务器上，但是我们的Python解释器是运行在容器中，而我们容器查找代码是查找的数据卷，所以这个时候就需要我们在配置中做一个简单的地址映射。

先看下上面一大段所涉及的原理图:

接下来我们开始配置,全局的地址映射:

在Docke组件中编辑配置，添加path mapping
效果：当我们配置云服务路径时会自动将我们本地路径映射过去

设置Python默认的mapping为对应的路径:

这里注意一点:这里的container path 指的是容器中路径,结合上面的原理图，全部的映射过程是本地路径 -> 云服务器路径 -> 容器路径

以上就是本次文章的全部内容了，如果对这其中的原理有不明白的，咸鱼建议可以重新温习下之前关于数据卷的部分，如果还是不明白可以直接无视原理，按图索骥直接配好了事，当然欢迎大家留言交流~ ~

咸鱼学Python

专注于Python商业化爬虫、Python数据科学的咸鱼

Docker 容器化部署 Python 应用

1. 简介

Docker 是目前主流 IT 公司广泛接受和使用的，用于构建、管理和保护它们应用程序的工具。

容器，例如 Docker 允许开发人员在单个操作系统上隔离和运行多个应用程序，而不是为服务器上的每个应用程序专用一个虚拟机。使用容器更轻量级，可以降低成本、更好地使用资源和发挥更高的性能。

本文将使用 Flask 开发一个简单的 Python web 应用程序，并为 “容器化” 做好准备。然后创建一个 Docker 映像，并将其部署到测试和生产环境中。

注意： 请确保机器上已安装 Docker，如果没有请参考 Docker 官方安装教程。

2. Docker 介绍

Docker 是一种工具，它使开发人员能够交付他们的应用程序 (以及库或其他依赖项)，确保他们可以使用正确的配置运行，而不受部署环境影响。

这是通过将应用程序隔离在单独的容器中来实现的，这些应用程序虽然被容器分隔开，但是却可以共享操作系统和其他资源。

Docker 包含两部分:

Docker Engine — 应用打包工具，用于封装应用程序。
Docker Hub — 用于管理云上容器应用程序的工具。

3. 为何选择容器

了解容器的重要性和实用性非常重要，虽然它和直接将应用部署到服务器没有多大区别，但是当涉及到比较复杂的且相当吃资源的应用，尤其是多个应用部署在同一台服务器，或是同一应用要部署到多台服务器时。容器就变得非常有用。

在容器之前，这是通过 VMWare 和 Hypervisor 等虚拟机解决的，但是它们在效率、速度和可移植性方面已被证明并不是最佳选择。

Docker 容器是虚拟机的轻量级的替代品 - 与 VM 不同，我们不需要为它预先分配 RAM、CPU 或其他资源，也不需要为每个应用程序启动一个 VM，仅仅只需要一个操作系统即可。

使用容器开发人员就不需要为不同环境制定特殊版本，这样可以专注于应用程序的核心业务逻辑。

4. 创建 Python 应用

Flask 是 Python 的一个轻量级 Web 应用框架，简单易用，可以很快速地创建 web 应用。我们用它来创建此 demo 应用。

如果还没有安装 Flask 模块，可以使用下面命令安装:

$ pip install flask

安装成功后，新建一个应用目录，命名为 FlaskDemo。并在该目录下创建应用代码文件 app.py。

在 app.py 中，首先引入 Flask 模块，然后创建一个 web 应用:

from flask import Flask

app = Flask(__name__)

然后定义路由 / 和其对应的请求处理程序:

@app.route("/")
def index():  
  return """
  <h1>Python Flask in Docker!</h1>
  <p>A sample web-app for running Flask inside Docker.</p>
  """

最后，添加运行主程序并启动该脚本:

if __name__ == "__main__":  
    app.run(debug=True, host=''0.0.0.0'')

$ python app.py

然后在浏览器中访问 http://localhost:5000/, 可以看到 Dockerzing Python app using Flask 这样的页面。

5.Dokcer 打包应用

要在 Docker 上运行应用程序，首先必须构建一个容器，而且必须包含使用的所有依赖项 —— 在我们的例子中只有 Flask。因此，新建一个包含所有依赖包的 requirements.txt 文件，然后创建一个 Dockerfile，该文件用来描述构建映像过程。

此外，当启动容器时还需要放开应用程序的 HTTP 端口。

准备工作

requirements.txt 文件非常简单，只需要填入项目的依赖包和其对应版本即可：

Flask==1.0.2

接下来，需要将应用程序运行所需的所有 Python 文件都放在顶层文件夹中，例如，名为 app 的目录。

同时建议将主入口程序命名为 app.py ，将脚本中创建的 Flask 对象命名为 app 是一种通常的做法，这样也可以简化部署。

FlaskApp  
    ├── requirements.txt
    ├── Dockerfile
    └── app
        └── app.py
        └── <other .py files>

创建 Dockerfile

Dockerfile 本质上是一个文本文件，其中明确定义了如何为我们的项目构建 Docker 镜像。

接下来创建一个基于 Ubuntu 16.04 和 Python 3.X 的 Dokcer 镜像:

FROM ubuntu:16.04

MAINTAINER jhao104 "j_hao104@163.com"

RUN apt-get update -y && \  
    apt-get install -y python3-pip python3-dev

COPY ./requirements.txt /requirements.txt

WORKDIR /

RUN pip3 install -r requirements.txt

COPY . /

ENTRYPOINT [ "python3" ]

CMD [ "app/app.py" ]

Dockerfile 的基本指令有十三个，上面用到了部分；

FROM - 所有 Dockerfile 的第一个指令都必须是 FROM ，用于指定一个构建镜像的基础源镜像，如果本地没有就会从公共库中拉取，没有指定镜像的标签会使用默认的 latest 标签，如果需要在一个 Dockerfile 中构建多个镜像，可以使用多次。
MAINTAINER - 描述镜像的创建者，名称和邮箱。
RUN - RUN 命令是一个常用的命令，执行完成之后会成为一个新的镜像，通常用于运行安装任务从而向映像中添加额外的内容。在这里，我们需更新包，安装 python3 和 pip 。在第二个 RUN 命令中使用 pip 来安装 requirements.txt 文件中的所有包。
COPY - 复制本机文件或目录，添加到指定的容器目录，本例中将 requirements.txt 复制到镜像中。
WORKDIR - 为 RUN、CMD、ENTRYPOINT 指令配置工作目录。可以使用多个 WORKDIR 指令，后续参数如果是相对路径，则会基于之前命令指定的路径。
ENTRYPOINT - 在启动容器的时候提供一个默认的命令项。
RUN - 运行 app 目录中的 app.py 。

Docker 镜像构建原理

Docker 镜像是使用 Docker build 命令构建的。在构建镜像时，Docker 创建了所谓的 “层 (layers)”。每一层都记录了 Dockerfile 中的命令所导致的更改，以及运行命令后镜像的状态。

Docker 在内部缓存这些层，这样在重新构建镜像时只需要重新创建已更改的层。例如，这里使用了 ubuntu:16.04 的基础镜像，相同容器的所有后续构建都可以重用它，因为它不会改变。但是，因为项目修改，在下次重新构建过程中 app 目录的内容可能会有所不同，因此只会重新构建这一层。

需要注意的是，每当重新构建某一层时，Dockerfile 中紧随其后的所有层也都需要重新构建。例如，我们首先复制 requirements.txt 文件，然后再复制应用程序的其余部分。这样之前安装的依赖项只要没有新的依赖关系，即使应用程序中的其他文件发生了更改，也不需要重新构建这一层。这一点在创建 Dockerfiles 时一定要注意。

因此，通过将 pip 安装与应用程序其余部分的部署分离，可以优化容器的构建过程。

构建 Docker 镜像

现在 Dockerfile 已经准备好了，而且也了解了 Docker 的构建过程，接下来为我们的应用程序创建 Docker 映像:

docker build -t docker-flask:0.1 .

调试模式运行

根据前面讲到的容器化的优点，开发的应用程序通过容器部署，这从一开始就确保了应用程序构建的环境是干净的，从而消除了交付过程中的意外情况。

但是呢，在开发应用程序的过程中，更重要的是要快速重新构建和测试，以检查验证过程中的每个中间步骤。为此，web 应用程序的开发人员需要依赖于 Flask 等框架提供的自动重启功能（Debug 模式下，修改代码自动重启）。而这一功能也可以在容器中使用。

为了启用自动重启，在启动 Docker 容器时将主机中的开发目录映射到容器中的 app 目录。这样 Flask 就可以监听主机中的文件变化 (通过映射) 来发现代码更改，并在检测到更改时自动重启应用程序。

此外，还需要将应用程序的端口从容器转发到主机。这是为了能够让主机上的浏览器访问应用程序。

因此，启动 Dokcer 容器时需要使用 volume-mapping 和 port-forwarding 选项：

docker run --name flask_app -v $PWD/app:/app -p 5000:5000 docker-flask:0.1

改命令将会执行以下操作:

基于之前构建的 docker-flask 镜像启动一个容器；
这个容器的名称被设置为 flask_app 。如果没有 ——name 选项，Docker 将为容器生成一个名称。显式指定名称可以帮助我们定位容器 (用来停止等操作)；
-v 选项将主机的 app 目录挂载到容器；
-p 选项将容器的端口映射到主机。

现在可以通过 http://localhost:5000 或者 http://0.0.0.0:5000/ 访问到应用:

如果我们在容器运行的时候，修改应用程序代码，Flask 会检测到更改并重新启动应用程序。

要停止容器的话，可以使用 Ctrl + C, 并运行 docker rm flask_app 移除容器。

生产模式运行

虽然直接使用 Flask 裸跑运行应用程序对于开发来说已经足够好了，但是我们需要在生产中使用更健壮的部署方法。

目前主流的部署方案是 nginx + uwsgi，下面我们将介绍如何为生产环境部署 web 应用程序。Nginx 是一个开源 web 服务器，uWSGI 是一个快速、自我修复、开发人员和系统管理员友好的服务器。

首先，我们创建一个入口脚本，用来控制以开发模式还是生产模式启动我们的应用程序，这两者区别是选择直接运行 python 还是 nginx 模式。

然后再写一个简单 shell 启动脚本 entry-point.sh:

#!/bin/bash

if [ ! -f /debug0 ]; then  
  touch /debug0

  while getopts ''hd:'' flag; do
    case "${flag}" in
      h)
        echo "options:"
        echo "-h        show brief help"
        echo "-d        debug mode, no nginx or uwsgi, direct start with ''python3 app/app.py''"
        exit 0
        ;;
      d)
        touch /debug1
        ;;
      *)
        break
        ;;
    esac
  done
fi

if [ -e /debug1 ]; then  
  echo "Running app in debug mode!"
  python3 app/app.py
else  
  echo "Running app in production mode!"
  nginx && uwsgi --ini /app.ini
fi

然后创建 uWSGI 配置文件 app.ini:

[uwsgi]
plugins = /usr/lib/uwsgi/plugins/python3  
chdir = /app  
module = app:app  
uid = nginx  
gid = nginx  
socket = /run/uwsgiApp.sock  
pidfile = /run/.pid  
processes = 4  
threads = 2

和 nginx 配置文件 nginx.conf:

user nginx;
worker_processes  4;
pid /run/nginx.pid;

events {
    worker_connections  20000;
}

http {
    include    mime.types;
    sendfile on;
    keepalive_timeout  65;
    gzip off;

    server {
        listen 80;
        access_log off;
        error_log off;

        location / { try_files $uri @flaskApp; }
        location @flaskApp {
            include uwsgi_params;
            uwsgi_pass unix:/run/uwsgiApp.sock;
        }
    }
}

最后，修改 Dockerfile 将 nginx 和 uWSGI 安装到镜像，将配置文件复制到镜像中，并设置运行 nginx 所需的用户权限:

FROM ubuntu:16.04

MAINTAINER jhao104 "j_hao104@163.com"

RUN apt-get update -y && \
    apt-get install -y python3-pip python3-dev && \
    apt-get install -y nginx uwsgi uwsgi-plugin-python3

COPY ./requirements.txt /requirements.txt
COPY ./nginx.conf /etc/nginx/nginx.conf

WORKDIR /

RUN pip3 install -r requirements.txt

COPY . /

RUN adduser --disabled-password --gecos '''' nginx\
  && chown -R nginx:nginx /app \
  && chmod 777 /run/ -R \
  && chmod 777 /root/ -R

ENTRYPOINT [ "/bin/bash", "/entry-point.sh"]

然后重新打包镜像:

docker build -t docker-flask:0.1 .

然后使用 nginx 启动应用程序：

docker run -d --name flaskapp --restart=always -p 8091:80 docker-flask:0.1

该镜像包含 python、ngix、uwsgi 完整环境，只需要在部署时指定端口映射便可以自动部署应用。要停止并删除此容器，请运行下面命令：

docker stop flaskapp && docker rm flaskapp

此外，如果我们仍然需要上面调试功能或修改部分代码，也可以像上面一样以调试模式运行容器:

docker run -it --name flaskapp -p 5000:5000 -v $PWD/app:/app docker-flask:0.1 -d debug

6. 管理外部依赖

如果将应用程序作为容器交付时，需要记住的一个关键事项是，开发人员管理依赖项的责任增加了。除了识别和指定正确的依赖项和版本之外，还需要负责在容器环境中安装和设置这些依赖项。

在 Python 项目中管理安装依赖比较容易，可以使用 requirements.txt 指定依赖项和对应版本，然后通过 pip 安装。

需要重申的是是，无论何时修改 requirements.txt 文件，都需要重新构建 Docker 镜像。

启动时安装依赖项

可能在某次版本更新时需要安装额外的依赖项。比如，在开发过程中使用了一个新的包。如果不希望每次都重新构建 Docker 镜像，或者希望在启动时使用最新的可用版本。可以通过修改启动程序在应用程序启动时运行安装程序来实现这一点。

同样，我们也可以安装额外的系统级包依赖项。修改 entry-point.sh:

#!/bin/bash

if [ ! -f debug0 ]; then
  touch debug0
  
  if [ -e requirements_os.txt ]; then
    apt-get install -y $(cat requirements_os.txt)
    
   fi
   if [-e requirements.txt ]; then
    pip3 install -r requirements.txt
   fi

  while getopts ''hd:'' flag; do
    case "${flag}" in
      h)
        echo "options:"
        echo "-h        show brief help"
        echo "-d        debug mode, no nginx or uwsgi, direct start with ''python3 app/app.py''"
        exit 0
        ;;
      d)
        touch debug1
        ;;
      *)
        break
        ;;
    esac
  done
fi

if [ -e debug1 ]; then
  echo "Running app in debug mode!"
  python3 app/app.py
else
  echo "Running app in production mode!"
  nginx && uwsgi --ini /app.ini
fi

这样我们可以在 requirements_os.txt 中指定将要安装的系统软件包名称，这些包名以空格分隔放在同一行。他们将和 requirements.txt 中的 Python 依赖库一样在应用程序启动之前安装。

尽管这样对应用的迭代开发期间提供了便利，但是出于几个原因，在启动时安装依赖项不是一个好的实践：

它破坏了容器化的目标之一，即修复和测试由于部署环境的变化而不会改变的依赖关系；
增加了应用程序启动的额外开销，这将增加容器的启动时间；
每次启动应用程序时需要安装依赖项，这样对网络资源有要求。

关于如何开发一个基于 Docker 的 Python 应用和开发docker教程的介绍已经告一段落，感谢您的耐心阅读，如果想了解更多关于5 分钟，教你用 Docker 部署一个 Python 应用！、5分钟教会你用Docker部署一个Python应用、Docker | 多图预警 | 配置Docker下Python开发环境、Docker 容器化部署 Python 应用的相关信息，请在本站寻找。

本文标签：