Verfassung

Webserver
- nginx --WSGI-Server (AP-Server)
- Gunicorn --Web Application Framework
- Django
Da hier WSGI verwendet wird, können andere Frameworks verwendet werden, solange sie WSGI-kompatibel sind.
In diesem Artikel werden keine Django-spezifischen Einstellungen vorgenommen --Webserver und WSGI-Server werden im Docker-Container ausgeführt
Verwenden Sie den UNIX-Domänensocket für die Kommunikation zwischen Webserver und WSGI-Server

Vereinbarung von Begriffen

Was ist ein WSGI-Server?

--WSGI steht für Web Server Gateway Interface, ein Protokoll für die Kommunikation zwischen einem Webserver und einem AP-Server in Python.

Rahmenwerke wie Django, Flask und Bottle entsprechen ebenfalls diesem Protokoll.
Der AP-Server, der dem oben genannten WSGI entspricht, wird als WSGI-Server bezeichnet, und Gunicorn ist einer davon.
Andere WSGI-Server als Gunicorn haben uWSGI

Was ist ein UNIX-Domain-Socket?

--Kommunikationsmethode zur Suche nach einem Kommunikationspartner über den Pfad des Dateisystems

In diesem Pfad wird eine Datei erstellt, und jeder Prozess greift auf die Datei zu ――Es scheint, dass Sie nur eine Datei freigeben, aber die erstellte Datei ist eine spezielle Datei, die als Socket-Datei bezeichnet wird, und es gibt keine tatsächliche Situation. --Kommunikationsinterface

Bauen

Gunicorn

Versuchen Sie zunächst, den WSGI-Server alleine auszuführen

Projekterstellung

Installieren Sie Django

$ pip install Django==3.0.2

--Erstellen Sie ein Projekt in Ihrer Arbeitsumgebung

$ django-admin.py startproject django_project .

--Hier erstellen Sie ein Projekt mit dem Namen django_project

Wenn Sie mit dem Befehl tree nachsehen, ist dies wie folgt

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

Starten Sie den Gunicorn-Container

--Erstellen Sie eine Docker-Datei

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 lautet wie folgt

`requirements.txt`


Django==3.0.2
gunicorn==20.0.4

--Bauen

$ docker build -t gunicorn:tmp .

Die Beschreibung von docker-compose.yaml lautet wie folgt
Ich werde später Nginx-Informationen hinzufügen

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

Der Befehl python manage.py runserver 0.0.0.0: 8000``` startet einen einfachen Testserver
Hier wird Port 8000 weitergeleitet, um den Betrieb zu überprüfen. --Starten Sie mit `` `$ docker-compose up -d```, greifen Sie auf localhost: 8000 zu, und wenn der Django-Bildschirm angezeigt wird, ist dies in Ordnung.

Einstellungen zur Verwendung von UNIX-Domain-Sockets mit Nginx

Verwenden Sie das offizielle Docker-Image, erstellen Sie jedoch eine conf-Datei, in der die Einstellungen des UNIX-Domain-Sockets beschrieben sind, und hängen Sie sie beim Start ein. --Beschreiben Sie den folgenden Inhalt mit dem Namen 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 {…} `` `Inhalte sind UNIX Domain Socket Einstellungen --Kommunizieren Sie mit Gunicorn über die Socket-Datei im beschriebenen Pfad

Mit anderen Worten, es ist notwendig, diese Socket-Datei auch von der Gunicorn-Seite aufzurufen.
Danach können Sie gunicorn-django angeben, das von upstream in proxy_pass of location angegeben wird.
Die Beschreibung von docker-compose.yaml von Nginx lautet wie folgt

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

--Mount in Nginx mit dem Namen `/ etc / nginx / conf.d / default.conf``` --Nginx liest /etc/nginx/nginx.conf beim Start und sagt include /etc/nginx/conf.d / *. Conf; in diese Datei, also Wenn Sie die unter `/ etc / nginx / conf.d``` erstellte conf-Datei mounten, wird sie beim Start zusammen gelesen.

Einstellungen zur Verwendung des UNIX-Domain-Sockets mit Gunicorn

Nehmen Sie einige Änderungen gegenüber dem Status vor, in dem es zuvor lokal gestartet wurde

Befehl zum Starten des Containers

WSGI-Einstellungen

Sie müssen den folgenden Gunicorn-Befehl ausführen, damit Gunicorn mit Nginx kommunizieren kann

gunicorn django_project.wsgi

--Dies liest wsgi.py unter django_project, das erstellt wird, wenn Sie dieses Mal ein Projekt namens django_project erstellen. --Manage.py wurde beim lokalen Start gestartet, dieser Befehl ist jedoch für die Kommunikation mit WSGI erforderlich.

UNIX Domain Socket Einstellungen

Geben Sie den Pfad der Start-Socket-Datei mit `` `--bind``` an, um mit UNIX-Domain-Sockets zu kommunizieren.

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

Dies ermöglicht die Kommunikation zwischen UNIX-Domain-Sockets und Gunicorn

Doickerfile beheben

CMD von Dockerfile basierend auf den oben genannten Inhalten geändert

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

Wieder bauen

$ docker build -t gunicorn:latest .

Geben Sie einen Host an, der auf das Django-Projekt zugreifen kann

Geben Sie in ALLOWED_HOSTS = [] in settings.py an, das unter django_project erstellt wurde
Es sollte normal eingeschränkt werden, aber hier ist es auf "ALLOWED_HOSTS = [*]" gesetzt, um den Zugriff von allen Hosts zu ermöglichen. --Diese Datei wird von wsgi.py aufgerufen

Erstellen Sie ein Volume, das mit UNIX-Domain-Socket-Kommunikation bereitgestellt werden soll

Da der Socket-Dateipfad in Nginx und Gunicorn angegeben wurde, muss ein Socket-Dateivolume erstellt werden.
Dieses Mal beginnen wir mit Docker. Erstellen Sie also beim Start ein Docker-Volume und hängen Sie es von zwei Containern auf dieses Volume.
Die endgültige Docker-compose.yaml ist wie folgt

`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

--Erstelle ein Volume namens Gunicorn und montiere es in jeden Container (diesmal ist in beiden Containern / var / run / gunicorn angegeben).

Operation

--Starten Sie mit dem folgenden Befehl

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

Versuchen Sie nach dem Start auf localhost zuzugreifen

--OK wenn der Bildschirm angezeigt wird

Der angezeigte Bildschirm ist der gleiche wie zu dem Zeitpunkt, als Gunicorn zum ersten Mal alleine ausgeführt wurde, diesmal jedoch über Nginx.

Quellcode

Die diesmal erstellten Dateien sind hier

Starten Sie mit Docker eine Python-Webanwendung auf Nginx + Gunicorn