So verwenden Sie Docker zum Bereitstellen eines Django-Technologie-Stack-Projekts

Mit der Popularität und Reife von Docker ist es allmählich zur ersten Wahl für die Bereitstellung von Projekten geworden. Heute werde ich Ihnen zeigen, wie Sie Docker zum Bereitstellen von Projekten mit dem Django-Technologiestapel verwenden.

Der Django-Technologie-Stack, über den wir hier sprechen, ist: Python3.6, Django2.2, Redis, MySQL, Celery, Gunicorn und Nginx. In tatsächlichen Produktionsprojekten werden diese Komponenten auf verschiedene Maschinen im Cluster verteilt. Beispielsweise können Nginx, Redis und Mysql von separaten Teams oder Abteilungen verwaltet werden. Die Bereitstellungsarchitektur und die Container-Orchestrierung sind komplexer und werden in diesem Artikel nicht näher untersucht. In diesem Artikel wird hauptsächlich die Verwendung von Docker-Compose zur Orchestrierung dieser Komponenten beschrieben. Diese Methode eignet sich für die Bereitstellung einer Testumgebung oder Ihres persönlichen Nebenprojekts.

Dieser Artikel setzt voraus, dass Sie bereits über Grundkenntnisse zu Docker und Docker-Compose verfügen. Wenn nicht, können Sie die folgenden Materialien lesen:

• Docker-Wissen
• Offizielle Docker-Dokumentation
• Docker Compose-Dokumentation

Lassen Sie uns über die Bereitstellung sprechen.

Projektorganisationsstruktur

Werfen wir zunächst einen Blick auf die Organisationsstruktur unseres Projekts. Sie sieht wie folgt aus:

├── LIZENZ
├── README.md
├── komponieren
│ ├── Sellerie
│ │ ├── Docker-Datei
│ │ ├── celery-beat.sh
│ │ └── celery.sh
│ ├── MySQL
│ │ └── meine.cnf
│ ├── nginx
│ │ └── nginx.conf
│ └── Internet
│ ├── Docker-Datei
│ ├── entrypoint.sh
│ ├── gunicorn.conf
│ └── gunicorn.sh
├── docker-compose.yml
├── docker_django_demo
│ ├── __init__.py
│ ├── celery.py
│ ├── Einstellungen.py
│ ├── urls.py
│ └── wsgi.py
├── env.tpl
├── verwalten.py
├── Anforderungen.txt

Zusätzlich zu den Django-Projektdateien sind die wichtigsten Ergänzungen das Compose-Konfigurationsdateiverzeichnis und die Konfigurationsdatei docker-compose.yml.

• Im Compose-Verzeichnis werden hauptsächlich die Dockerfile-Dateien und Startskripte der einzelnen Komponenten gespeichert.
• docker-compose.yml ist die Orchestrierungskonfigurationsdatei von Docker-Compose.

Dockerfile schreiben und Initialisierungsskript starten

In Docker-Compose gibt es zwei Möglichkeiten, den Container zu starten: Eine besteht darin, den Container direkt mit einem öffentlichen Image zu starten, und die andere darin, eine von uns selbst geschriebene Docker-Datei zu verwenden. Da wir zusätzliche Toolkits installieren und zugehörige Konfigurationen initialisieren müssen, verwenden wir eine benutzerdefinierte Docker-Datei für die Web- und Celery-Komponenten.

compose/web/Dockerfile für den Webcontainer:

VON python:3.6
ENV PYTHONUNBUFFERED 1

Führen Sie mkdir /code aus.
ARBEITSVERZEICHNIS /code

KOPIEREN ./requirements.txt /code/
Führen Sie den Befehl pip install --no-cache-dir -r requirements.txt \ aus.
  && rm -rf Anforderungen.txt

KOPIEREN ./code/
KOPIEREN ./compose/web/*.sh /code/
RUN sed -i 's/\r//' gunicorn.sh \
  && chmod +x gunicorn.sh \
  && sed -i 's/\r//' Einstiegspunkt.sh \
  && chmod +x entrypoint.sh

EINSTIEGSPUNKT ["/bin/bash", "entrypoint.sh"]

Andere Dateien des Webcontainers:

• compose/web/entrypoint.sh ist das Startskript des Webcontainers, das eine Initialisierungs- oder Erkennungslogik ausführt.
• compose/web/gunicorn.conf Gunicorn-Konfigurationsdatei.
• compose/web/gunicorn.sh ist das Startskript von Gunicorn.

Dockerfile für Sellerie:

VON python:3.6
ENV PYTHONUNBUFFERED 1

Führen Sie mkdir /code aus.
ARBEITSVERZEICHNIS /code

KOPIEREN ./requirements.txt /code/
KOPIEREN ./compose/celery/*.sh /code/
Führen Sie den Befehl pip install --no-cache-dir -r requirements.txt \ aus.
  && rm -rf Anforderungen.txt && sh init_env.sh

KOPIEREN ./code/
KOPIEREN ./compose/celery/*.sh /code/
RUN sed -i 's/\r//' celery.sh \
  && chmod +x celery.sh \
  && sed -i 's/\r//' celery-beat.sh \
  && chmod +x celery-beat.sh

Andere Dateien von Sellerie:

• compose/celery/celery.sh Celery-Startskript.
• compose/celery/celery-beat.sh Das Startskript von celery-beat.

Schreiben Sie die Compose-Startkonfigurationsdatei

Die Docker-Compose-Konfiguration sieht wie folgt aus:

Version: '2'

Leistungen:
 Redis:
  Bild: Redis
  Häfen:
   - „6379:6379“

 db:
  Neustart: immer
  Bild:mysql:5.7.19
  # Befehl: --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci
  Bände:
   - ./compose/mysql/:/etc/mysql/conf.d
   - ./db:/var/lib/mysql
  # für Test
  Häfen:
   – „127.0.0.1:3307:3306“
   # (HOST:CONTAINER)
  Umgebungsdatei:
   - .env

 Webseite:
  # Neustart: immer
  bauen:
   Kontext: .
   Docker-Datei: ./compose/web/Dockerfile
  Befehl: sh gunicorn.sh # ["/bin/bash", "gunicorn.sh"]
  Häfen:
   - „8080:8002“
   # (HOST:CONTAINER)
  Bände:
   - ./logs:/var/logs/
   - ./collect_static:/code/collect_static
   - ./static:/code/static
   - ./Vorlagen:/Code/Vorlagen
   - ./uploads:/code/uploads
  Umgebungsdatei: .env
  hängt ab von:
   - Redis
   -db

 nginx:
  Neustart: immer
  Bild: nginx:1.13.0
  Bände:
   - ./compose/nginx:/etc/nginx/conf.d/
   - ./staticfiles:/code/staticfiles
   - ./logs:/var/log/nginx
  Häfen:
   - "80:80"
   # (HOST:CONTAINER)
  hängt ab von:
   - Netz

 Sellerie:
  bauen:
   Kontext: .
   Docker-Datei: ./compose/celery/Dockerfile
  Befehl: sh celery.sh
  Bände:
   - ./logs:/var/logs/
   - ./uploads:/code/uploads
  hängt ab von:
   - Redis
   -db
  Umgebungsdatei: .env

 Sellerie-Beat:
  bauen:
   Kontext: .
   Docker-Datei: ./compose/celery/Dockerfile
  Befehl: sh celery-beat.sh
  Bände:
   - ./logs:/var/logs/
  hängt ab von:
   - Redis
   -db
  Umgebungsdatei: .env

Celery Worker und Beat Hier verwenden wir dasselbe Image-Dockerfile. Nach dem Prinzip „ein Image und ein Prozess“ starten wir zwei Container, um jeweils den Worker- und Beat-Prozess auszuführen.

Test kompilieren

Nachdem Sie die Konfigurationsdatei geschrieben haben, kompilieren und testen Sie das Image:

Docker-Compose-Build - Entwicklertools 
docker-compose up # Im Vordergrund ausführen docker-compose up -d # Im Hintergrund ausführen, nachdem alles korrekt ist

docker-compose ps Sie können den gestarteten Container sehen:

$ Docker-Compose ps  
       Name Befehl Status Ports     
--------------------------------------------------------------------------------------------------
docker djangodemo_celery-beat_1 sh celery-beat.sh Nach oben               
docker djangodemo_celery_1 sh celery.sh Nach oben               
dockerdjangodemo_db_1 docker-entrypoint.sh mysqld Up 127.0.0.1:3307->3306/tcp
dockerdjangodemo_nginx_1 nginx -g Daemon aus; Hoch 0.0.0.0:80->80/tcp   
dockerdjangodemo_redis_1 docker-entrypoint.sh redis ... Nach oben 0.0.0.0:6379->6379/tcp 
dockerdjangodemo_web_1 /bin/bash entrypoint.sh sh ... Hoch 0.0.0.0:8080->8002/tcp 

Der Mapping-Port kann entsprechend Ihrer tatsächlichen Situation angepasst werden.

Frage

Hier sind einige Punkte, die während des Bauprozesses beachtet werden müssen.

MySQL-Kodierungsproblem

Die Standardkodierung des von Docker bereitgestellten MySQL-Images ist latin1, wodurch beim Speichern von Chinesisch verstümmelte Zeichen angezeigt werden. Auf der offiziellen Website finden Sie eine Methode zum Ändern der Kodierungsmethode. Sie können das Kodierungsformat nach dem Starten des Skripts angeben. Das Dokument finden Sie hier. Für die MySQL-Containerversion 5.7.19 können Sie die Parameter --character-set-server=utf8mb4 --collation-server=utf8mb4_general_ci direkt nach dem Befehl in docker-compose.yml hinzufügen. Diese Methode ändert nur die Kodierung auf der Serverseite. Sie können die Konfigurationsdatei direkt verwenden, um alle Kodierungsformate zu überschreiben und anzugeben.

Die Konfiguration ist wie folgt:

[mysqld]
Standard-Speicher-Engine = INNODB
Zeichensatzserver = utf8mb4
Sortierserver = utf8mb4_general_ci
init-connect='Namen festlegen utf8mb4'
init_connect = 'SET-Sortierung_Verbindung = utf8mb4_general_ci'
skip-character-set-client-handshake # Überspringe die Client-Kodierungskonfiguration, und der Client verwendet direkt die Server-Kodierungskonfiguration bind-address = 0.0.0.0

Hinweis: Die Konfigurationsdateimethode von MySQL 5.7.19 ist erfolgreich, während 5.7.4 und 5.7.17 fehlschlagen. Sie können dies als Referenz verwenden.

Das Web wartet, bis MySQL gestartet wird, bevor es fortfährt.

Der MySQL-Container kann keine Datenbanklinks akzeptieren, bevor er gestartet wird. Wenn beim Initialisieren des Webs die Datenbank noch nicht gestartet wurde, kann der Web-Container nicht gestartet werden und wird direkt beendet. Wir können beim Starten des Webcontainers ein Erkennungsskript hinzufügen und dann fortfahren, nachdem die Datenbank verbunden ist.

Das Skript lautet wie folgt:

#!/usr/bin/env bash
setze -o errexit
setze -o Pipefail

echo $MYSQL_PASSWORD
echo $MYSQL_DATABASE
echo $MYSQL_HOST
echo $MYSQL_USER
echo $MYSQL_PORT

Funktion mysql_ready(){
Python << ENDE
System importieren
pymysql importieren
versuchen:
  conn = pymysql.connect(Host="db", Port=3306, Benutzer="root", Passwort="$MYSQL_ROOT_PASSWORD", db='$MYSQL_DATABASE', Zeichensatz='utf8')
außer pymysql.err.OperationalError:
  sys.exit(-1)
sys.exit(0)
ENDE
}

bis mysql_ready; tun
 >&2 echo "MySQL ist nicht verfügbar - im Ruhezustand"
 Schlaf 1
Erledigt

>&2 echo "MySQL ist aktiv – Fortsetzung läuft …"

Zusammenfassen

An diesem Punkt ist die Bereitstellung des Django-Technologie-Stack-Dienstes mit Docker abgeschlossen. Den vollständigen Projektcode finden Sie unter docker-django-demo.

Wie am Anfang des Artikels erwähnt, ist diese Bereitstellungsmethode nicht für Online-Produktionsdienste großer Websites geeignet. Sie weist viele Probleme auf, beispielsweise eine hohe Kopplung und schlechte Wartung. Allerdings ist die Bereitstellung eines eigenen Nebenprojekts oder einer eigenen Testumgebung auch dann sehr sinnvoll, wenn die Hardwareressourcen begrenzt sind. Es reduziert nicht nur den Aufwand für die Bereitstellung und Einrichtung der Umgebung, sondern ist auch sehr bequem zu migrieren.

Das Demoprojekt enthält auch einige Beispiele für die Verwendung von Docker in einer Entwicklungsumgebung. Ich persönlich denke jedoch, dass Docker besser für die Bereitstellung geeignet ist und nicht so flexibel und bequem ist, als es direkt in einer Entwicklungsumgebung zu erstellen. Jeder ist herzlich eingeladen, eine Nachricht zu hinterlassen und die Erfahrungen mit der Verwendung von Docker bei Entwicklung und Bereitstellung zu diskutieren.

siehe

Keksausstecher-Django

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.