注册    登录
关注
Py学习  »  Python

Docker容器化部署Python应用

Docker • 4 年前 • 394 次点击  


简介


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

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

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

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

Docker介绍


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

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

Docker包含两部分：

  • Docker Engine：应用打包工具，用于封装应用程序。

  • Docker Hub：用于管理云上容器应用程序的工具。


为何选择容器


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

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

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

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

创建Python应用


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

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

  1. $ pip install flask

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

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

  1. from flask import Flask

  3. app = Flask(__name__)

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

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

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

  1. if __name__ == "__main__":  
  2.     app


    
.run(debug=True, host='0.0.0.0')
  3. Copy
  4. $ python app.py

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


Dokcer打包应用


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

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

准备工作

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

  1. Flask==1.0.2

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

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

  1. FlaskApp  
  2.     ├── requirements.txt
  3.     ├── Dockerfile
  4.     └── app
  5.         └── app.py
  6.         └── <other .py files>

创建Dockerfile

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

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

  1. FROM ubuntu:16.04

  3. MAINTAINER jhao104 "j_hao104@163.com"

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

  8. COPY ./requirements.txt /requirements.txt

  10. WORKDIR /

  12. RUN pip3 install -


    
r requirements.txt

  14. COPY . /

  16. ENTRYPOINT [ "python3" ]

  18. 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镜像：

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

调试模式运行

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

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

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

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

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

  1. 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：

  1. #!/bin/bash

  3. if [ ! -f /debug0 ]; then  
  4.   touch /debug0

  6.   while getopts 'hd:' flag; do
  7.     case "${flag}" in
  8.       h)
  9.         echo "options:"
  10. 


    
        echo "-h        show brief help"
  11.         echo "-d        debug mode, no nginx or uwsgi, direct start with 'python3 app/app.py'"
  12.         exit 0
  13.         ;;
  14.       d)
  15.         touch /debug1
  16.         ;;
  17.       *)
  18.         break
  19.         ;;
  20.     esac
  21.   done
  22. 


    
fi

  24. if [ -e /debug1 ]; then  
  25.   echo "Running app in debug mode!"
  26.   python3 app/app.py
  27. else  
  28.   echo "Running app in production mode!"
  29.   nginx && uwsgi --ini /app.ini
  30. fi  
  31. Copy

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

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


    
= /run/.pid
  9. processes = 4  
  10. threads = 2

和Nginx配置文件nginx.conf：

  1. user nginx;
  2. worker_processes  4;
  3. pid /run/nginx.pid;

  5. events {
  6.     worker_connections  20000;
  7. }

  9. 


    
http {
  10.     include    mime.types;
  11.     sendfile on;
  12.     keepalive_timeout  65;
  13.     gzip off;

  15.     server {
  16.         listen 80;
  17.         access_log off;
  18.         error_log off;

  20.         location / { try_files $uri @flaskApp; }
  21.         location 


    
@flaskApp {
  22.             include uwsgi_params;
  23.             uwsgi_pass unix:/run/uwsgiApp.sock;
  24.         }
  25.     }
  26. }

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

  1. FROM ubuntu:16.04

  3. MAINTAINER jhao104 "j_hao104@163.com"

  5. RUN apt-get update -y && \
  6. 


    
    apt-get install -y python3-pip python3-dev && \
  7.     apt-get install -y nginx uwsgi uwsgi-plugin-python3

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

  12. WORKDIR /

  14. RUN pip3 install -r requirements.txt


    


  16. COPY . /

  18. RUN adduser --disabled-password --gecos '' nginx\
  19.   && chown -R nginx:nginx /app \
  20.   && chmod 777 /run/ -R \
  21.   && chmod 777 /root/ -R

  23. ENTRYPOINT [ "/bin/bash",


    
 "/entry-point.sh"]

然后重新打包镜像：

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

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

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

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

  1. 


    
docker stop flaskapp && docker rm flaskapp

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

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

管理外部依赖


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

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

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

启动时安装依赖项

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

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

  1. #!/bin/bash

  3. if [ ! -f debug0 ]; then
  4.   touch debug0

  6.   if [ -e requirements_os.txt ]; then
  7.     apt-get install -y $(cat requirements_os.txt)

  9.    fi
  10. 


    
   if [-e requirements.txt ]; then
  11.     pip3 install -r requirements.txt
  12.    fi

  14.   while getopts 'hd:' flag; do
  15.     case "${flag}" in
  16.       h)
  17.         echo "options:"
  18.         echo "-h        show brief help"
  19.         echo "-d        debug mode, no nginx or uwsgi, direct start with 'python3 app/app.py'"
    


    

  20.         exit 0
  21.         ;;
  22.       d)
  23.         touch debug1
  24.         ;;
  25.       *)
  26.         break
  27.         ;;
  28.     esac
  29.   done
  30. fi

  32. if [ -e debug1 ];


    
 then
  33.   echo "Running app in debug mode!"
  34.   python3 app/app.py
  35. else
  36.   echo "Running app in production mode!"
  37.   nginx && uwsgi --ini /app.ini
  38. fi

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

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

  • 它破坏了容器化的目标之一，即修复和测试由于部署环境的变化而不会改变的依赖关系；

  • 增加了应用程序启动的额外开销，这将增加容器的启动时间；

  • 每次启动应用程序时需要安装依赖项，这样对网络资源有要求。


原文链接：http://www.spiderpy.cn/blog/detail/46

基于Kubernetes的DevOps实战培训


基于Kubernetes的DevOps战培训将于2019年7月26日在上海开课，3天时间带你系统掌握Kubernetes，学习效果不好可以继续学习。本次培训包括：容器特性、镜像、网络；Kubernetes架构、核心组件、基本功能；Kubernetes设计理念、架构设计、基本功能、常用对象、设计原则；Kubernetes的数据库、运行时、网络、插件已经落地经验；微服务架构、组件、监控方案等，点击下方图片或者阅读原文链接查看详情。

Python社区是高质量的Python/Django开发社区
本文地址：http://www.python88.com/topic/36032
Reply
 
394 次点击  
登录后回复
关于   移动版   ·   三行代码   ·   今天看啥   ·   Code   ·   link之家   ·   卧龙搜索   ·   藏经阁   ·   小百科
Py学习 - 专注于Python技术发展的社区(原Django社区)
沪ICP备11025650号