Lancer une application Web Python sur Nginx + Gunicorn avec Docker

Constitution

--Serveur Web - nginx

• Serveur WSGI (serveur AP)
  • Gunicorn
• Framework d'application Web
  • Django
• Comme WSGI est utilisé ici, d'autres frameworks peuvent être utilisés tant qu'ils sont conformes WSGI.
• Aucun paramètre spécifique à Django n'apparaît dans cet article
• Le serveur Web et le serveur WSGI s'exécutent dans le conteneur Docker --Utilisez le socket de domaine UNIX pour la communication entre le serveur Web et le serveur WSGI

Arrangement des termes

Qu'est-ce qu'un serveur WSGI?

--WSGI signifie Web Server Gateway Interface, qui est un protocole de communication entre un serveur Web et un serveur AP en Python.

• Les cadres tels que Django, Flask et Bottle sont également conformes à ce protocole.
• Le serveur AP qui est conforme au WSGI ci-dessus est appelé un serveur WSGI, et Gunicorn en fait partie.
• Les serveurs WSGI autres que gunicorn ont uWSGI

Qu'est-ce qu'une socket de domaine UNIX?

• Méthode de communication pour rechercher un partenaire de communication via le chemin du système de fichiers
• Un fichier est créé dans ce chemin et chaque processus accède au fichier ――Il semble que vous partagiez simplement un fichier, mais le fichier créé est un fichier spécial appelé fichier socket et il n'y a pas de situation réelle. --Interface de Communication

Construire

Gunicorn

• Tout d'abord, essayez d'exécuter le serveur WSGI seul

Création de projet

--Installez Django

$ pip install Django==3.0.2

--Créez un projet dans votre environnement de travail

$ django-admin.py startproject django_project .

• Ici, créez un projet avec le nom django_project --Si vous vérifiez avec la commande tree, ce sera comme suit

$ tree
.
├── django_project
│   ├── __init__.py
│   ├── asgi.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
├── manage.py

Démarrer le conteneur Gunicorn

--Créer un Dockerfile

FROM python:3.8.0-alpine

WORKDIR /usr/src/app

ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1

RUN pip install --upgrade pip
COPY ./requirements.txt /usr/src/app/requirements.txt
RUN pip install -r requirements.txt

--requirements.txt se présente comme suit

requirements.txt

Django==3.0.2
gunicorn==20.0.4

--Construire

$ docker build -t gunicorn:tmp .

• La description de docker-compose.yaml est la suivante
• J'ajouterai des informations nginx plus tard

version: '3.7'

services:
  gunicorn:
    image: gunicorn:tmp 
    container_name: gunicorn
    command: python manage.py runserver 0.0.0.0:8000
    volumes:
      - .:/usr/src/app/
    ports:
      - 8000:8000

• La commande python manage.py runserver 0.0.0.0: 8000 démarre un serveur de test simple
• Ici, le port 8000 est transféré pour vérifier le fonctionnement.
• Commencez avec $ docker-compose up -d```, accédez à localhost: 8000, et si l'écran Django est affiché, c'est OK.

Paramètres pour utiliser les sockets de domaine UNIX avec Nginx

• Utilisez l'image Docker officielle, mais créez un fichier de configuration qui décrit les paramètres de socket du domaine UNIX et montez-le au démarrage. --Description du contenu suivant avec le nom gunicorn.conf

gunicorn.conf

upstream gunicorn-django {
    server unix:///var/run/gunicorn/gunicorn.sock;
}

server {
    listen 80;
    server_name localhost;

    location / {
        try_files $uri @gunicorn;
    }

    location @gunicorn {
        proxy_pass http://gunicorn-django;
    }
}

--```upstream gunicorn-django {…} le contenu est les paramètres de socket de domaine UNIX --Communiquer avec gunicorn via le fichier socket dans le chemin décrit

• En d'autres termes, il est nécessaire de configurer pour appeler également ce fichier socket du côté gunicorn.
• Après cela, vous pouvez spécifier gunicorn-django spécifié par upstream dans proxy_pass de location.
• La description de docker-compose.yaml de Nginx est la suivante

version: '3.7'

services:
  nginx:
    image: nginx:1.17.7
    container_name: nginx
    ports:
      - "80:80"
    volumes:
      - ./gunicorn.conf:/etc/nginx/conf.d/default.conf

--Monter dans Nginx avec le nom / etc / nginx / conf.d / default.conf --Nginx lit /etc/nginx/nginx.conf au démarrage et ditinclure /etc/nginx/conf.d / *. Conf; `` dans ce fichier, donc Si vous montez le fichier de configuration que vous avez créé sous/ etc / nginx / conf.d```, il sera lu ensemble au démarrage.

Paramètres pour utiliser le socket de domaine UNIX avec Gunicorn

• Apportez des modifications à l'état où il a été démarré localement plus tôt

Commande de démarrage du conteneur

Paramètres WSGI

• Vous devez appuyer sur la commande gunicorn suivante pour que Gunicorn puisse communiquer avec Nginx

gunicorn django_project.wsgi

--Ceci lit wsgi.py sous django_project, qui est construit lorsque vous créez un projet appelé django_project cette fois. --Manage.py a été démarré lors du démarrage local, mais cette commande est requise lors de la communication avec WSGI.

Paramètres de socket de domaine UNIX

--Spécifiez le chemin du fichier de socket de démarrage avec --bind``` pour communiquer avec les sockets de domaine UNIX

gunicorn django_project.wsgi　--bind=unix:/var/run/gunicorn/gunicorn.sock

• Cela permet la communication de socket de domaine UNIX avec gunicorn

Correction de Doickerfile

--Changed CMD of Dockerfile basé sur le contenu ci-dessus

Dockerfile

FROM python:3.8.0-alpine

WORKDIR /usr/src/app

ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1

RUN pip install --upgrade pip
COPY ./requirements.txt /usr/src/app/requirements.txt
RUN pip install -r requirements.txt

RUN mkdir -p /var/run/gunicorn

CMD ["gunicorn", "django_project.wsgi", "--bind=unix:/var/run/gunicorn/gunicorn.sock"]

--Construire à nouveau

$ docker build -t gunicorn:latest .

Spécifiez un hôte pouvant accéder au projet Django

--Spécifiez dans ʻALLOWED_HOSTS = [] dans setting.py créé sous django_project --Il devrait être restreint normalement, mais ici il est défini sur ʻALLOWED_HOSTS = [*] pour permettre l'accès de tous les hôtes.

• Ce fichier est appelé depuis wsgi.py

Créer un volume à monter avec la communication de socket de domaine UNIX

• Puisque le chemin du fichier socket a été spécifié dans Nginx et Gunicorn, il est nécessaire de créer un volume de fichier socket.
• Cette fois, nous allons commencer avec Docker, donc créez un volume de Docker au démarrage et montez-le à partir de deux conteneurs sur ce volume. --Le dernier docker-compose.yaml est le suivant

docker-compose.yaml

version: '3.7'

services:
  gunicorn:
    image: gunicorn:latest
    container_name: gunicorn
    volumes:
      - .:/usr/src/app/
      - gunicorn:/var/run/gunicorn
  nginx:
    image: nginx:1.17.7
    container_name: nginx
    depends_on:
      - gunicorn
    ports:
      - "80:80"
    volumes:
      - ./gunicorn.conf:/etc/nginx/conf.d/default.conf
      - gunicorn:/var/run/gunicorn
volumes:
  gunicorn:
    driver: local

--Créez un volume appelé gunicorn et montez-le dans chaque conteneur (cette fois, / var / run / gunicorn est spécifié dans les deux conteneurs)

Opération

• Commencez avec la commande suivante

$ docker-compose up -d
Starting gunicorn ... done
Starting nginx    ... done

• Essayez d'accéder à localhost après le démarrage

--OK si l'écran est affiché

• L'écran affiché est le même que lorsque Gunicorn a été exécuté pour la première fois seul, mais cette fois, il est affiché via nginx.

Code source

• L'ensemble des fichiers créés cette fois est ici

référence

• Guide de démarrage rapide: Docker Compose et Django
• Introduction à uWSGI
• Socket de domaine Unix
• Qui dirige django? (Présentation du déploiement)
• Paramètres Django ALLOWED_HOSTS
• Exécutez des applications Web Python sur gunicorn (Django et Flask)