[PYTHON] Aufbau einer Django-Entwicklungsumgebung mit Docker-Compose + Nginx + uWSGI + MariaDB (macOS Edition)

Docker ist praktisch für die lokale Entwicklungsumgebung

Beim Erstellen der Entwicklungsumgebung von Python + Django können Sie die Version mit pyenv usw. ändern. Dies ist jedoch problematisch, wenn Sie mit einem Team oder auf einem anderen Computer entwickeln. Daher möchte ich Docker verwenden, der eine virtuelle Umgebung erstellt Ich denke.

Docker ist eine Plattform, auf der Middleware und Apps mithilfe der Containertechnologie ausgeführt werden. Es unterscheidet sich ein wenig von virtuellen Maschinen wie VMware. Wie auch immer, es ist praktisch, also sollten Sie es versuchen. Es ist auch möglich, einen Webserver wie WordPress lokal zu erstellen.

Referenz: https://knowledge.sakura.ad.jp/13265/

Außerdem möchte ich PyCharm für die integrierte Entwicklungsumgebung unter macOS verwenden.

Umgebung

Installieren Sie Docker für Mac

Installieren Sie Docker für Mac über Download von der offiziellen Docker-Website.

Sie müssen sich bei Docker anmelden. Erstellen Sie hier ein Konto. https://hub.docker.com/

Wenn Sie Docker für Mac starten, werden Sie nach einer ID und einem Kennwort gefragt. Melden Sie sich daher mit dem zuvor erstellten Konto an.

Um Docker-Befehle verwenden zu können, müssen Sie Docker für Mac starten und sich anmelden.

Referenz: https://docs.docker.com/docker-for-mac/

Erstellen einer Umgebung mit Docker-compose

Docker muss jeden Container wie Nginx, CentOS, MariaDB (MySQL) starten und die Container verbinden. Docker-compose beschreibt diese Konfigurationen und startet mehrere Container gleichzeitig.

Ein Projekt erstellen

Erstellen Sie unter Dokument ein Projektverzeichnis, um ein Projekt zu erstellen.

Erstellen Sie eine Docker-Compose-Konfigurationsdatei

Beschreiben der Konfiguration des Docker-Containers in einer Datei.

docker-compose.yml

version: "3.7"

volumes:
  app.db.volume:

services:
  uwsgi:
    build: ./docker
    container_name: app.uwsgi
    command: uwsgi --socket :8081 --module userapp.wsgi --logto /code/userapp/uwsgi.log --py-autoreload 1
    volumes:
      - ./src:/code
      - ./static:/static
    expose:
      - "8081"
    depends_on:
      - db

  nginx:
    image: nginx:1.16
    container_name: app.nginx
    ports:
      - 8080:80
    volumes:
      - ./nginx/conf.d:/etc/nginx/conf.d
      - ./nginx/uwsgi_params:/etc/nginx/uwsgi_params
      - ./static:/static
    depends_on:
      - uwsgi

  db:
    image: mariadb:10.4
    container_name: app.db
    ports:
      - 3316:3306
    environment:
      MYSQL_ROOT_PASSWORD: dbtest5928
      TZ: 'Asia/Tokyo'
    volumes:
      - app.db.volume:/var/lib/mysql
      - ./sql:/docker-entrypoint-initdb.d

--version: "3.7" : Beschreibende Version von Docker-Compose --volumes: : Speichern Sie den Inhalt der Datenbank.

Erläuterung des uWSGI-Containers

docker-compose.yml

  uwsgi:
    build: ./docker
    container_name: app.uwsgi
    command: uwsgi --socket :8081 --module userapp.wsgi --logto /code/userapp/uwsgi.log --py-autoreload 1
    volumes:
      - ./src:/code
      - ./static:/static
    expose:
      - "8081"
    depends_on:
      - db

--uwsgi: : Führen Sie Python mit uWSGI aus. --Starten Sie Django mit dem Befehl command:.

• Hören Sie auf Port 8081. -- - Modul userapp.wsgi sollte denselben Namen haben wie der von Django generierte Projektname (userapp).
• Protokolldatei einstellen
• Aktivieren Sie das automatische Neuladen

Beschreibung des Nginx-Containers

docker-compose.yml

  nginx:
    image: nginx:1.16
    container_name: app.nginx
    ports:
      - 8080:80
    volumes:
      - ./nginx/conf.d:/etc/nginx/conf.d
      - ./nginx/uwsgi_params:/etc/nginx/uwsgi_params
      - ./static:/static
    depends_on:
      - uwsgi

--ports: : Der Zugriff von außen erfolgt über Port 8080, der Zugriff innerhalb des Containers über Port 80 --volumes: : Erstellen Sie die Nginx-Konfigurationsdatei später in. / nginx / conf.d.

MariaDB Container Beschreibung

docker-compose.yml

  db:
    image: mariadb:10.4
    container_name: app.db
    ports:
      - 3316:3306
    environment:
      MYSQL_ROOT_PASSWORD: dbtest5928
      TZ: 'Asia/Tokyo'
    volumes:
      - app.db.volume:/var/lib/mysql
      - ./sql:/docker-entrypoint-initdb.d

--ports: : Zugriff von außen auf Port 3316, innerhalb des Containers auf Port 3306 --environment: : Legen Sie das Root-Passwort und die Zeitzone fest --volumes: : Das anfängliche SQL für die Datenbankkonstruktion wird später in. / sql erstellt.

Erstellen einer Docker-Datei

Dies ist ein Skript, das beim Erstellen eines Docker-Images gestartet wird.

./docker/Dockerfile

FROM python 3.8
ENV PYTHONUNBUFFERED 1
RUN mkdir /code
WORKDIR /code
ADD requirements.txt /code/
RUN pip install -r requirements.txt
ADD . /code/

--FROM Python 3.8: Startet basierend auf dem Python-Image.

• Ungültigmachung des Ausgabepuffers in der Befehlszeile. Es ist besser, den Puffer für das Debuggen zu deaktivieren, da das Ergebnis aufgrund der Anzeige mit einem Zeitunterschied unbeabsichtigt ist. --WORKDIR / code: Ausführungsverzeichnis --RUN pip install -r Anforderungen.txt: Installieren Sie die erforderlichen Bibliotheken für Docker, indem Sie sie in Anforderungen.txt auflisten.

Erstellen Sie die Anforderungen.txt

Beschreibt die Bibliothek, die zum Ausführen von Python beim Starten von Docker erforderlich ist.

text:./docker/requirements.txt

Django==3.0
uwsgi==2.0.18
PyMySQL==0.9

--Django ist ein Framework --uwsgi ist ein Python-Ausführungsserver im Web --PyMySQL ist eine Bibliothek für die Verbindung von Python zu MySQL (MariaDB).

MariaDB-Anfangsskript

Erstellen Sie einen Benutzer und eine Datenbank für DB-Vorgänge.

sql:./sql/init.sql

CREATE DATABASE IF NOT EXISTS app CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci;
CREATE USER IF NOT EXISTS 'appuser'@'%' IDENTIFIED BY 'apppass';
GRANT ALL PRIVILEGES ON app.* TO 'appuser'@'%';

FLUSH PRIVILEGES;

--Erstellen Sie eine "App" -Datenbank und konfigurieren Sie sie so, dass sie für "Appuser" zugänglich ist.

Nginx uWSGI config

% curl https://raw.githubusercontent.com/nginx/nginx/master/conf/uwsgi_params > ./nginx/uwsgi_params

Sie können die uWSGI-Konfiguration für Nginx von [hier] herunterladen (https://github.com/nginx/nginx/blob/master/conf/uwsgi_params).

./nginx/uwsgi_params

uwsgi_param  QUERY_STRING       $query_string;
uwsgi_param  REQUEST_METHOD     $request_method;
uwsgi_param  CONTENT_TYPE       $content_type;
uwsgi_param  CONTENT_LENGTH     $content_length;

uwsgi_param  REQUEST_URI        $request_uri;
uwsgi_param  PATH_INFO          $document_uri;
uwsgi_param  DOCUMENT_ROOT      $document_root;
uwsgi_param  SERVER_PROTOCOL    $server_protocol;
uwsgi_param  REQUEST_SCHEME     $scheme;
uwsgi_param  HTTPS              $https if_not_empty;

uwsgi_param  REMOTE_ADDR        $remote_addr;
uwsgi_param  REMOTE_PORT        $remote_port;
uwsgi_param  SERVER_PORT        $server_port;
uwsgi_param  SERVER_NAME        $server_name;

Enthält die zum Ausführen von uWSGI erforderlichen Parameter. Bitte benutze es so wie es ist und denke, dass es magisch ist.

Nginx-Konfiguration

conf:nginx/conf.d/app.conf

upstream django {
        server 127.0.0.1:8081;
}       

server {
        listen 80;
        server_name localhost;
        charset utf-8;

        # Static file
        location /static {
                alias /static;
        }

        # Non media 
        location / {
                uwsgi_pass django;
                include /etc/nginx/uwsgi_params;
        }
}

• Da der uWSGI-Port 8081 ist, setzen Sie ihn auf "Upstream Django". --listen 80: Der Zugriff im Container erfolgt über Port 80 --location / static: Bilder, JavaScript und CSS werden in Nginx zurückgegeben. --location / : Alle anderen Zugriffe werden von uWSGI abgewickelt.

Projektstart und erste Erstellung

Erstellen Sie ein Django-Projekt

% docker-compose build

Das von Docker-compose definierte Image wird heruntergeladen und erstellt.

% docker-compose run uwsgi django-admin.py startproject userapp . 

Erstellen Sie das Djanago-Projekt. Vergessen Sie nicht das letzte ".".

% tree
.
├── docker
│   ├── Dockerfile
│   └── requirements.txt
├── docker-compose.yml
├── nginx
│   ├── conf.d
│   │   └── app.conf
│   └── uwsgi_params
├── sql
│   └── init.sql
├── src
│   └── userapp
│       ├── manage.py
│       └── userapp
│           ├── __init__.py
│           ├── asgi.py
│           ├── settings.py
│           ├── urls.py
│           └── wsgi.py
└── static

Das Projektverzeichnis, in dem das Django-Projekt erfolgreich erstellt wurde, sieht folgendermaßen aus.

Führen Sie Django aus

% docker-compose up -d
Starting app.db ... done
Starting app.uwsgi ... done
Starting app.nginx ... done

• Die Option -d wird im Daemon (Hintergrund) ausgeführt.

http://127.0.0.1:8080 Ich werde versuchen, darauf zuzugreifen. Wenn Sie einen solchen Bildschirm sehen, sind Sie erfolgreich.

% docker-compose down
Stopping app.nginx ... done
Stopping app.uwsgi ... done
Stopping app.db    ... done
Removing userapp_uwsgi_run_ec11989e36c3 ... done
Removing app.nginx                      ... done
Removing app.uwsgi                      ... done
Removing app.db                         ... done
Removing network userapp_default

Wenn Sie fertig sind, bringt Sie dieser Befehl zum Absturz.

% docker-compose ps  
Name   Command   State   Ports
------------------------------

Führen Sie den Befehl aus, um den Betriebsstatus von Docker zu hacken. Wenn nichts angezeigt wird, ist down erfolgreich.

Installation der integrierten Entwicklungsumgebung PyCharm

PyCharm von JetBeans ist praktisch für die Entwicklung von Django und Python. Wenn Sie eine Web-App entwickeln, ist die kostenpflichtige Professional-Version hilfreich, mit der auch Javascript, CSS und HTML bearbeitet werden können. Die kostenlose Community-Version ist jedoch zunächst ausreichend.

Laden Sie PyCharm herunter und installieren Sie es

Laden Sie die Software von der offiziellen Website von PyCharm herunter. Offizielle PyCharm-Website

Legen Sie es nach dem Herunterladen in den Anwendungsordner und die Installation ist abgeschlossen.

Projekt laden

Wählen Sie "Datei"> "Öffnen" und wählen Sie den Stammordner für Ihr Projekt.

Verbindung zwischen Dockers Python-Container und PyCharm

Die Professional-Version ist erforderlich, um von PyCharm mit dem Python-Container von Docker ausgeführt zu werden. Wenn Sie vorerst für Light entwickeln, ist es meiner Meinung nach in Ordnung, PyCharm als Editor zu verwenden.

das ist alles.

Referenz: https://nmmmk.hatenablog.com/entry/2018/05/01/101126 https://qiita.com/NickelCreate/items/bed3dc9d088b57127ba7