[PYTHON] Erstellen Sie mit Docker eine Django-Entwicklungsumgebung! (Docker-compose / Django / postgreSQL / nginx)

Ich habe versucht, es wieder aufzubauen! Erstellen Sie die Entwicklungsumgebung von Django mit Docker neu! !! !! !!

Einführung

Teamentwicklung ... Der Aufbau der Umgebung ist sehr mühsam ... In diesem Fall verwenden wir Docker (Sonstiges).

Dieser Artikel ist ein Repost von dem, was ich qrunch gegeben habe

Erstellen wir eine Entwicklungsumgebung für Django / postgreSQL / gunicorn / nginx mit Docker und Docker-compose, die für die Teamentwicklung sehr praktisch sind! !!

Ich verweise auf die folgenden Websites für den Gesamtablauf, aber ich beabsichtige, den Artikel leicht verständlich zu machen, z. B. das Einfügen von Kommentaren in fast alle Zeilen der Einstellungsdatei usw.! Dockerizing Django with Postgres, Gunicorn, and Nginx

Es war ein langer Artikel, also gehe ich weiter!

Was ist in diesem Artikel zu tun?

--Installation von Docker und Docker-Compose

• Installieren von pipenv und Erstellen einer virtuellen Umgebung --Erstellen eines Docker-Containers
• Django
• postgres
• gunicorn
• nginx Umgang mit statischen Dateien

Installieren Sie Docker und Docker-compose

Wie Sie alle wissen, kann Docker ausgeführt werden, indem Sie virtuell ein anderes Betriebssystem in Ihren PC einbauen (was nur leicht gesagt werden kann), und Sie können die gesamte Umgebung auf andere Personen kopieren. Es ist ein Werkzeug, an das weitergegeben werden kann!

Einzelheiten finden Sie auf den folgenden Seiten! Einführung in Docker (1.) - Was ist Docker und was ist gut -

Installieren Sie Docker trotzdem!

docker

Installation von https://docs.docker.com/docker-for-mac/install/

docker-compose

$ curl -L https://github.com/docker/compose/releases/download/1.24.0/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose

$ chmod +x /usr/local/bin/docker-compose

Version prüfen

Die Installation ist abgeschlossen, wenn die Version mit dem folgenden Befehl angezeigt wird!

$ docker --version
Docker version 18.09.2

$ docker-compose --version
docker-compose version 1.23.2

Erstellen Sie ein Verzeichnis für Django

Als Nächstes erstellen wir ein Verzeichnis zum Erstellen eines Django-Projekts

<!--Erstellen Sie ein Verzeichnis für das Projekt (App-Verzeichnis ist das Stammverzeichnis des Django-Projekts)-->
$ mkdir docker-demo-with-django && cd docker-demo-with-django
$ mkdir app && cd app

Erstellen einer Umgebung auf der Hostseite mit pipenv

pipenv ist ein virtuelles Umgebungskonstruktionswerkzeug von Python, das mit kürzlich entwickelten venv und venv-virtuarenv usw. verglichen wird.

Es hat eine Funktion wie eine Kombination aus pip und virtuarenv und ist eine hervorragende Funktion, die die virtuelle Umgebung und die Paketversion mit zwei Dateitypen verwalten kann: "pipfile" und "Pipfile.lock".

Wenn Sie eine Django-Umgebung mit Docker erstellen, können Sie eine ähnliche Python-Entwicklungsumgebung erstellen, indem Sie einfach die beiden oben genannten Dateien kopieren und pipenv ausführen. Verwenden Sie diese Option

Stellen Sie sicher, dass Sie eine Pipfile in "Docker-Demo-mit-Django / App /" haben, und geben Sie "Django =" == 2.2.3 "" in das Feld "Pakete" ein.

docker-demo-with-django/app/Pipfile

[[source]]
name = "pypi"
url = "https://pypi.org/simple"
verify_ssl = true

[dev-packages]

[packages]
Django = "==2.2.3"

[requires]
python_version = "3.7"

Geben Sie nach dem Erstellen von pipfile den folgenden Befehl in dasselbe Verzeichnis y ein

<!--Installation des Rohrleitungskörpers-->
:app$ pip install pipenv

<!--Erstellen Sie eine virtuelle Umgebung aus Pipfile-->
:app$ pipenv install

<!--Betreten Sie die virtuelle Umgebung-->
:app$ pipenv shell

<!--Start des Django-Projekts-->
(app) :app$ django-admin.py startproject django_demo .

<!--Wenden Sie Modellinhalte auf die Datenbank an-->
(app) :app$ python manage.py migrate

<!--Starten Sie den Entwicklungsserver-->
(app) :app$ python manage.py runserver

Versuchen Sie, auf [http: // localhost: 8000 /](http: // localhost: 8000 /) zuzugreifen. Sie sollten den Django-Begrüßungsbildschirm sehen

Aktuelle Verzeichnisstruktur

:docker-demo-with-django$ tree
.
└── app
    ├── Pipfile
    ├── Pipfile.lock
    ├── db.sqlite3
    ├── django_demo
    │ ├── __init__.py
    │ ├── settings.py
    │ ├── urls.py
    │ └── wsgi.py
    └── manage.py

Erstellen Sie einen Docker-Container

Django

Fügen Sie dem App-Verzeichnis die folgende Docker-Datei hinzu Da der Zweck dieser Zeit darin besteht, eine Mindestumgebung zu schaffen, verwenden alle vom Beamten installierten Docker-Images das leichte "alpine Linux" Dies ermöglicht es, eine Umgebung mit einer Kapazität von etwa 1/10 im Vergleich zu Bildern wie Ubuntu zu erstellen.

docker-demo-with-django/app/Dockerfile

#Python3 vom Beamten.7 auf alpine pull linux image
FROM python:3.7-alpine

#Arbeitsverzeichnis einstellen
WORKDIR /usr/src/app

#Umgebungsvariablen festlegen
#Verhindern Sie, dass Python in Pyc-Dateien und -Discs schreibt
ENV PYTHONDONTWRITEBYTECODE 1
#Verhindern Sie, dass Python Standard-E / A puffert
ENV PYTHONUNBUFFERED 1

#Installieren Sie Pipenv
RUN pip install --upgrade pip \
&& pip install pipenv

#Kopieren Sie die Host-Pipfile in das Arbeitsverzeichnis des Containers
COPY ./Pipfile /usr/src/app/Pipfile

#Erstellen Sie eine Django-Umgebung, indem Sie Pakete aus der Pipfile installieren
RUN pipenv install --skip-lock --system --dev

#Kopieren Sie das aktuelle Verzeichnis des Hosts (derzeit das App-Verzeichnis) in Ihr Arbeitsverzeichnis
COPY . /usr/src/app/

Fügen Sie dann docker-compose.yml zum Stammverzeichnis des Projekts hinzu ( docker-demo-with-django)

version: '3.7'

services:
    #Der Dienstname kann frei eingestellt werden
    django:
        #Aus dem App-Verzeichnis`Dockerfile`Finden
        build: ./app
        #Stellen Sie den Befehl ein, der nach dem Starten des Dienstes eingegeben werden soll
        command: python manage.py runserver 0.0.0.0:8000
        #Einstellungen für persistente Daten.`host:container`Beschreiben Sie den Pfad mit
        volumes:
            - ./app/:/usr/src/app/
        #Geben Sie den zu öffnenden Port an.`host:container`Listen Sie den Port in
        ports:
            - 8000:8000
        #Geben Sie die Umgebungsvariable an
        environment:
            #1 ist der Zurück-Modus
            - DEBUG=1
　　　　# setting.SECRET in py aufgeführt_Füllen Sie den SCHLÜSSEL aus
            - SECRET_KEY=hoge

Ändern Sie settings.py im Django-Projekt. Es gibt 3 Korrekturelemente: "SECRET_KEY", "DEBUG" und "ALLOWED_HOSTS".

#SECRET aus Umgebungsvariablen_Einstellung, um KEY zu bekommen
SECRET_KEY = os.environ.get('SECRET_KEY')

#Holen Sie sich DEBUG aus Umgebungsvariablen. Der Standardwert ist True (Produktionsmodus).
DEBUG = int(os.environ.get('DEBUG', default=0))

#Listen Sie die zulässigen Hosts auf
ALLOWED_HOSTS = ['localhost', '127.0.0.1']

Verwenden Sie nach der Änderung den Befehl docker-compose up -d --build, um gleichzeitig zu erstellen und zu starten.

Die Option -d bedeutet, im Hintergrund zu beginnen

Wenn Sie eine Verbindung zu [http: // localhost: 8000 /](http: // localhost: 8000 /) herstellen und der Begrüßungsbildschirm angezeigt wird, sind Sie erfolgreich.

Postgres

Um psotgres hinzuzufügen, fügen Sie einen neuen Dienst zu "docker-compose.yml" hinzu Gleichzeitig müssen Sie die Datenbank für den Django-Dienst konfigurieren

version: '3.7'

services:
    #Der Dienstname kann frei eingestellt werden
    django:
        #Aus dem App-Verzeichnis`Dockerfile`Finden
        build: ./app
        #Stellen Sie den Befehl ein, der nach dem Starten des Dienstes eingegeben werden soll
        command: python manage.py runserver 0.0.0.0:8000
        #Einstellungen für persistente Daten.`host:container`Beschreiben Sie den Pfad mit
        volumes:
            - ./app/:/usr/src/app/
        #Geben Sie den zu öffnenden Port an.`host:container`Listen Sie den Port in
        ports:
            - 8000:8000
        #Geben Sie die Umgebungsvariable an
        environment:
            #1 ist der Zurück-Modus
            - DEBUG=1
            - SECRET_KEY=hoge
            - DATABASE_ENGINE=django.db.backends.postgresql
            - DATABASE_DB=django_db
            - DATABASE_USER=django_db_user
            - DATABASE_PASSWORD=password1234
            - DATABASE_HOST=postgres
            - DATABASE_PORT=5432
        #Geben Sie den zu verbindenden Dienst an
        depends_on:
            - postgres

    postgres:
        #Ziehen Sie das Bild vom Beamten
        image: postgres:11.4-alpine
        #Datenbankpersistenz
        #Zu Beginn, um nicht im Host-Verzeichnis zu mounten`./`Nicht anhängen
        volumes:
            - postgres_data:/var/lib/postgresql/data
        #Erstellen Sie eine Datenbank mit su-Berechtigungen und demselben Namen wie der angegebene Benutzer
        #Geben Sie den Wert auf die gleiche Weise ein, wie im Django-Dienst angegeben
        environment:
            - POSTGRES_USER=django_db_user
            - POSTGRES_PASSWORD=password1234
            - POSTGRES_DB=django_db

#Auf der obersten Ebene geschriebene "benannte Volumes" können von mehreren Diensten aus referenziert werden
volumes:
    postgres_data:

Schreiben Sie als Nächstes das Element "DATENBANKEN" in settings.py neu.

DATABASES = {
    'default': {
        'ENGINE': os.environ.get('DATABASE_ENGINE', 'django.db.backends.sqlite3'),
        'NAME': os.environ.get('DATABASE_DB', os.path.join(BASE_DIR, 'db.sqlite3')),
        'USER': os.environ.get('DATABASE_USER', 'user'),
        'PASSWORD': os.environ.get('DATABASE_PASSWORD', 'password'),
        'HOST': os.environ.get('DATABASE_HOST', 'localhost'),
        'PORT': os.environ.get('DATABASE_PORT', '5432'),
    }
}

Sie müssen einen Treiber verwenden, um eine Verbindung zu Postgres von Django herzustellen Dieses Mal ändern wir "Docker-Demo-mit-Django / App / Dockerfile", um den wichtigsten Treiber, "Psycopg2", zu nutzen. Das Dockerfile sieht so aus Lassen Sie uns psycopg2 von pip installieren, nachdem wir die Abhängigkeiten mit apk installiert haben, dem Paketmanager von alpine Linux

#Python3 vom Beamten.7 auf alpine pull linux image
FROM python:3.7-alpine

#Arbeitsverzeichnis einstellen
WORKDIR /usr/src/app

#Umgebungsvariablen festlegen
#Verhindern Sie, dass Python in Pyc-Dateien und -Discs schreibt
ENV PYTHONDONTWRITEBYTECODE 1
#Verhindern Sie, dass Python Standard-E / A puffert
ENV PYTHONUNBUFFERED 1

#Installation von psycopg2
RUN apk update \
    && apk add --virtual build-deps gcc python3-dev musl-dev \
    && apk add postgresql-dev \
    && pip install psycopg2 \
    && apk del build-deps

#Installieren Sie Pipenv
RUN pip install --upgrade pip \
&& pip install pipenv

#Kopieren Sie die Host-Pipfile in das Arbeitsverzeichnis des Containers
COPY ./Pipfile /usr/src/app/Pipfile

#Erstellen Sie eine Django-Umgebung, indem Sie Pakete aus der Pipfile installieren
RUN pipenv install --skip-lock --system --dev

#Kopieren Sie das aktuelle Verzeichnis des Hosts (derzeit das App-Verzeichnis) in Ihr Arbeitsverzeichnis
COPY . /usr/src/app/

Stoppen Sie die Container, die zuvor mit docker-compose down -v gestartet wurden, und geben Sie dann docker-compose up -d --build erneut ein, um die Container neu zu starten. Die Option -v repräsentiert das Löschen des Volumes

<!--Behälter stoppen-->
$ docker-compose down -v

<!--Container starten-->
$ docker-compose up -d --build

<!--Migration-->
<!-- $ docker-compose exec <service_name> python manage.py migrate --noinput -->
$ docker-compose exec django python manage.py migrate --noinput

In seltenen Fällen stellen Django und Postgres keine Verbindung her und der Postgres-Container stoppt, nachdem er mehrmals dasselbe getan hat. In diesem Fall überprüfen wir das Protokoll Wahrscheinlich existiert postgres_1 | initdb: Verzeichnis" / var / lib / postgresql / data ", ist aber nicht leer
Sie können die Beschreibung wie folgt sehen, also lassen Sie uns "Docker-Demo-mit-Django / Postgres_Data" auf der Host-Seite löschen.

Verwenden Sie den Befehl docker-compose ps, um zu überprüfen, ob beide Container ausgeführt werden (Status ist aktiv), wie unten gezeigt.

$ docker-compose ps
               Name                             Command               State           Ports         
----------------------------------------------------------------------------------------------------
docker-demo-with-django_django_1     python manage.py runserver ...   Up      0.0.0.0:8000->8000/tcp
docker-demo-with-django_postgres_1   docker-entrypoint.sh postgres    Up      5432/tcp 

Stellen Sie als Nächstes sicher, dass die angegebene Datenbank für die Datenbank erstellt wurde.

$docker-compose exec postgres psql --username=django_db_user --dbname=django_db
psql (11.4)
Type "help" for help.

django_db=# \l
                                          List of databases
   Name    |     Owner      | Encoding |  Collate   |   Ctype    |         Access privileges         
-----------+----------------+----------+------------+------------+-----------------------------------
 django_db | django_db_user | UTF8     | en_US.utf8 | en_US.utf8 | 
 postgres  | django_db_user | UTF8     | en_US.utf8 | en_US.utf8 | 
 template0 | django_db_user | UTF8     | en_US.utf8 | en_US.utf8 | =c/django_db_user                +
           |                |          |            |            | django_db_user=CTc/django_db_user
 template1 | django_db_user | UTF8     | en_US.utf8 | en_US.utf8 | =c/django_db_user                +
           |                |          |            |            | django_db_user=CTc/django_db_user
(4 rows)

django_db=# \dt
                      List of relations
 Schema |            Name            | Type  |     Owner      
--------+----------------------------+-------+----------------
 public | auth_group                 | table | django_db_user
 public | auth_group_permissions     | table | django_db_user
 public | auth_permission            | table | django_db_user
 public | auth_user                  | table | django_db_user
 public | auth_user_groups           | table | django_db_user
 public | auth_user_user_permissions | table | django_db_user
 public | django_admin_log           | table | django_db_user
 public | django_content_type        | table | django_db_user
 public | django_migrations          | table | django_db_user
 public | django_session             | table | django_db_user
(10 rows)

django_db=# \q

Nach der Bestätigung fügen Sie "entrypoint.sh" für die automatische Migration zum App-Verzeichnis hinzu, nachdem Sie die Verbindung zu postgres bestätigt haben.

#!/bin/sh

if [ "$DATABASE" = "postgres" ]
then
    echo "Waiting for postgres..."

    while ! nc -z $DATABASE_HOST $DATABASE_PORT; do
      sleep 0.1
    done

    echo "PostgreSQL started"
fi

python manage.py flush --no-input
python manage.py migrate

exec "$@"

Erteilen Sie nach dem Hinzufügen die Ausführungsberechtigung mit dem Befehl chmod + x app / entrypoint.sh. Ändern Sie abschließend die Docker-Datei, um entrypoint.sh auszuführen, und fügen Sie die Umgebungsvariable $ DATABASE hinzu

#Python3 vom Beamten.7 auf alpine pull linux image
FROM python:3.7-alpine

#Arbeitsverzeichnis einstellen
WORKDIR /usr/src/app

#Umgebungsvariablen festlegen
#Verhindern Sie, dass Python in Pyc-Dateien und -Discs schreibt
ENV PYTHONDONTWRITEBYTECODE 1
#Verhindern Sie, dass Python Standard-E / A puffert
ENV PYTHONUNBUFFERED 1

#Installation von psycopg2
RUN apk update \
    && apk add --virtual build-deps gcc python3-dev musl-dev \
    && apk add postgresql-dev \
    && pip install psycopg2 \
    && apk del build-deps

#Installieren Sie Pipenv
RUN pip install --upgrade pip \
&& pip install pipenv

#Kopieren Sie die Host-Pipfile in das Arbeitsverzeichnis des Containers
COPY ./Pipfile /usr/src/app/Pipfile

#Erstellen Sie eine Django-Umgebung, indem Sie Pakete aus der Pipfile installieren
RUN pipenv install --skip-lock --system --dev

# entrypoint.kopieren sh
COPY ./entrypoint.sh /usr/src/app/entrypoint.sh

#Kopieren Sie das aktuelle Verzeichnis des Hosts (derzeit das App-Verzeichnis) in Ihr Arbeitsverzeichnis
COPY . /usr/src/app/

# entrypoint.lauf sh
ENTRYPOINT ["/usr/src/app/entrypoint.sh"]

Warten Sie eine Weile und wenn Sie nach Abschluss des Startvorgangs eine Verbindung zu [http: // localhost: 8000 /](http: // localhost: 8000 /) herstellen können, sind Sie fertig.

Die persönliche Entwicklungsumgebung ist vorerst bereit Für eine Produktionsumgebung müssen Sie die Umgebungsvariablen jedoch privat halten. Sie müssen den Server auch aufgrund mangelnder Funktionalität oder Sicherheitsprobleme mit "python manage.py runserver" auf andere Weise starten. Installieren Sie zu diesem Zweck "gunicorn" (WSGI-Server), die Schnittstelle zwischen der Anwendung und dem Webserver, setzen Sie "env_file" und setzen Sie "nginx", das als Reverse-Proxy von "gunicorn" fungiert, um statische Dateien zu verarbeiten. Muss tun Als nächstes werden wir sie machen

Installieren Sie Gunicorn und erstellen Sie eine Produktionskonfigurationsdatei

Fügen wir Gunforn zu Pipfile hinzu

[[source]]

url = "https://pypi.python.org/simple"
verify_ssl = true
name = "pypi"


[packages]

django = "==2.2"
gunicorn= "==19.9.0"


[dev-packages]



[requires]

python_version = "3.7"

Fügen Sie außerdem "docker-compose.prod.yml" zum selben Verzeichnis wie "docker-compose.yml" hinzu und beschreiben Sie die Einstellungen für die Produktionsumgebung.

version: '3.7'

services:
    #Der Dienstname kann frei eingestellt werden
    django:
        #Aus dem App-Verzeichnis`Dockerfile`Finden
        build: ./app
        #Stellen Sie den Befehl ein, der nach dem Starten des Dienstes eingegeben werden soll
        command: gunicorn django_demo.wsgi:application --bind 0.0.0.0:8000
        #Einstellungen für persistente Daten.`host:container`Beschreiben Sie den Pfad mit
        volumes:
            - ./app/:/usr/src/app/
        #Geben Sie den zu öffnenden Port an.`host:container`Listen Sie den Port in
        ports:
            - 8000:8000
        #Geben Sie die Umgebungsvariable an
        env_file: .env
        #Geben Sie den zu verbindenden Dienst an
        depends_on:
            - postgres

    postgres:
        #Ziehen Sie das Bild vom Beamten
        image: postgres:11.4-alpine
        #Datenbankpersistenz
        volumes:
            - postgres_data:/var/lib/postgresql/data
        env_file: .env.db

#Auf der obersten Ebene geschriebene "benannte Volumes" können von mehreren Diensten aus referenziert werden
volumes:
  postgres_data:

Im Vergleich zu den Einstellungen der Entwicklungsumgebung wurde "Umgebung:" in "env_file:" geändert. Dadurch entfällt die Notwendigkeit, Produktionseinstellungen direkt in yml zu schreiben. Durch Angabe des Befehls zum Starten von "gunicorn" im Befehl "des Django-Dienstes" wird "gunicorn" anstelle von "runserver" gestartet.

Platzieren Sie "env_file" im selben Verzeichnis wie "docker-compose.prod.yml" und schreiben Sie wie folgt Vergessen Sie zu diesem Zeitpunkt nicht, "DEBAG = 0" in ".env" zu setzen (deaktivieren Sie den Debug-Modus mit "DEBAG = 0").

/docker-demo-with-django/.env

DEBUG=0
SECRET_KEY=hoge
DATABASE_ENGINE=django.db.backends.postgresql
DATABASE_DB=django_db
DATABASE_USER=django_db_user
DATABASE_PASSWORD=password1234
DATABASE_HOST=postgres
DATABASE_PORT=5432
DATABASE=postgres

/docker-demo-with-django/.env.db

POSTGRES_USER=django_db_user
POSTGRES_PASSWORD=password1234
POSTGRES_DB=django_db

Darüber hinaus wird in dieser Phase die Migration jedes Mal ausgeführt, wenn der Container gestartet wird. Erstellen wir also "entrypoint.prod.sh" auch für die Produktionsumgebung.

/docker-demo-with-django/app/entrypoint.prod.sh

#!/bin/sh

if [ "$DATABASE" = "postgres" ]
then
    echo "Waiting for postgres..."

    while ! nc -z $DATABASE_HOST $DATABASE_PORT; do
      sleep 0.1
    done

    echo "PostgreSQL started"
fi

exec "$@"

Dockerfile wird auch für die Produktion erstellt

/docker-demo-with-django/app/Dockerfile.prod

#Python3 vom Beamten.7 auf alpine pull linux image
FROM python:3.7-alpine

#Arbeitsverzeichnis einstellen
WORKDIR /usr/src/app

#Umgebungsvariablen festlegen
#Verhindern Sie, dass Python in Pyc-Dateien und -Discs schreibt
ENV PYTHONDONTWRITEBYTECODE 1
#Verhindern Sie, dass Python Standard-E / A puffert
ENV PYTHONUNBUFFERED 1

#Installation von psycopg2
RUN apk update \
    && apk add --virtual build-deps gcc python3-dev musl-dev \
    && apk add postgresql-dev \
    && pip install psycopg2 \
    && apk del build-deps

#Installieren Sie Pipenv
RUN pip install --upgrade pip \
&& pip install pipenv

#Kopieren Sie die Host-Pipfile in das Arbeitsverzeichnis des Containers
COPY ./Pipfile /usr/src/app/Pipfile

#Erstellen Sie eine Django-Umgebung, indem Sie Pakete aus der Pipfile installieren
RUN pipenv install --skip-lock --system --dev

# entrypoint.kopieren sh
COPY ./entrypoint.prod.sh /usr/src/app/entrypoint.prod.sh

#Kopieren Sie das aktuelle Verzeichnis des Hosts (derzeit das App-Verzeichnis) in Ihr Arbeitsverzeichnis
COPY . /usr/src/app/

# entrypoint.lauf sh
ENTRYPOINT ["/usr/src/app/entrypoint.prod.sh"]

Schreiben Sie natürlich "docker-compose.prod.yml" neu, um auch die Produktionsdatei zu lesen.

version: '3.7'

services:
    #Der Dienstname kann frei eingestellt werden
    django:
        build:
            #Der zu lesende Dateiname lautet`Dockerfile`Wenn nicht, geben Sie den relativen Pfad im Kontext und den Dateinamen in der Docker-Datei ein
            context: ./app
            dockerfile: Dockerfile.prod
        #Stellen Sie den Befehl ein, der nach dem Starten des Dienstes eingegeben werden soll
        command: gunicorn django_demo.wsgi:application --bind 0.0.0.0:8000
        #Einstellungen für persistente Daten.`host:container`Beschreiben Sie den Pfad mit
        volumes:
            - ./app/:/usr/src/app/
        #Geben Sie den zu öffnenden Port an.`host:container`Listen Sie den Port in
        ports:
            - 8000:8000
        #Geben Sie die Umgebungsvariable an
        env_file: .env
        #Geben Sie den zu verbindenden Dienst an
        depends_on:
            - postgres

    postgres:
        #Ziehen Sie das Bild vom Beamten
        image: postgres:11.4-alpine
        #Datenbankpersistenz
        volumes:
            - postgres_data:/var/lib/postgresql/data
        env_file: .env.db

#Auf der obersten Ebene geschriebene "benannte Volumes" können von mehreren Diensten aus referenziert werden
volumes:
    postgres_data:

Lassen Sie uns den Container nach dem Einstellen erneut starten

$ docker-compose down -v

<!-- -Docker mit Option f-compose.prod.Geben Sie yml an-->
$ docker-compose -f docker-compose.prod.yml up -d --build

<!-- entrypoint.prod.Da sh nicht migriert, führen Sie es manuell aus-->
$ docker-compose -f docker-compose.prod.yml exec django python manage.py migrate --noinput

Lassen Sie uns nach dem Start auf [http: // localhost: 8000 / admin](http: // localhost: 8000 / admin) zugreifen. Sie sollten verbunden sein und den Anmeldebildschirm für die Verwaltung von Django sehen, aber Sie sollten keine statischen Dateien (CSS usw.) sehen. Dies liegt daran, dass ich den Debug-Modus deaktiviert habe, damit statische Dateien nicht mehr geladen werden Gunicorn wurde ebenfalls wie festgelegt gestartet, unterstützt jedoch nicht die statische Dateiverteilung von Gunicorn und stellt nur eine Anwendung bereit (in diesem Fall Django). Wenn Sie also die beiden oben genannten Einstellungen nicht ändern, wird die statische Datei verwendet Kann nicht geliefert werden Verwenden Sie insbesondere "python manage.py collectstatic", um statische Dateien an einem Ort zu sammeln und zu lesen, und verwenden Sie einen Webserver wie nginx als Reverse-Proxy für Gunicorn.

Fügen wir zuerst Nginx zum Service hinzu

Nginx hinzufügen

Erstellen Sie ein Nginx-Verzeichnis im Stammverzeichnis Ihres Projekts (/ docker-demo-with-django /) und fügen Sie Dockerfile und nginx.conf hinzu.

/docker-demo-with-django/nginx/Dockerfile

FROM nginx:1.15.12-alpine

#Löschen Sie die Standardeinstellung conf und fügen Sie eine weitere Einstellung hinzu
RUN rm /etc/nginx/conf.d/default.conf
COPY nginx.conf /etc/nginx/conf.d

/docker-demo-with-django/nginx/nginx.conf

upstream config {
    #Wenn Sie den Dienstnamen des Containers angeben, wird der Name aufgelöst
    server django:8000;
}

server {
    #Halten Sie sich an Port 80 bereit
    listen 80;

    location / {
        proxy_pass http://config;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header Host $host;
        proxy_redirect off;
    }

}

Fügen Sie dann nginx zu "docker-compose.prod.yml" hinzu

version: '3.7'

services:
    #Der Dienstname kann frei eingestellt werden
    django:
        build:
            #Der zu lesende Dateiname lautet`Dockerfile`Wenn nicht, geben Sie den relativen Pfad im Kontext und den Dateinamen in der Docker-Datei ein
            context: ./app
            dockerfile: Dockerfile.prod
        #Stellen Sie den Befehl ein, der nach dem Starten des Dienstes eingegeben werden soll
        command: gunicorn django_demo.wsgi:application --bind 0.0.0.0:8000
        #Einstellungen für persistente Daten.`host:container`Beschreiben Sie den Pfad mit
        volumes:
            - ./app/:/usr/src/app/
        #Auf den angegebenen Port kann über den verbundenen Dienst zugegriffen werden
        expose:
            - 8000
        #Geben Sie die Umgebungsvariable an
        env_file: .env
        #Geben Sie den zu verbindenden Dienst an
        depends_on:
            - postgres

    postgres:
        #Ziehen Sie das Bild vom Beamten
        image: postgres:11.4-alpine
        #Datenbankpersistenz
        volumes:
            - postgres_data:/var/lib/postgresql/data
        env_file: .env.db

    nginx:
        build: ./nginx
        ports:
            - 1337:80
        depends_on:
            - django

#Auf der obersten Ebene geschriebene "benannte Volumes" können von mehreren Diensten aus referenziert werden
volumes:
    postgres_data:

Ändern Sie "ports:" in "expose:", da Sie den Django-Dienst nicht mehr direkt vom Host-Betriebssystem anfordern Der hier angegebene Port ist nicht für das Host-Betriebssystem verfügbar, es ist jedoch möglich, eine Verbindung über den verknüpften Dienst herzustellen.

Starten Sie den Dienst wie zuvor neu

$ docker-compose -f docker-compose.prod.yml down -v
$ docker-compose -f docker-compose.prod.yml up -d --build
$ docker-compose -f docker-compose.prod.yml exec djnago python manage.py migrate --noinput

Stellen Sie eine Verbindung zu [http: // localhost: 1337 / admin /](http: // localhost: 1337 / admin /) her. Sie sollten den Admin-Bildschirm sehen

Damit ist die Verbindung mit nginx abgeschlossen. Die Verzeichnisstruktur in dieser Phase ist wie folgt

$tree
.
├── app
│ ├── Dockerfile
│ ├── Dockerfile.prod
│ ├── Pipfile
│ ├── Pipfile.lock
│ ├── django_demo
│ │ ├── __init__.py
│ │ ├── settings.py
│ │ ├── urls.py
│ │ └── wsgi.py
│ ├── entrypoint.prod.sh
│ ├── entrypoint.sh
│ └── manage.py
├── docker-compose.prod.yml
├── docker-compose.yml
└── nginx
    ├── Dockerfile
    └── nginx.conf

Umgang mit statischen Dateien

Als nächstes wird die Einstellung zum Verarbeiten statischer Dateien festgelegt. Ändern Sie das Ende von "settings.py" des Django-Projekts und fügen Sie es zu "entrypoint.sh" hinzu

/docker-demo-with-django/app/django_demo/settings.py

STATIC_URL = '/staticfiles/'
STATIC_ROOT = os.path.join(BASE_DIR, 'staticfiles')

/docker-demo-with-django/app/entrypoint.sh

#!/bin/sh

if [ "$DATABASE" = "postgres" ]
then
    echo "Waiting for postgres..."

    while ! nc -z $DATABASE_HOST $DATABASE_PORT; do
      sleep 0.1
    done

    echo "PostgreSQL started"
fi

python manage.py flush --no-input
python manage.py migrate
python manage.py collectstatic --no-input --clear

exec "$@"

Jetzt sammelt python manage.py collectstatic die statischen Dateien in dem von STATIC_ROOT angegebenen Pfad und liefert auch die statischen Dateien, die dort im Verzeichnis staticfiles vorhanden sind.

Stellen Sie als Nächstes dasselbe Volume für django und nginx in docker-compose.prod.yml ein, verbinden Sie das django-Projekt mit dem nginx-Container und leiten Sie statische Dateianforderungen an das Verzeichnis staticfiles weiter. Lass uns setzen

/docker-demo-with-django/docker-compose.prod.yml

version: '3.7'

services:
    #Der Dienstname kann frei eingestellt werden
    django:
        build:
            #Der zu lesende Dateiname lautet`Dockerfile`Wenn nicht, geben Sie den relativen Pfad im Kontext und den Dateinamen in der Docker-Datei ein
            context: ./app
            dockerfile: Dockerfile.prod
        #Stellen Sie den Befehl ein, der nach dem Starten des Dienstes eingegeben werden soll
        command: gunicorn django_demo.wsgi:application --bind 0.0.0.0:8000
        #Einstellungen für persistente Daten.`host:container`Beschreiben Sie den Pfad mit
        volumes:
            - static_volume:/usr/src/app/staticfiles
        #Auf den angegebenen Port kann über den verbundenen Dienst zugegriffen werden
        expose:
            - 8000
        #Geben Sie die Umgebungsvariable an
        env_file: .env
        #Geben Sie den zu verbindenden Dienst an
        depends_on:
            - postgres

    postgres:
        #Ziehen Sie das Bild vom Beamten
        image: postgres:11.4-alpine
        #Datenbankpersistenz
        volumes:
            - postgres_data:/var/lib/postgresql/data
        env_file: .env.db

    nginx:
        build: ./nginx
        volumes:
            - static_volume:/usr/src/app/staticfiles
        ports:
            - 1337:80
        depends_on:
            - django

#Auf der obersten Ebene geschriebene "benannte Volumes" können von mehreren Diensten aus referenziert werden
volumes:
    postgres_data:
    static_volume:

/docker-demo-with-django/nginx/nginx.conf

upstream config {
    #Wenn Sie den Dienstnamen des Containers angeben, wird der Name aufgelöst
    server django:8000;
}

server {
    #Halten Sie sich an Port 80 bereit
    listen 80;

    location / {
        proxy_pass http://config;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header Host $host;
        proxy_redirect off;
    }

    #Leiten Sie statische Dateianforderungen an statische Dateien weiter
    location /staticfiles/ {
        alias /usr/src/app/staticfiles/;
    }

}

Damit sind alle Einstellungen abgeschlossen! Starten wir den Container erneut!

$ docker-compose -f docker-compose.prod.yml down -v
$ docker-compose -f docker-compose.prod.yml up -d --build
$ docker-compose -f docker-compose.prod.yml exec django python manage.py migrate --noinput
$ docker-compose -f docker-compose.prod.yml exec django python manage.py collectstatic --no-input --clear

Versuchen Sie nach Bestätigung des Startvorgangs, eine Verbindung zu [http: // localhost: 1337 / admin](http: // localhost: 1337 / admin) herzustellen. CSS sollte auf dem Verwaltungsbildschirm eingestellt werden! Dann ändern Sie das Django-Projekt nach Ihren Wünschen!

Danke für deine harte Arbeit! !!