Implementierung der Docker-Bereitstellung von Django+Mysql+Redis+Gunicorn+Nginx

I. Einleitung

Die Docker-Technologie erfreut sich derzeit großer Beliebtheit. Durch den Aufbau einer Projektumgebung mithilfe von Containern sind die Betriebs- und Bereitstellungseffizienz sehr gut. Deshalb habe ich mir vor Kurzem die Zeit genommen, einige Tutorials zu lesen, und dann die Bereitstellungsmethode im Blog auf Docker geändert. Ich hatte das Gefühl, dass es im Internet keine besonders guten Tutorials zum Bereitstellen von Django -Projekten mit Docker gibt, deshalb habe ich diesen Artikel speziell geschrieben, um meine eigenen Erfahrungen aufzuzeichnen.

Die Testumgebung dieses Tutorials ist Deepin . Es konzentriert sich hauptsächlich auf Container-Orchestrierung und Django -bezogene Bereitstellungskenntnisse. Einige Details, wie die Installation von Umgebungsabhängigkeiten, werden nicht ausführlich erläutert. Da es lokal getestet wird, wird beim Konfigurieren von Nginx- bezogenen Informationen der HTTP- Proxy anstelle des HTTPS -Proxys konfiguriert.

2. Umweltabhängigkeit

Die Bereitstellungsmethode ist Docker plus Docker-Compose, Sie müssen also Docker und Docker-Compose installieren.

• Docker kann mit dem Befehl sudo apt install docker-ce installiert werden.
• docker-compose kann mit dem folgenden Befehl installiert werden.

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

Geben Sie nach Abschluss der Installation docker version ein. Der folgende Bildschirm wird angezeigt, der angibt, dass Docker erfolgreich installiert wurde.

Geben Sie docker-compose version ein und sehen Sie sich den folgenden Bildschirm an, der angibt, dass Docker-Compose erfolgreich installiert wurde.

3. Einsatzanalyse

Das Blog-Projekt verwendet Django , Mysql , Redis und Nginx , daher sind vier Container erforderlich, wobei jeder Container einer Anwendung entspricht. Natürlich haben diese Container eine Sequenz, d. h. es besteht eine Abhängigkeitsbeziehung. Verwenden Sie dann Docker-Compose, um diese vier Container zu orchestrieren und eine Container-Betriebsumgebung zu erstellen.

Insgesamt vier Container:

• Redis-Container: Cache-Dienst
• Mysql-Container: Datenspeicherung
• Django (Gunicorn)-Container: Umgang mit dynamischen Anfragen
• Nginx-Container: Reverse-Proxy, Verarbeitung statischer Ressourcen

Unten sehen Sie ein Diagramm der Containerstruktur.

Containerabhängigkeiten: Der Django-Container ist vom Redis-Container und vom MySQL-Container abhängig, und der Nginx-Container ist vom Gunicorn-Container abhängig.

IV. Projektstruktur

Freunde, die dieses Tutorial lesen, versuchen Sie bitte, das Verzeichnis mit dem Verzeichnis im Tutorial konsistent zu halten, da sonst im nachfolgenden Bereitstellungsprozess eine hohe Fehlerwahrscheinlichkeit besteht.

my_blog ist das Django- Projektverzeichnis und der Bereitstellungsordner enthält die Konfigurationsinformationen von drei Containern mit Ausnahme des Django- Containers.

Dockerfile: Docker-Umgebungsdatei

docker-compose.yml: Orchestrierungscontainerdatei

start.sh: Shell-Befehlsskript, das nach der Containerinitialisierung ausgeführt wird

requirements.txt: Abhängigkeitsdatei der Django-Projektumgebung

gunicorn.conf: Gunicorn-Konfigurationsdatei

Das Bereitstellungsverzeichnis enthält die Konfigurationsinformationen des MySQL- Containers, die Konfigurationsinformationen des Nginx- Containers und das Datenverzeichnis des Redis -Containers.

mysql: speichert Datenbankkonfigurationsinformationen, conf speichert die Datenbankinitialisierungskonfigurationsdatei my.cnf, data wird zum Mounten von Datenbankdaten verwendet und init speichert das SQL-Skript (importiert Tabellenstruktur und Daten und mountet sie in den Container).

nginx: Platzieren Sie die Nginx-Konfigurationsinformationen, SSL platziert SSL-Zertifikate

redis: Redis-Daten mounten

5. Erstellen Sie eine Django-Containerumgebung

1. Dockerfile für Django-Projekt schreiben

Die Containerumgebung ist von der lokalen Umgebung isoliert . Sie können sich den Container als ein weiteres System vorstellen. Dieses System hat zunächst nichts mit Ihrem lokalen System zu tun . Wir konfigurieren und erstellen die Containerumgebung, indem wir eine Dockerfile -Datei schreiben (genau wie beim Konfigurieren einer Python-Umgebung in einem sauberen System).

# Erstellen Sie eine Python 3.6-Umgebung VON daocloud.io/python:3.6

# Spiegelautor MAINTAINER zyk [email protected]

# Python-Umgebungsvariable ENV PYTHONUNBUFFERED 1 festlegen

# Erstellen Sie den Ordner my_blog. RUN mkdir /my_blog

# Legen Sie den Ordner my_blog als Arbeitsverzeichnis fest WORKDIR /my_blog

# Das aktuelle Verzeichnis zum Arbeitsverzeichnis hinzufügen (. steht für das aktuelle Verzeichnis)
HINZUFÜGEN ./mein_blog

# Verwenden Sie pip, um Abhängigkeiten zu installieren (- i zeigt an, dass die Tsinghua-Quelle angegeben ist. Der Download der Standardquelle ist zu langsam.)
Führen Sie den Befehl pip3 install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple/ aus.

#Umgebungsvariable ENV SPIDER=/my_blog festlegen

2. Schreiben Sie die Gunicorn-Konfigurationsdatei

Schreiben Sie die Datei gunicorn.conf zum Starten von Gunicorn

workers=3 #Anzahl paralleler Arbeitsprozesse threads = 2 #Geben Sie die Anzahl der Threads für jeden Worker an bind=['0.0.0.0:8000'] #Auf Intranet-Port 8000 lauschen 
proc_name='my_blog' # Prozessname pidfile='/tmp/blog.pid' # Prozessdateiverzeichnis festlegen worker_class='gevent' # Arbeitsmodus Coroutine timeout=30 # Timeout max_requests=6000 # Maximale Anzahl an Anfragen

3. Schreiben Sie das Befehlsskript start.sh

Das Skript start.sh wird zum Starten des Django-Containers verwendet

#!/bin/bash
# Von der ersten bis zur letzten Zeile stellen sie dar:
# 1. Der Daemon führt Celery aus. Wenn Sie diese Anforderung nicht haben, können Sie die erste Befehlszeile löschen. # 2. Sammeln Sie statische Dateien im Stammverzeichnis.
# 3. Ausführbare Datenbankdatei generieren,
# 4. Ändern Sie die Datenbank entsprechend der ausführbaren Datenbankdatei. # 5. Starten Sie den Django-Dienst Celery mit gunicorn multi start w1 -A celery_tasks.tasks worker -l info&&
python manage.py collectstatic --noinput &&
python manage.py makemigrations &&
python manage.py migrieren&&
gunicorn my_blog.wsgi:Anwendung -c gunicorn.conf

6. Erstellen Sie die Nginx-Containerumgebung

1. Dockefile für Nginx-Container schreiben

Erstellen und schreiben Sie das Dockerfile in den nginx-Ordner

# nginx-Bild VON daocloud.io/nginx

# Löschen Sie die ursprüngliche Konfigurationsdatei, erstellen Sie einen statischen Ressourcenordner und einen SSL-Zertifikatspeicherordner 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

# Konfigurationsdatei ADD hinzufügen ./nginx.conf /etc/nginx/conf.d/

2. Konfigurieren Sie nginx.conf

nginx.conf wird verwendet, um den Domänennamen oder die IP per Reverse-Proxy zu übermitteln, dynamische Anforderungen an Port 8000 des internen Django-Containers zu verteilen und den statischen Ressourcenpfad zu konfigurieren.

Beachten Sie beim Konfigurieren des Reverse-Proxys, dass Host in Web geändert werden muss, wobei Web der Name des Django-Containers ist (konfiguriert in docker-compose.yml).

# Wird nur zum Testen der lokalen Docker-Umgebung verwendet (Proxy-HTTP-Anfrage über Port 80)
Server {
 listen 80; # Lauschen Sie auf Port 80 Servername 127.0.0.1; # Wechseln Sie für eine Produktionsumgebung bitte zum Domänennamen-Standort / {
  proxy_pass http://web:8000; # Reverse-Proxy Django-Container-Port 8000, Web ist der Name des Django-Containers, denken Sie daran, nicht den Domänennamen oder die IP zu schreiben
  Proxy_Set_Header Host $host;
  Proxy_Redirect aus;
  proxy_set_header X-Weitergeleitet-Für $proxy_add_x_forwarded_for;
 }
 Standort /static/ {
  Alias ​​/usr/share/nginx/html/static/; #statischer Ressourcenpfad}
 Standort /media/ {
  alias /usr/share/nginx/html/media/; #Dateipfad hochladen}
}

7. MySQL konfigurieren

1. Schreiben Sie die Datei my.cnf

Die Datei my.cnf wird zum Initialisieren der MySQL-Konfiguration verwendet. Diese Datei wird in den Container eingebunden.

[mysqld]
Benutzer=mysql
Standard-Speicher-Engine = INNODB
Zeichensatzserver = utf8
sql_mode=STRICT_TRANS_TABLES,KEINE_NULL_IM_DATUM,KEINE_NULL_DATUM,FEHLER_FÜR_DIVISION_DURCH_NULL,KEIN_AUTO_CREATE_USER,KEINE_ENGINE_SUBSTITUTION
[Kunde]
Standardzeichensatz = utf8
[mysql]
Standardzeichensatz = utf8

2. Importieren Sie die initialisierte SQL-Datei (wer die initiale Datenbank nicht importieren muss, kann diesen Schritt überspringen)

Legen Sie die zu importierende SQL-Datei in das Init-Verzeichnis und ändern Sie ihren Namen in init.sql

8. Container mit Docker-Compose orchestrieren

Schreiben Sie docker-compose.yml

Version: "3"
Leistungen:
 Redis:
 Bild: daocloud.io/redis:3
 Befehl: redis-server
 Bände:
  - ./Bereitstellung/Redis:/Daten
 Häfen:
  - „6379:6379“
 Neustart: immer #Datenbank immer neu starten, wenn während des Betriebs des Tabellencontainers ein Fehler auftritt:
 Bild: daocloud.io/mysql:5.7
 Umfeld:
  - MYSQL_DATABASE=my_blog # Datenbankname - MYSQL_ROOT_PASSWORD=19960331 # Datenbankkennwort-Volumes:
  - ./deployment/mysql/data:/var/lib/mysql # Datenbankdaten mounten - ./deployment/mysql/conf/my.cnf:/etc/mysql/my.cnf # Konfigurationsdatei mounten - ./deployment/mysql/init:/docker-entrypoint-initdb.d/ # Initialisierung der Mount-Daten SQL-Skript-Ports:
  - „3306:3306“
 Neustart: immer

 Webseite:
 bauen: .
 exponieren:
  - "8000"
 Bände:
  - .:/mein_blog
  – /tmp/logs:/tmp
 Befehl: bash start.sh
 Links:
  -db
  - Redis
 hängt ab von:
  -db
  - Redis
 Neustart: immer

 nginx:
 Build: Bereitstellung/Nginx
 Häfen:
  - "80:80"
  - „443:443“
 exponieren:
  - "8000"
 Bände:
  - ./collect_static:/usr/share/nginx/html/static # Statische Dateien mounten - ./media:/usr/share/nginx/html/media # Hochgeladene Dateien mounten - ./deployment/nginx/ssl:/usr/share/nginx/ssl # SSL-Zertifikat-Verzeichnislinks mounten:
  - Netz
 hängt ab von:
  - Netz
 Neustart: immer

Die Containernamen sind „redis“, „db“, „web“ und „nginx“.

„image“ gibt den Namen des abzurufenden Images an, und „build“ sucht im angegebenen Verzeichnis nach der Docker-Datei und erstellt die Containerumgebung.

Expose bedeutet, den Port anderen Containern zugänglich zu machen, jedoch nicht dem Host (verschiedene Container sind standardmäßig voneinander isoliert).

Ports bedeutet, den Container-Port dem Host-Port zuzuordnen (von rechts nach links lesen, z. B. Ports: - „3307:3306“ bedeutet, den Port 3306 des Containers dem Port 3307 des Hosts zuzuordnen). Der Container-Port ist auch für andere Container geöffnet.

Volumes bedeutet Mounten, also das Zuordnen der lokalen Dateien und der Dateien im Container. Der Container und die lokale Umgebung sind ursprünglich isoliert. Das Mounten entspricht dem Bohren eines kleinen Lochs, damit die Daten der beiden miteinander kommunizieren können.

Links verbinden Container miteinander.

depends_on: zeigt eine Abhängigkeit an, da Container der Reihe nach gestartet werden. Der Django-Container hängt vom MySQL-Container und vom Redis-Container ab (Django muss Daten aus der Datenbank und dem Cache lesen und schreiben) und der Nginx-Container hängt vom Django-Container ab (der Nginx-Container muss den Port 8000 des Django-Containers per Reverse-Proxy verwenden).

9. Erstellen und Ausführen des Containers

Bevor Sie den Container erstellen und ausführen, müssen Sie die Datei settings.py des Django-Projekts ändern.

Ändern Sie den Datenbankverbindungs-HOST in den MySQL-Containernamen db

DATENBANKEN = {
 'Standard': {
  „ENGINE“: „django.db.backends.mysql“, # MySQL-Treiber „NAME“: „my_blog“, # Datenbankname „USER“: „root“, # Anmeldekonto „PASSWORD“: „19960331“, # Anmeldekennwort „HOST“: „db“, # Hostadresse (Containerbereitstellung)
  # 'HOST': '127.0.0.1', # Hostadresse 'PORT': '3306', # Port 'OPTIONS': {'charset': 'utf8mb4'},
 }
}

Ändern Sie den Host in der Cache-Konfiguration in den Redis-Containernamen „Redis“ (wenn Sie Redis als Cache konfiguriert haben, ignorieren Sie dies bitte, falls Sie es nicht konfiguriert haben).

CACHES = {
 'Standard': {
  'BACKEND': 'django_redis.cache.RedisCache',
  „ORT“: „redis://redis:6379“, # redis (Container)
  # 'Standort': '127.0.0.1:6379',
  'OPTIONEN': {
   "CLIENT_CLASS": "django_redis.client.DefaultClient",
   "CONNECTION_POOL_KWARGS": {"max_connections": 100},
   'SOCKET_TIMEOUT': 10,
  },
 },
}

Ändern Sie für die Produktionsbereitstellung DEBUG = True in settings.py DEBUG = False um den Debug-Modus zu deaktivieren.

Führen Sie abschließend den Befehl docker-compose up --build im Stammverzeichnis des Projekts aus.

Nachdem die Ausführung abgeschlossen ist, wird der folgende Bildschirm angezeigt, der angibt, dass der Build erfolgreich war.

Greifen Sie im Browser-Port auf 127.0.0.1 oder Ihre öffentliche IP-Adresse zu. Wenn Sie erfolgreich darauf zugreifen können, bedeutet dies, dass der Build erfolgreich war.

10. Abschließend

Dies ist auch das erste Mal, dass ich Docker-Compose verwende, um ein Django-Projekt bereitzustellen. Wenn es unangemessene oder falsche Schreibweisen gibt, helfen Sie bitte, mich darauf hinzuweisen.

Das Obige ist der vollständige Inhalt dieses Artikels. Ich hoffe, er wird für jedermanns Studium hilfreich sein. Ich hoffe auch, dass jeder 123WORDPRESS.COM unterstützen wird.