聊聊Python应用容器化部署流程

 1. 简介

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

创新互联建站是一家专注于成都网站建设、网站设计与策划设计,桂平网站建设哪家好?创新互联建站做网站,专注于网站建设十余年,网设计领域的专业建站公司;建站业务涵盖:桂平等地区。桂平做网站价格咨询:028-86922220

容器，例如 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 模块，可以使用下面命令安装:

 
 
 
 
    
  
  
  
  
  1. $ pip install flask
    2.

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

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

 
 
 
 
    
  
  
  
  
  1. from flask import Flask
    2. 
  
  
  
  
  2. 
  
  
  
  
  3. app = Flask(__name__)
    4.

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

 
 
 
 
    
  
  
  
  
  1. @app.route("/")
    2. 
  
  
  
  
  2. def index():  
    3. 
  
  
  
  
  3.   return """
    4. 
  
  
  
  
  4.   
    Python Flask in Docker!
    5. 
  
  
  
  
  5.   
    A sample web-app for running Flask inside Docker.
    6. 
  
  
  
  
  6.   """
    7.

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

 
 
 
 
    
  
  
  
  
  1. if __name__ == "__main__":
    2. 
  
  
  
  
  2.     app.run(debug=True, host='0.0.0.0')
    3. 
 
 
 
 
 
 
 
 
    
  
  
  
  
  1. $ python app.py
    2.

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

5.Dokcer打包应用

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

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

准备工作

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

 
 
 
 
    
  
  
  
  
  1. Flask==1.0.2 
    2.

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

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

 
 
 
 
    
  
  
  
  
  1. FlaskApp
    2. 
  
  
  
  
  2.     ├── requirements.txt
    3. 
  
  
  
  
  3.     ├── Dockerfile
    4. 
  
  
  
  
  4.     └── app
    5. 
  
  
  
  
  5.         └── app.py
    6. 
  
  
  
  
  6.         └── 
    7.

创建Dockerfile

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

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

 
 
 
 
    
  
  
  
  
  1. FROM ubuntu:16.04
    2. 
  
  
  
  
  2. 
  
  
  
  
  3. MAINTAINER jhao104 "j_hao104@163.com"
    4. 
  
  
  
  
  4. 
  
  
  
  
  5. RUN apt-get update -y && \
    6. 
  
  
  
  
  6.     apt-get install -y python3-pip python3-dev
    7. 
  
  
  
  
  7. 
  
  
  
  
  8. COPY ./requirements.txt /requirements.txt
    9. 
  
  
  
  
  9. 
  
  
  
  
  10. WORKDIR /
    11. 
  
  
  
  
  11. 
  
  
  
  
  12. RUN pip3 install -r requirements.txt
    13. 
  
  
  
  
  13. 
  
  
  
  
  14. COPY . /
    15. 
  
  
  
  
  15. 
  
  
  
  
  16. ENTRYPOINT [ "python3" ]
    17. 
  
  
  
  
  17. 
  
  
  
  
  18. CMD [ "app/app.py" ]
    19.

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映像:

 
 
 
 
    
  
  
  
  
  1. docker build -t docker-flask:0.1 .
    2.

调试模式运行

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

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

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

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

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

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

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

  • 基于之前构建的 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:

 
 
 
 
    
  
  
  
  
  1. #!/bin/bash
    2. 
  
  
  
  
  2. 
  
  
  
  
  3. if [ ! -f /debug0 ]; then
    4. 
  
  
  
  
  4.   touch /debug0
    5. 
  
  
  
  
  5. 
  
  
  
  
  6.   while getopts 'hd:' flag; do
    7. 
  
  
  
  
  7.     case "${flag}" in
    8. 
  
  
  
  
  8.       h)
    9. 
  
  
  
  
  9.         echo "options:"
    10. 
  
  
  
  
  10.         echo "-h        show brief help"
    11. 
  
  
  
  
  11.         echo "-d        debug mode, no nginx or uwsgi, direct start with 'python3 app/app.py'"
    12. 
  
  
  
  
  12.         exit 0
    13. 
  
  
  
  
  13.         ;;
    14. 
  
  
  
  
  14.       d)
    15. 
  
  
  
  
  15.         touch /debug1
    16. 
  
  
  
  
  16.         ;;
    17. 
  
  
  
  
  17.       *)
    18. 
  
  
  
  
  18.         break
    19. 
  
  
  
  
  19.         ;;
    20. 
  
  
  
  
  20.     esac
    21. 
  
  
  
  
  21.   done
    22. 
  
  
  
  
  22. fi
    23. 
  
  
  
  
  23. 
  
  
  
  
  24. if [ -e /debug1 ]; then
    25. 
  
  
  
  
  25.   echo "Running app in debug mode!"
    26. 
  
  
  
  
  26.   python3 app/app.py
    27. 
  
  
  
  
  27. else
    28. 
  
  
  
  
  28.   echo "Running app in production mode!"
    29. 
  
  
  
  
  29.   nginx && uwsgi --ini /app.ini
    30. 
  
  
  
  
  30. fi
    31.

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

 
 
 
 
    
  
  
  
  
  1. [uwsgi]
    2. 
  
  
  
  
  2. plugins = /usr/lib/uwsgi/plugins/python3
    3. 
  
  
  
  
  3. chdir = /app
    4. 
  
  
  
  
  4. module = app:app
    5. 
  
  
  
  
  5. uid = nginx
    6. 
  
  
  
  
  6. gid = nginx
    7. 
  
  
  
  
  7. socket = /run/uwsgiApp.sock
    8. 
  
  
  
  
  8. pidfile = /run/.pid
    9. 
  
  
  
  
  9. processes = 4  
    10. 
  
  
  
  
  10. threads = 2
    11.

和nginx配置文件 nginx.conf:

 
 
 
 
    
  
  
  
  
  1. user nginx;
    2. 
  
  
  
  
  2. worker_processes  4;
    3. 
  
  
  
  
  3. pid /run/nginx.pid;
    4. 
  
  
  
  
  4. 
  
  
  
  
  5. events {
    6. 
  
  
  
  
  6.     worker_connections  20000;
    7. 
  
  
  
  
  7. }
    8. 
  
  
  
  
  8. 
  
  
  
  
  9. http {
    10. 
  
  
  
  
  10.     include    mime.types;
    11. 
  
  
  
  
  11.     sendfile on;
    12. 
  
  
  
  
  12.     keepalive_timeout  65;
    13. 
  
  
  
  
  13.     gzip off;
    14. 
  
  
  
  
  14. 
  
  
  
  
  15.     server {
    16. 
  
  
  
  
  16.         listen 80;
    17. 
  
  
  
  
  17.         access_log off;
    18. 
  
  
  
  
  18.         error_log off;
    19. 
  
  
  
  
  19. 
  
  
  
  
  20.         location / { try_files $uri @flaskApp; }
    21. 
  
  
  
  
  21.         location @flaskApp {
    22. 
  
  
  
  
  22.             include uwsgi_params;
    23. 
  
  
  
  
  23.             uwsgi_pass unix:/run/uwsgiApp.sock;
    24. 
  
  
  
  
  24.         }
    25. 
  
  
  
  
  25.     }
    26. 
  
  
  
  
  26. }
    27.

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

 
 
 
 
    
  
  
  
  
  1. FROM ubuntu:16.04
    2. 
  
  
  
  
  2. 
  
  
  
  
  3. MAINTAINER jhao104 "j_hao104@163.com"
    4. 
  
  
  
  
  4. 
  
  
  
  
  5. RUN apt-get update -y && \
    6. 
  
  
  
  
  6.     apt-get install -y python3-pip python3-dev && \
    7. 
  
  
  
  
  7.     apt-get install -y nginx uwsgi uwsgi-plugin-python3
    8. 
  
  
  
  
  8. 
  
  
  
  
  9. COPY ./requirements.txt /requirements.txt
    10. 
  
  
  
  
  10. COPY ./nginx.conf /etc/nginx/nginx.conf
    11. 
  
  
  
  
  11. 
  
  
  
  
  12. WORKDIR /
    13. 
  
  
  
  
  13. 
  
  
  
  
  14. RUN pip3 install -r requirements.txt
    15. 
  
  
  
  
  15. 
  
  
  
  
  16. COPY . /
    17. 
  
  
  
  
  17. 
  
  
  
  
  18. RUN adduser --disabled-password --gecos '' nginx\
    19. 
  
  
  
  
  19.   && chown -R nginx:nginx /app \
    20. 
  
  
  
  
  20.   && chmod 777 /run/ -R \
    21. 
  
  
  
  
  21.   && chmod 777 /root/ -R
    22. 
  
  
  
  
  22. 
  
  
  
  
  23. ENTRYPOINT [ "/bin/bash", "/entry-point.sh"]
    24.

然后重新打包镜像:

 
 
 
 
    
  
  
  
  
  1. docker build -t docker-flask:0.1 .
    2.

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

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

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

 
 
 
 
    
  
  
  
  
  1. docker stop flaskapp && docker rm flaskapp
    2.

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

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

6.管理外部依赖

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

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

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

启动时安装依赖项

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

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

 
 
 
 
    
  
  
  
  
  1. #!/bin/bash
    2. 
  
  
  
  
  2. 
  
  
  
  
  3. if [ ! -f debug0 ]; then
    4. 
  
  
  
  
  4.   touch debug0
    5. 
  
  
  
  
  5.   
    6. 
  
  
  
  
  6.   if [ -e requirements_os.txt ]; then
    7. 
  
  
  
  
  7.     apt-get install -y $(cat requirements_os.txt)
    8. 
  
  
  
  
  8.     
    9. 
  
  
  
  
  9.    fi
    10. 
  
  
  
  
  10.    if [-e requirements.txt ]; then
    11. 
  
  
  
  
  11.     pip3 install -r requirements.txt
    12. 
  
  
  
  
  12.    fi
    13. 
  
  
  
  
  13. 
  
  
  
  
  14.   while getopts 'hd:' flag; do
    15. 
  
  
  
  
  15.     case "${flag}" in
    16. 
  
  
  
  
  16.       h)
    17. 
  
  
  
  
  17.         echo "options:"
    18. 
  
  
  
  
  18.         echo "-h        show brief help"
    19. 
  
  
  
  
  19.         echo "-d        debug mode, no nginx or uwsgi, direct start with 'python3 app/app.py'"
    20. 
  
  
  
  
  20.         exit 0
    21. 
  
  
  
  
  21.         ;;
    22. 
  
  
  
  
  22.       d)
    23. 
  
  
  
  
  23.         touch debug1
    24. 
  
  
  
  
  24.         ;;
    25. 
  
  
  
  
  25.       *)
    26. 
  
  
  
  
  26.         break
    27. 
  
  
  
  
  27.         ;;
    28. 
  
  
  
  
  28.     esac
    29. 
  
  
  
  
  29.   done
    30. 
  
  
  
  
  30. fi
    31. 
  
  
  
  
  31. 
  
  
  
  
  32. if [ -e debug1 ]; then
    33. 
  
  
  
  
  33.   echo "Running app in debug mode!"
    34. 
  
  
  
  
  34.   python3 app/app.py
    35. 
  
  
  
  
  35. else
    36. 
  
  
  
  
  36.   echo "Running app in production mode!"
    37. 
  
  
  
  
  37.   nginx && uwsgi --ini /app.ini
    38. 
  
  
  
  
  38. fi
    39.

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

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

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

本文标题：聊聊Python应用容器化部署流程
URL网址：http://www.shufengxianlan.com/qtweb/news39/260939.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

外贸建站知识

同城分类信息

成都网站推广　　 　商城网站　　 　成都宣传海报　　 　SSL认证　　 　眉山电信机房托管　　 　复盛机电设备安装　　 　卖链接　　 　响应式网站建设　　 　腾讯免备案空间　　 　网站设计　　 　成都APP定制开发　　 　成都免费建站　　 　达州做网站　　 　云服务器　　 　成都橡塑保温管　　 　成都电信光华数据中心　　 　成都企业网站维护　　 　四川成都seo网站优化　　 　成都手机网站开发　　 　成都包装盒设计