[PYTHON] Créez un environnement de développement Django avec Docker! (Docker-compose / Django / postgreSQL / nginx)

J'ai essayé de le reconstruire! Reconstruisez l'environnement de développement de Django avec Docker! !! !! !!

introduction

Développement d'équipe ... La construction de l'environnement est vraiment gênante ... Dans ce cas, utilisons Docker (divers)

Cet article est un repost de ce que j'ai donné à qrunch

Construisons un environnement de développement pour Django / postgreSQL / gunicorn / nginx en utilisant Docker et Docker-compose, qui sont très pratiques pour le développement en équipe! !!

Je me réfère aux sites suivants pour le flux global, mais j'ai l'intention de rendre l'article facile à comprendre, comme l'insertion de commentaires dans presque toutes les lignes du fichier de paramètres, etc.! Dockerizing Django with Postgres, Gunicorn, and Nginx

Ça a été un long article, alors je vais passer à autre chose!

Que faire dans cet article

--Installation de Docker et Docker-compose --Installation de pipenv et création d'un environnement virtuel --Construire un conteneur Docker

• Django
• postgres
• gunicorn
• nginx Gestion des fichiers statiques

Installez Docker et Docker-compose

Comme vous le savez tous, Docker peut être exécuté en insérant virtuellement un autre système d'exploitation dans votre PC (ce qui ne peut être dit facilement), et vous pouvez copier tout l'environnement à d'autres personnes. C'est un outil auquel on peut passer!

Pour plus de détails, veuillez vous référer aux pages suivantes! Introduction à Docker (1er) -Qu'est-ce que Docker et ce qui est bon-

Installez quand même Docker!

docker

Installer depuis 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

Vérifier la version

L'installation est terminée lorsque la version est affichée avec la commande suivante!

$ docker --version
Docker version 18.09.2

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

Créer un répertoire pour Django

Ensuite, créons un répertoire pour créer un projet Django

<!--Créez un répertoire pour le projet (le répertoire de l'application est le répertoire racine du projet django)-->
$ mkdir docker-demo-with-django && cd docker-demo-with-django
$ mkdir app && cd app

Créer un environnement côté hôte avec pipenv

pipenv est un outil de construction d'environnement virtuel de python qui est comparé à venv et venv-virtuarenv récemment développés, etc.

Il a une fonction comme une combinaison de pip et virtuarenv, et c'est un excellent qui peut gérer l'environnement virtuel et la version du package avec deux types de fichiers, pipfile et Pipfile.lock.

Lors de la construction d'un environnement Django avec Docker, vous pouvez créer un environnement de développement Python similaire simplement en copiant les deux fichiers ci-dessus et en exécutant pipenv, alors utilisons ceci

Assurez-vous d'avoir un Pipfile dans docker-demo-with-django / app / et mettez Django =" == 2.2.3 " dans le champ packages.

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"

Après avoir créé pipfile, entrez la commande suivante dans le même répertoire y

<!--Installation du corps pipenv-->
:app$ pip install pipenv

<!--Créer un environnement virtuel à partir de Pipfile-->
:app$ pipenv install

<!--Entrez dans l'environnement virtuel-->
:app$ pipenv shell

<!--Début du projet Django-->
(app) :app$ django-admin.py startproject django_demo .

<!--Appliquer le contenu du modèle à la base de données-->
(app) :app$ python manage.py migrate

<!--Démarrer le serveur de développement-->
(app) :app$ python manage.py runserver

Essayez d'accéder à [http: // localhost: 8000 /](http: // localhost: 8000 /). Vous devriez voir l'écran d'accueil de Django

Structure de répertoire actuelle

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

Créer un conteneur Docker

Django

Ajoutez le Dockerfile suivant au répertoire de l'application Puisque le but de cette fois est de créer un environnement minimum, toutes les images Docker installées à partir du fonctionnaire utiliseront le léger «linux alpin». Cela permet de construire un environnement d'une capacité d'environ 1/10 par rapport à des images comme ubuntu.

docker-demo-with-django/app/Dockerfile

#Python3 de l'officiel.7 sur l'image linux alpine pull
FROM python:3.7-alpine

#Définir le répertoire de travail
WORKDIR /usr/src/app

#Définir les variables d'environnement
#Empêcher Python d'écrire sur des fichiers et des disques pyc
ENV PYTHONDONTWRITEBYTECODE 1
#Empêcher Python de mettre en mémoire tampon les E / S standard
ENV PYTHONUNBUFFERED 1

#Installez Pipenv
RUN pip install --upgrade pip \
&& pip install pipenv

#Copiez le fichier pip de l'hôte dans le répertoire de travail du conteneur
COPY ./Pipfile /usr/src/app/Pipfile

#Construire un environnement Django en installant des packages à partir de pipfile
RUN pipenv install --skip-lock --system --dev

#Copiez le répertoire actuel de l'hôte (actuellement le répertoire de l'application) dans votre répertoire de travail
COPY . /usr/src/app/

Ajoutez ensuite docker-compose.yml à la racine du projet ( docker-demo-with-django)

version: '3.7'

services:
    #Le nom du service peut être défini librement
    django:
        #Depuis le répertoire de l'application`Dockerfile`Trouver
        build: ./app
        #Définissez la commande à saisir après le démarrage du service
        command: python manage.py runserver 0.0.0.0:8000
        #Paramètres des données persistantes.`host:container`Décrivez le chemin avec
        volumes:
            - ./app/:/usr/src/app/
        #Spécifiez le port à ouvrir.`host:container`Listez le port dans
        ports:
            - 8000:8000
        #Spécifiez la variable d'environnement
        environment:
            #1 est le mode de retour
            - DEBUG=1
　　　　# setting.SECRET répertorié dans py_Remplissez la CLÉ
            - SECRET_KEY=hoge

Modifiez setting.py dans le projet django. Il y a 3 éléments à modifier: SECRET_KEY, DEBUG, ʻALLOWED_HOSTS`

#SECRET des variables d'environnement_Paramètre pour obtenir la clé
SECRET_KEY = os.environ.get('SECRET_KEY')

#Obtenez DEBUG à partir des variables d'environnement. La valeur par défaut est True (mode production)
DEBUG = int(os.environ.get('DEBUG', default=0))

#Lister les hôtes autorisés
ALLOWED_HOSTS = ['localhost', '127.0.0.1']

Après la modification, utilisez la commande docker-compose up -d --build pour construire et démarrer en même temps.

L'option -d signifie démarrer en arrière-plan

Si vous vous connectez à [http: // localhost: 8000 /](http: // localhost: 8000 /) et que l'écran de bienvenue s'affiche, vous avez réussi.

Postgres

Pour ajouter des psotgres, ajoutez un nouveau service à docker-compose.yml En même temps, vous devez configurer la base de données pour le service django

version: '3.7'

services:
    #Le nom du service peut être défini librement
    django:
        #Depuis le répertoire de l'application`Dockerfile`Trouver
        build: ./app
        #Définissez la commande à saisir après le démarrage du service
        command: python manage.py runserver 0.0.0.0:8000
        #Paramètres des données persistantes.`host:container`Décrivez le chemin avec
        volumes:
            - ./app/:/usr/src/app/
        #Spécifiez le port à ouvrir.`host:container`Listez le port dans
        ports:
            - 8000:8000
        #Spécifiez la variable d'environnement
        environment:
            #1 est le mode de retour
            - 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
        #Spécifiez le service à connecter
        depends_on:
            - postgres

    postgres:
        #Tirez l'image du fonctionnaire
        image: postgres:11.4-alpine
        #Persistance de la base de données
        #Au début pour ne pas monter dans le répertoire hôte`./`N'attachez pas
        volumes:
            - postgres_data:/var/lib/postgresql/data
        #Créer une base de données avec les privilèges su et le même nom que l'utilisateur spécifié
        #Entrez la valeur de la même manière que celle spécifiée dans le service django
        environment:
            - POSTGRES_USER=django_db_user
            - POSTGRES_PASSWORD=password1234
            - POSTGRES_DB=django_db

#Les "volumes nommés" écrits au niveau supérieur peuvent être référencés à partir de plusieurs services
volumes:
    postgres_data:

Ensuite, réécrivez l'élément DATABASES dans setting.py.

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'),
    }
}

Vous devez utiliser un pilote pour vous connecter à postgres depuis django Cette fois, modifions docker-demo-with-django / app / Dockerfile pour tirer parti du pilote le plus important, psycopg2. Le Dockerfile ressemble à ceci Installons psycopg2 from pip après avoir installé les dépendances en utilisant ʻapk` qui est le gestionnaire de paquets de linux alpin

#Python3 de l'officiel.7 sur l'image linux alpine pull
FROM python:3.7-alpine

#Définir le répertoire de travail
WORKDIR /usr/src/app

#Définir les variables d'environnement
#Empêcher Python d'écrire sur des fichiers et des disques pyc
ENV PYTHONDONTWRITEBYTECODE 1
#Empêcher Python de mettre en mémoire tampon les E / S standard
ENV PYTHONUNBUFFERED 1

#Installation de 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

#Installez Pipenv
RUN pip install --upgrade pip \
&& pip install pipenv

#Copiez le fichier pip de l'hôte dans le répertoire de travail du conteneur
COPY ./Pipfile /usr/src/app/Pipfile

#Construire un environnement Django en installant des packages à partir de pipfile
RUN pipenv install --skip-lock --system --dev

#Copiez le répertoire actuel de l'hôte (actuellement le répertoire de l'application) dans votre répertoire de travail
COPY . /usr/src/app/

Arrêtez les conteneurs qui ont été démarrés précédemment avec docker-compose down -v, puis entrez à nouveau docker-compose up -d --build pour redémarrer les conteneurs. L'option -v représente la suppression du volume

<!--Arrêter le conteneur-->
$ docker-compose down -v

<!--Démarrer le conteneur-->
$ 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

Dans de rares cas, Django et postgres ne se connectent pas et le conteneur postgres s'arrête après avoir fait la même chose plusieurs fois. Dans ce cas, vérifions le journal Probablement postgres_1 | initdb: répertoire" / var / lib / postgresql / data "existe mais n'est pas vide
Vous pouvez voir la description comme, alors supprimons docker-demo-with-django / postgres_data du côté hôte.

Utilisez la commande docker-compose ps pour vérifier que les deux conteneurs sont en cours d'exécution (l'état est actif) comme indiqué ci-dessous.

$ 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 

Ensuite, assurez-vous que la base de données spécifiée a été créée pour la base de données.

$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

Une fois confirmé, ajoutez ʻentrypoint.sh` dans le répertoire de l'application pour la migration automatique après avoir confirmé la connexion à postgres.

#!/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 "$@"

Après l'ajout, accordez l'autorisation d'exécution avec la commande chmod + x app / entrypoint.sh. Enfin modifiez le Dockerfile pour exécuter ʻentrypoint.sh et ajoutez la variable d'environnement $ DATABASE`

#Python3 de l'officiel.7 sur l'image linux alpine pull
FROM python:3.7-alpine

#Définir le répertoire de travail
WORKDIR /usr/src/app

#Définir les variables d'environnement
#Empêcher Python d'écrire sur des fichiers et des disques pyc
ENV PYTHONDONTWRITEBYTECODE 1
#Empêcher Python de mettre en mémoire tampon les E / S standard
ENV PYTHONUNBUFFERED 1

#Installation de 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

#Installez Pipenv
RUN pip install --upgrade pip \
&& pip install pipenv

#Copiez le fichier pip de l'hôte dans le répertoire de travail du conteneur
COPY ./Pipfile /usr/src/app/Pipfile

#Construire un environnement Django en installant des packages à partir de pipfile
RUN pipenv install --skip-lock --system --dev

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

#Copiez le répertoire actuel de l'hôte (actuellement le répertoire de l'application) dans votre répertoire de travail
COPY . /usr/src/app/

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

Attendez un moment et si vous pouvez vous connecter à [http: // localhost: 8000 /](http: // localhost: 8000 /) une fois le démarrage terminé, vous avez terminé

Pour le moment, l'environnement de développement personnel est prêt Mais pour un environnement de production, vous devez garder les variables d'environnement privées. Vous devez également démarrer le serveur d'une manière différente en raison d'un manque de fonctionnalités ou de problèmes de sécurité avec python manage.py runserver. Pour cela, installez gunicorn (serveur WSGI) qui est l'interface entre l'application et le serveur Web, définissez ʻenv_file, et définisseznginx qui agit comme un proxy inverse de gunicorn` pour traiter les fichiers statiques. Doit faire Ensuite, nous les ferons

Installez Gunicorn et créez un fichier de configuration de production

Ajoutons gunicorn à pipfile

[[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"

De plus, ajoutez docker-compose.prod.yml au même répertoire que docker-compose.yml, et décrivez les paramètres de l'environnement de production.

version: '3.7'

services:
    #Le nom du service peut être défini librement
    django:
        #Depuis le répertoire de l'application`Dockerfile`Trouver
        build: ./app
        #Définissez la commande à saisir après le démarrage du service
        command: gunicorn django_demo.wsgi:application --bind 0.0.0.0:8000
        #Paramètres des données persistantes.`host:container`Décrivez le chemin avec
        volumes:
            - ./app/:/usr/src/app/
        #Spécifiez le port à ouvrir.`host:container`Listez le port dans
        ports:
            - 8000:8000
        #Spécifiez la variable d'environnement
        env_file: .env
        #Spécifiez le service à connecter
        depends_on:
            - postgres

    postgres:
        #Tirez l'image du fonctionnaire
        image: postgres:11.4-alpine
        #Persistance de la base de données
        volumes:
            - postgres_data:/var/lib/postgresql/data
        env_file: .env.db

#Les "volumes nommés" écrits au niveau supérieur peuvent être référencés à partir de plusieurs services
volumes:
  postgres_data:

Par rapport aux paramètres de l'environnement de développement, ʻenvironment: est devenu ʻenv_file:. Cela élimine le besoin d'écrire les paramètres de production directement dans yml. De plus, en spécifiant la commande liée au démarrage de gunicorn dans la commande: ʻdu service django, gunicornest lancé à la place derunserver`.

Placez ʻenv_filedans le même répertoire quedocker-compose.prod.ymlet écrivez comme suit À ce stade, n'oubliez pas de définirDEBAG = 0 dans .env (désactivez le mode débogage avec 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

De plus, à ce stade, migrate sera exécuté à chaque démarrage du conteneur, donc créons également ʻentrypoint.prod.sh` pour l'environnement de production.

/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 sera également créé pour la production

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

#Python3 de l'officiel.7 sur l'image linux alpine pull
FROM python:3.7-alpine

#Définir le répertoire de travail
WORKDIR /usr/src/app

#Définir les variables d'environnement
#Empêcher Python d'écrire sur des fichiers et des disques pyc
ENV PYTHONDONTWRITEBYTECODE 1
#Empêcher Python de mettre en mémoire tampon les E / S standard
ENV PYTHONUNBUFFERED 1

#Installation de 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

#Installez Pipenv
RUN pip install --upgrade pip \
&& pip install pipenv

#Copiez le fichier pip de l'hôte dans le répertoire de travail du conteneur
COPY ./Pipfile /usr/src/app/Pipfile

#Construire un environnement Django en installant des packages à partir de pipfile
RUN pipenv install --skip-lock --system --dev

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

#Copiez le répertoire actuel de l'hôte (actuellement le répertoire de l'application) dans votre répertoire de travail
COPY . /usr/src/app/

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

Naturellement, réécrivez docker-compose.prod.yml pour lire également le fichier de production.

version: '3.7'

services:
    #Le nom du service peut être défini librement
    django:
        build:
            #Le nom du fichier à lire est`Dockerfile`Sinon, entrez le chemin relatif en contexte et le nom du fichier dans dockerfile
            context: ./app
            dockerfile: Dockerfile.prod
        #Définissez la commande à saisir après le démarrage du service
        command: gunicorn django_demo.wsgi:application --bind 0.0.0.0:8000
        #Paramètres des données persistantes.`host:container`Décrivez le chemin avec
        volumes:
            - ./app/:/usr/src/app/
        #Spécifiez le port à ouvrir.`host:container`Listez le port dans
        ports:
            - 8000:8000
        #Spécifiez la variable d'environnement
        env_file: .env
        #Spécifiez le service à connecter
        depends_on:
            - postgres

    postgres:
        #Tirez l'image du fonctionnaire
        image: postgres:11.4-alpine
        #Persistance de la base de données
        volumes:
            - postgres_data:/var/lib/postgresql/data
        env_file: .env.db

#Les "volumes nommés" écrits au niveau supérieur peuvent être référencés à partir de plusieurs services
volumes:
    postgres_data:

Redémarrons le conteneur après avoir terminé les paramètres

$ docker-compose down -v

<!-- -docker avec option f-compose.prod.Spécifiez yml-->
$ docker-compose -f docker-compose.prod.yml up -d --build

<!-- entrypoint.prod.Puisque sh ne migre pas, exécutez-le manuellement-->
$ docker-compose -f docker-compose.prod.yml exec django python manage.py migrate --noinput

Après le démarrage, accédons à [http: // localhost: 8000 / admin](http: // localhost: 8000 / admin) Vous devriez être connecté et voir l'écran de connexion pour gérer django, mais vous ne devriez voir aucun fichier statique (CSS, etc.) C'est parce que j'ai désactivé le mode de débogage pour que les fichiers statiques ne soient plus chargés De plus, Gunicorn a démarré selon les paramètres, mais il ne prend pas en charge la distribution des fichiers statiques Gunicorn et ne fournit que l'application (django dans ce cas), donc si vous ne modifiez pas les deux paramètres ci-dessus, le fichier statique Ne peut être livré Plus précisément, utilisez python manage.py collectstatic pour collecter les fichiers statiques en un seul endroit et les lire, et utilisez un serveur Web tel que nginx comme proxy inverse pour gunicorn.

Ajoutons d'abord nginx au service

Ajouter nginx

Créez un répertoire nginx à la racine de votre projet (/ docker-demo-with-django /) et ajoutez-y Dockerfile et nginx.conf.

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

FROM nginx:1.15.12-alpine

#Supprimer la configuration par défaut et ajouter un autre paramètre
RUN rm /etc/nginx/conf.d/default.conf
COPY nginx.conf /etc/nginx/conf.d

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

upstream config {
    #Si vous spécifiez le nom de service du conteneur, le nom sera résolu
    server django:8000;
}

server {
    #Attendez au port 80
    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;
    }

}

Ajoutez ensuite nginx à docker-compose.prod.yml

version: '3.7'

services:
    #Le nom du service peut être défini librement
    django:
        build:
            #Le nom du fichier à lire est`Dockerfile`Sinon, entrez le chemin relatif en contexte et le nom du fichier dans dockerfile
            context: ./app
            dockerfile: Dockerfile.prod
        #Définissez la commande à saisir après le démarrage du service
        command: gunicorn django_demo.wsgi:application --bind 0.0.0.0:8000
        #Paramètres des données persistantes.`host:container`Décrivez le chemin avec
        volumes:
            - ./app/:/usr/src/app/
        #Le port spécifié est accessible depuis le service connecté
        expose:
            - 8000
        #Spécifiez la variable d'environnement
        env_file: .env
        #Spécifiez le service à connecter
        depends_on:
            - postgres

    postgres:
        #Tirez l'image du fonctionnaire
        image: postgres:11.4-alpine
        #Persistance de la base de données
        volumes:
            - postgres_data:/var/lib/postgresql/data
        env_file: .env.db

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

#Les "volumes nommés" écrits au niveau supérieur peuvent être référencés à partir de plusieurs services
volumes:
    postgres_data:

Remplacez ports: par ʻexpose: `car vous ne demanderez plus le service django directement depuis le système d'exploitation hôte Le port spécifié par ceci ne sera pas exposé au système d'exploitation hôte, mais il sera possible de se connecter à partir du service lié.

Redémarrez le service comme avant

$ 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

Connectons-nous à [http: // localhost: 1337 / admin /](http: // localhost: 1337 / admin /). Vous devriez voir l'écran d'administration

Ceci termine la connexion avec nginx. La structure des répertoires à ce stade est la suivante

$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

Gestion des fichiers statiques

Vient ensuite le paramètre de traitement des fichiers statiques. Corrigez la fin de setting.py du projet django et ajoutez-le à ʻentrypoint.sh`

/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 "$@"

Maintenant, python manage.py collectstatic collectera les fichiers statiques dans le chemin spécifié par STATIC_ROOT et fournira également les fichiers statiques qui existent dans le répertoire staticfiles.

Ensuite, définissez le même volume pour django et nginx dans docker-compose.prod.yml, connectez le projet django au conteneur nginx, puis acheminez les demandes de fichiers statiques vers le répertoire staticfiles. Mettons

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

version: '3.7'

services:
    #Le nom du service peut être défini librement
    django:
        build:
            #Le nom du fichier à lire est`Dockerfile`Sinon, entrez le chemin relatif en contexte et le nom du fichier dans dockerfile
            context: ./app
            dockerfile: Dockerfile.prod
        #Définissez la commande à saisir après le démarrage du service
        command: gunicorn django_demo.wsgi:application --bind 0.0.0.0:8000
        #Paramètres des données persistantes.`host:container`Décrivez le chemin avec
        volumes:
            - static_volume:/usr/src/app/staticfiles
        #Le port spécifié est accessible depuis le service connecté
        expose:
            - 8000
        #Spécifiez la variable d'environnement
        env_file: .env
        #Spécifiez le service à connecter
        depends_on:
            - postgres

    postgres:
        #Tirez l'image du fonctionnaire
        image: postgres:11.4-alpine
        #Persistance de la base de données
        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

#Les "volumes nommés" écrits au niveau supérieur peuvent être référencés à partir de plusieurs services
volumes:
    postgres_data:
    static_volume:

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

upstream config {
    #Si vous spécifiez le nom de service du conteneur, le nom sera résolu
    server django:8000;
}

server {
    #Attendez au port 80
    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;
    }

    #Acheminer les demandes de fichiers statiques vers des fichiers statiques
    location /staticfiles/ {
        alias /usr/src/app/staticfiles/;
    }

}

Ceci termine tous les réglages! Commençons à nouveau le conteneur!

$ 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

Après avoir confirmé le démarrage, essayez de vous connecter à [http: // localhost: 1337 / admin](http: // localhost: 1337 / admin). CSS doit être défini sur l'écran de gestion! Modifiez ensuite le projet Django comme vous le souhaitez!

Je vous remercie pour votre travail acharné! !!