Implementation of Docker deployment of Django+Mysql+Redis+Gunicorn+Nginx

I. Introduction

Docker technology is very popular now. By building a project environment through containers, the operation efficiency and deployment efficiency are very good. So I recently took the time to read some tutorials, and then changed the blog deployment method to docker. I felt that there were no particularly good tutorials on the Internet about deploying Django projects with docker , so I wrote this article specifically to record my own experience.

The test environment of this tutorial is Deepin . It mainly focuses on container orchestration and Django -related deployment knowledge. Some details, such as environment dependency installation, will not be explained in detail. Since it is tested locally, when configuring nginx related information, the http proxy will be configured instead of the https proxy.

2. Environmental Dependence

The deployment method is docker plus docker-compose, so you need to install docker and docker-compose.

• Docker can be installed using the command sudo apt install docker-ce .
• docker-compose can be installed with the following command.

sudo curl -L https://get.daocloud.io/docker/compose/releases/download/1.22.0/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose 
sudo chmod +x /usr/local/bin/docker-compose

After the installation is complete, enter docker version and you will see the following screen, indicating that Docker has been installed successfully.

Enter docker-compose version and see the following screen, indicating that docker-compose is installed successfully.

3. Deployment Analysis

The blog project uses Django , Mysql , Redis , and Nginx , so four containers are required, each container corresponds to an application. Of course, these containers have a sequence, that is, there is a dependency relationship. Then use docker-compose to orchestrate these four containers and build a container operating environment.

Four containers in total:

• Redis container: cache service
• Mysql container: data storage
• Django (Gunicorn) container: handling dynamic requests
• Nginx container: reverse proxy, processing static resources

Below is a diagram of the container structure.

Container dependencies: The Django container depends on the Redis container and the MySQL container, and the Nginx container depends on the Gunicorn container.

IV. Project Structure

Friends who are reading this tutorial, please try to keep the directory consistent with the directory in the tutorial, otherwise there is a high probability of errors in the subsequent deployment process.

my_blog is the Django project directory, and the deployment folder contains the configuration information of three containers except the Django container.

Dockerfile: Docker environment file

docker-compose.yml: orchestration container file

start.sh: Shell command script executed after container initialization

requirements.txt: Django project environment dependency file

gunicorn.conf: gunicorn configuration file

The deployment directory contains the mysql container configuration information, the nginx container configuration information, and the redis container data directory.

mysql: stores database configuration information, conf stores the database initialization configuration file my.cnf, data is used to mount database data, and init stores the sql script (imports table structure and data, and mounts it into the container).

nginx: Place nginx configuration information, ssl places ssl certificates

redis: mount redis data

5. Build a Django container environment

1. Writing Dockerfile for Django project

The container environment is isolated from the local environment. You can think of the container as another system . Initially, this system has nothing to do with your local system. We configure and build the container environment by writing a Dockerfile file (just like configuring a Python environment in a clean system).

# Create a python 3.6 environment FROM daocloud.io/python:3.6

# Mirror author MAINTAINER zyk [email protected]

# Set Python environment variable ENV PYTHONUNBUFFERED 1

# Create the my_blog folder RUN mkdir /my_blog

# Set the my_blog folder as the working directory WORKDIR /my_blog

# Add the current directory to the working directory (. represents the current directory)
ADD ./my_blog

# Use pip to install dependencies (- i indicates that the Tsinghua source is specified, the default source download is too slow)
RUN pip3 install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple/

#Set environment variable ENV SPIDER=/my_blog

2. Write the gunicorn configuration file

Write the gunicorn.conf file for starting gunicorn

workers=3 #Number of parallel worker processes threads = 2 #Specify the number of threads for each worker bind=['0.0.0.0:8000'] #Listen on intranet port 8000 
proc_name='my_blog' # process name pidfile='/tmp/blog.pid' # set process file directory worker_class='gevent' # working mode coroutine timeout=30 # timeout max_requests=6000 # maximum number of requests

3. Write the start.sh command script

The start.sh script is used to start the Django container

#!/bin/bash
# From the first line to the last line, they represent:
# 1. The daemon executes celery. If you don't have this requirement, you can delete the first line of command. # 2. Collect static files to the root directory.
# 3. Generate database executable file,
# 4. Modify the database according to the database executable file # 5. Start the Django service celery with gunicorn multi start w1 -A celery_tasks.tasks worker -l info&&
python manage.py collectstatic --noinput &&
python manage.py makemigrations &&
python manage.py migrate&&
gunicorn my_blog.wsgi:application -c gunicorn.conf

6. Build the nginx container environment

1. nginx container Dockefile writing

Create and write the Dockerfile in the nginx folder

# nginx image FROM daocloud.io/nginx

# Delete the original configuration file, create a static resource folder and an SSL certificate storage folder RUN rm /etc/nginx/conf.d/default.conf \
&& mkdir -p /usr/share/nginx/html/static \
&& mkdir -p /usr/share/nginx/html/media \
&& mkdir -p /usr/share/nginx/ssl

# Add configuration file ADD ./nginx.conf /etc/nginx/conf.d/

2. Configure nginx.conf

nginx.conf is used to reverse proxy the domain name or IP, distribute dynamic requests to port 8000 of the internal Django container, and configure the static resource path.

When configuring the reverse proxy, note that host must be changed to web, where web is the name of the Django container (configured in docker-compose.yml)

# Only used for local docker environment testing (port 80 proxy http request)
server {
 listen 80; # Listen to port 80 server_name 127.0.0.1; # For production environment, please change to domain name location / {
  proxy_pass http://web:8000; # Reverse proxy Django container port 8000, web is the name of the Django container, remember not to write the domain name or IP
  proxy_set_header Host $host;
  proxy_redirect off;
  proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
 }
 location /static/ {
  alias /usr/share/nginx/html/static/; #static resource path}
 location /media/ {
  alias /usr/share/nginx/html/media/; #Upload file path}
}

7. Configure MySQL

1. Write the my.cnf file

The my.cnf file is used to initialize the mysql configuration. This file will be mounted into the container.

[mysqld]
user=mysql
default-storage-engine=INNODB
character-set-server=utf8
sql_mode=STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION
[client]
default-character-set=utf8
[mysql]
default-character-set=utf8

2. Import the initialization sql file (those who do not need to import the initial database can ignore this step)

Put the sql file to be imported into the init directory and change its name to init.sql

8. Orchestrate containers with docker-compose

Write docker-compose.yml

version: "3"
services:
 redis:
 image: daocloud.io/redis:3
 command: redis-server
 volumes:
  - ./deployment/redis:/data
 ports:
  - "6379:6379"
 restart: always #Always restart db when an error occurs during the operation of the table container:
 image: daocloud.io/mysql:5.7
 environment:
  - MYSQL_DATABASE=my_blog # Database name - MYSQL_ROOT_PASSWORD=19960331 # Database password volumes:
  - ./deployment/mysql/data:/var/lib/mysql # Mount database data - ./deployment/mysql/conf/my.cnf:/etc/mysql/my.cnf # Mount configuration file - ./deployment/mysql/init:/docker-entrypoint-initdb.d/ # Mount data initialization sql script ports:
  - "3306:3306"
 restart: always

 web:
 build: .
 expose:
  - "8000"
 volumes:
  - .:/my_blog
  - /tmp/logs:/tmp
 command: bash start.sh
 links:
  -db
  - redis
 depends_on:
  -db
  - redis
 restart: always

 nginx:
 build: deployment/nginx
 ports:
  - "80:80"
  - "443:443"
 expose:
  - "8000"
 volumes:
  - ./collect_static:/usr/share/nginx/html/static # Mount static files - ./media:/usr/share/nginx/html/media # Mount uploaded files - ./deployment/nginx/ssl:/usr/share/nginx/ssl # Mount ssl certificate directory links:
  - web
 depends_on:
  - web
 restart: always

redis, db, web, and nginx are the container names.

image indicates the name of the image to be pulled, and build will search for the Dockerfile in the given directory and build the container environment.

Expose means exposing the port to other containers but not to the host (different containers are isolated from each other by default).

ports means mapping the container port to the host port (read from right to left, for example, ports: - "3307:3306" means mapping the container's port 3306 to the host's port 3307). The container port will also be open to other containers.

Volumes means mounting, which is to map the local files and the files in the container. The container and the local environment are originally isolated. Mounting is equivalent to drilling a small hole so that the data of the two can communicate with each other.

Links connects containers to each other.

depends_on: indicates dependency, because containers are started in order, the Django container depends on the MySQL container and the Redis container (Django needs to read and write data from the database and cache), and the nginx container depends on the Django container (the nginx container needs to reverse proxy the Django container's port 8000)

9. Build and run the container

Before building and running the container, you need to modify the settings.py file of the Django project.

Change the database connection HOST to mysql container name db

DATABASES = {
 'default': {
  'ENGINE': 'django.db.backends.mysql', # mysql driver'NAME': 'my_blog', # database name'USER': 'root', # login account'PASSWORD': '19960331', # login password'HOST': 'db', # host address (container deployment)
  # 'HOST': '127.0.0.1', # Host address'PORT': '3306', # Port'OPTIONS': {'charset': 'utf8mb4'},
 }
}

Change the host in the cache configuration to the redis container name redis (if you have configured redis as a cache, please ignore it if you have not configured it)

CACHES = {
 'default': {
  'BACKEND': 'django_redis.cache.RedisCache',
  'LOCATION': 'redis://redis:6379', # redis (container)
  # 'LOCATION': '127.0.0.1:6379',
  'OPTIONS': {
   "CLIENT_CLASS": "django_redis.client.DefaultClient",
   "CONNECTION_POOL_KWARGS": {"max_connections": 100},
   'SOCKET_TIMEOUT': 10,
  },
 },
}

For production deployment, please change DEBUG = True in settings.py DEBUG = False to disable debug mode.

Finally, execute the command docker-compose up --build in the project root directory.

After the execution is completed, you will see the following screen indicating that the build is successful.

Access 127.0.0.1 or your public IP address in the browser port. If you can access it successfully, it means the build is successful.

10. Finally

This is also the first time I use docker-compose to deploy a Django project. If there are any inappropriate or incorrect writing, please help point it out.

The above is the full content of this article. I hope it will be helpful for everyone’s study. I also hope that everyone will support 123WORDPRESS.COM.