Shulou(Shulou.com)06/02 Report--

How to carry out Python application containerization deployment, many novices are not very clear about this, in order to help you solve this problem, the following editor will explain for you in detail, people with this need can come to learn, I hope you can gain something.

1. Brief introduction

Docker is a tool widely accepted and used by mainstream IT companies to build, manage, and protect their applications.

Containers, such as Docker, allow developers to isolate and run multiple applications on a single operating system, rather than dedicating a virtual machine to each application on the server. Using containers is more lightweight, resulting in lower costs, better use of resources, and higher performance.

This article will use Flask to develop a simple Python web application and prepare for containerization. Then create a Docker image and deploy it to test and production environments.

Note: please make sure that Docker is installed on the machine, if not, please refer to the official installation tutorial of Docker.

2. Docker introduction

Docker is a tool that enables developers to deliver their applications (as well as libraries or other dependencies) to ensure that they can run with the correct configuration regardless of the deployment environment.

This is achieved by isolating applications in separate containers that are separated by containers but can share operating systems and other resources.

Docker consists of two parts:

Docker Engine-apply the packaging tool to encapsulate the application.

Docker Hub-A tool for managing container applications on the cloud.

3. Why choose a container?

It is important to understand the importance and practicality of containers, although it is not much different from deploying applications directly to the server, but when it comes to more complex and resource-hungry applications, especially when multiple applications are deployed on the same server, or when the same application is deployed to multiple servers. The container becomes very useful.

Before the container, this was solved through virtual machines such as VMWare and Hypervisor, but they have not proved to be the best choice in terms of efficiency, speed, and portability.

The Docker container is a lightweight alternative to a virtual machine-unlike VM, we don't need to pre-allocate RAM, CPU, or other resources to it, nor do we need to launch a VM for each application, just an operating system.

Container developers do not need to make special versions for different environments, so they can focus on the core business logic of the application.

4. Create a Python application

Flask is a lightweight Web application framework of Python, which is easy to use and can quickly create web applications. We use it to create this demo application.

If the Flask module is not already installed, you can install it using the following command:

$pip install flask

After the installation is successful, create a new application directory and name it FlaskDemo. And create the application code file app.py in this directory.

In app.py, first introduce the Flask module, and then create a web application:

From flask import Flask app = Flask (_ _ name__)

Then define the route / and its corresponding request handler:

@ app.route ("/") def index (): return "" Python Flask in Docker!

A sample web-app for running Flask inside Docker.

"

Finally, add the running main program and start the script:

If _ _ name__ = "_ _ main__": app.run (debug=True, host='0.0.0.0') $python app.py

Then visit http://localhost:5000/, in the browser to see a page like Dockerzing Python app using Flask.

5.Dokcer packaged application

To run the application on Docker, you must first build a container and must contain all the dependencies used-- only Flask in our case. Therefore, create a new requirements.txt file that contains all dependent packages, and then create a Dockerfile that describes the process of building the image.

In addition, you need to release the application's HTTP port when starting the container.

Preparatory work

The requirements.txt file is very simple. You only need to fill in the dependent package of the project and its corresponding version:

Flask==1.0.2

Next, you need to put all the Python files needed for the application to run in the top-level folder, for example, a directory named app.

It is also recommended that the main portal be named app.py and the Flask object created in the script app as a common practice, which can also simplify deployment.

FlaskApp ├── requirements.txt ├── Dockerfile └── app └── app.py └──

Create Dockerfile

Dockerfile is essentially a text file that clearly defines how to build a Docker image for our project.

Next, create a Dokcer image based on Ubuntu 16.04 and Python 3.x:

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"]

There are thirteen basic Dockerfile instructions, some of which are used.

FROM-the first instruction of all Dockerfile must be FROM, which is used to specify a basic source image for building an image. If it is not available locally, it will be pulled from the public library. The tag without the specified image will use the default latest tag. If you need to build multiple images in a Dockerfile, you can use it multiple times.

MAINTAINER-describes the creator, name, and mailbox of the image.

The RUN-RUN command is a commonly used command that becomes a new mirror after execution, and is usually used to run installation tasks to add additional content to the image. Here, we need to update the package and install python3 and pip. Use pip in the second RUN command to install all packages in the requirements.txt file.

COPY-copy the native file or directory, add it to the specified container directory, and in this case copy the requirements.txt to the image.

WORKDIR-configure the working directory for the RUN, CMD, ENTRYPOINT directives. Multiple WORKDIR instructions can be used, and if the subsequent parameters are relative paths, they are based on the path specified by the previous command.

ENTRYPOINT-provides a default command entry when starting the container.

RUN-run app.py in the app directory.

Construction principle of Docker Image

The Docker image is built using the Docker build command. When building an image, Docker creates a so-called "layers". Each layer records the changes caused by commands in Dockerfile and the status of the mirror after running the command.

Docker caches these layers internally so that only the changed layers need to be recreated when rebuilding the mirror. For example, the base image of ubuntu:16.04 is used here, and all subsequent builds of the same container can reuse it because it will not change. However, because the project changes, the contents of the app directory may be different during the next rebuild, so only this layer will be rebuilt.

It is important to note that every time a layer is rebuilt, all the layers that follow in the Dockerfile also need to be rebuilt. For example, we first copy the requirements.txt file, and then copy the rest of the application. In this way, as long as the previously installed dependencies do not have new dependencies, you do not need to rebuild this layer even if other files in the application have changed. This must be noted when creating a Dockerfiles.

Therefore, the container construction process can be optimized by separating the pip installation from the deployment of the rest of the application.

Build a Docker image

Now that Dockerfile is ready and understands the process of building Docker, let's create a Docker image for our application:

Docker build-t docker-flask:0.1.

Debug mode operation

Based on the advantages of containerization mentioned earlier, the developed application is deployed through a container, which ensures that the environment built by the application is clean from the start, thus eliminating unexpected situations in the delivery process.

However, in the process of developing an application, it is more important to quickly rebuild and test to check each intermediate step in the validation process. To do this, developers of web applications need to rely on the automatic restart function provided by frameworks such as Flask (automatic restart of modified code in Debug mode). This feature can also be used in containers.

To enable automatic restart, map the development directory in the host to the app directory in the container when you start the Docker container. This allows Flask to listen for file changes in the host (through mapping) to detect code changes and automatically restart the application when changes are detected.

In addition, the port of the application needs to be forwarded from the container to the host. This is to allow browsers on the host to access the application.

Therefore, you need to use the volume-mapping and port-forwarding options when starting the Dokcer container:

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

Changing the command will do the following:

Start a container based on the previously built docker-flask image

The container's name is set to flask_app. If there is no-- name option, Docker generates a name for the container. Explicitly specifying a name can help us locate the container (used to stop operations, etc.)

The-v option mounts the host's app directory to the container

The-p option maps the port of the container to the host.

Applications can now be accessed through http://localhost:5000 or http://0.0.0.0:5000/:

If we modify the application code while the container is running, Flask detects the change and restarts the application.

To stop the container, you can use Ctrl + C and run docker rm flask_app to remove the container.

Production mode operation

While running applications directly using Flask naked runs is good enough for development, we need to use a more robust deployment approach in production.

The current mainstream deployment solution is nginx + uwsgi. Here we will describe how to deploy web applications for a production environment. Nginx is an open source web server, and uWSGI is a fast, self-healing, developer-and system administrator-friendly server.

First, we create an entry script to control whether to launch our application in development mode or production mode, and the difference between the two is whether we choose to run python directly or nginx mode.

Then write a simple shell startup script 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

Then create the uWSGI configuration file 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

And nginx profile 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;}

Finally, modify Dockerfile to install nginx and uWSGI to the image, copy the configuration file to the image, and set the user rights required to run 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"]

Then repackage the image:

Docker build-t docker-flask:0.1.

Then use nginx to start the application:

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

The image contains the complete environment of python, ngix and uwsgi. You only need to specify the port mapping at deployment time to deploy the application automatically. To stop and delete this container, run the following command:

Docker stop flaskapp & & docker rm flaskapp

In addition, if we still need the above debugging features or modify part of the code, we can also run the container in debug mode as above:

Docker run-it-- name flaskapp-p 5000 PWD/app:/app docker-flask:0.1-d debug6. Manage external dependencies

One of the key things to keep in mind when delivering the application as a container is that the developer has an increased responsibility to manage dependencies. In addition to identifying and specifying the correct dependencies and versions, you are also responsible for installing and setting these dependencies in the container environment.

It is relatively easy to manage installation dependencies in a Python project. You can use requirements.txt to specify dependencies and corresponding versions, and then install them through pip.

It is important to reiterate that whenever the requirements.txt file is modified, the Docker image needs to be rebuilt.

Install dependencies at startup

Additional dependencies may need to be installed when a version is updated. For example, a new package is used in the development process. If you don't want to rebuild the Docker image every time, or you want to use the latest available version at startup. You can do this by modifying the launcher to run the installer when the application starts.

Similarly, we can install additional system-level package dependencies. Modify 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

This allows us to specify the name of the system package to be installed in requirements_os.txt, separated by spaces on the same line. They will be installed just like the Python dependent libraries in requirements.txt before the application starts.

While this facilitates iterative development of the application, installing dependencies at startup is not a good practice for several reasons:

It destroys one of the goals of containerization, that is, to fix and test dependencies that will not change due to changes in the deployment environment

Increase the extra overhead of application startup, which will increase the startup time of the container

Dependencies need to be installed each time you start the application, which requires network resources.

Is it helpful for you to read the above content? If you want to know more about the relevant knowledge or read more related articles, please follow the industry information channel, thank you for your support.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.