Construction de l'environnement de développement Django avec Docker-compose + Nginx + uWSGI + MariaDB (édition macOS)

Docker est pratique pour l'environnement de développement local

En créant l'environnement de développement de Python + Django, vous pouvez changer la version avec pyenv etc., mais c'est gênant lors du développement avec une équipe ou du développement sur une autre machine, donc je veux le faire en utilisant Docker qui construit un environnement virtuel Je pense.

Docker est une plate-forme qui exécute des intergiciels et des applications à l'aide de la technologie de conteneur. C'est un peu différent des machines virtuelles telles que VMware. Quoi qu'il en soit, c'est pratique, vous devriez donc l'essayer. Il est également possible de créer un serveur Web tel que wordpress localement.

Référence: https://knowledge.sakura.ad.jp/13265/

Je souhaite également utiliser PyCharm pour l'environnement de développement intégré sur macOS.

environnement

Installez Docker pour Mac

Installez Docker pour mac en Download depuis le site Web officiel de Docker.

Vous devrez vous connecter à Docker, alors créez un compte ici. https://hub.docker.com/

Lorsque vous démarrez Docker pour mac, il vous sera demandé un identifiant et un mot de passe, alors connectez-vous avec le compte que vous avez créé précédemment.

Pour utiliser les commandes Docker, vous devez démarrer Docker pour mac et vous connecter.

Référence: https://docs.docker.com/docker-for-mac/

Créer un environnement avec Docker-compose

Docker doit démarrer chaque conteneur tel que Nginx, CentOS, MariaDB (MySQL) et connecter les conteneurs. Docker-compose décrit ces configurations et lance plusieurs conteneurs à la fois.

Créer un projet

Créez un répertoire de projet sous Document pour créer un projet.

Créer un fichier de configuration Docker-compose

Décrivez la configuration du conteneur Docker dans un fichier.

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" : Version descriptive de docker-compose --volumes: : Sauvegarde le contenu de la base de données.

Explication du conteneur uWSGI

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: `: Exécutez python avec uWSGI.

• Démarrez Django avec la commande command:.
• Écoute sur le port 8081. -- - module userapp.wsgi doit avoir le même nom que le nom du projet (userapp) généré par Django. --Définir le fichier journal
• Activer le rechargement automatique

Description du conteneur Nginx

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: : L'accès de l'extérieur est le port 8080, l'accès à l'intérieur du conteneur est le port 80 --volumes: : Créez le fichier de configuration Nginx dans. / nginx / conf.d plus tard.

Description du conteneur MariaDB

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: : Accès de l'extérieur sur le port 3316, à l'intérieur du conteneur sur le port 3306 --ʻEnvironnement: : définir le mot de passe root et le fuseau horaire --volumes: : Le SQL initial pour la construction de la base de données sera créé plus tard dans. / sql`.

Créer un Dockerfile

Il s'agit d'un script qui démarre lors de la création d'une image Docker.

./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: démarre en fonction de l'image python. --Invalidation du tampon de sortie sur la ligne de commande. Il est préférable pour le débogage si le tampon est désactivé car le résultat sera involontaire en raison de l'affichage avec un décalage horaire. --WORKDIR / code: répertoire d'exécution --RUN pip install -r requirements.txt: Installez les bibliothèques requises pour Docker en les listant dans requirements.txt.

Créer requirements.txt

Décrit la bibliothèque requise pour exécuter python lors du démarrage de Docker.

text:./docker/requirements.txt

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

--Django est un framework --ʻUwsgi est un serveur d'exécution python sur le Web --PyMySQL` est une bibliothèque pour se connecter de python à MySQL (MariaDB).

Script initial de MariaDB

Créez un utilisateur et une base de données pour les opérations de base de données.

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;

--Créez une base de données ʻapp et paramétrez-la pour qu'elle soit accessible par ʻappuser.

Configuration de Nginx uWSGI

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

Vous pouvez télécharger la configuration uWSGI pour Nginx depuis ici.

./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;

Contient les paramètres requis pour exécuter uWSGI. Veuillez l'utiliser tel quel, en pensant que c'est magique.

Configuration Nginx

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;
        }
}

• Puisque le port uWSGI est 8081, réglez-le sur ʻupstream django. --écoute 80: L'accès dans le conteneur est le port 80 --location / static: Les images, JavaScript et CSS sont renvoyés dans Nginx. --location / `: Tous les autres accès sont gérés par uWSGI.

Lancement du projet et construction initiale

Construire un projet Django

% docker-compose build

L'image définie par Docker-compose sera téléchargée et construite.

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

Construisez le projet Djanago. N'oubliez pas le dernier ".".

% 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

Le répertoire du projet dans lequel le projet Django est construit avec succès ressemble à ceci.

Exécutez Django

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

• L'option -d s'exécute dans le démon (en arrière-plan).

http://127.0.0.1:8080 J'essaierai d'accéder. Si vous voyez un écran comme celui-ci, vous avez réussi.

% 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

Lorsque vous avez terminé, cette commande vous fera tomber.

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

Exécutez la commande pour pirater l'état de fonctionnement de Docker, et si rien ne s'affiche, l'arrêt réussit.

Installation de l'environnement de développement intégré PyCharm

PyCharm de JetBeans est pratique pour développer Django et Python. Si vous développez une application Web, la version professionnelle payante, qui peut également éditer Javascript, CSS et HTML, est utile, mais la version gratuite Community est suffisante au début.

Téléchargez et installez PyCharm

Téléchargez le logiciel sur le site officiel de PyCharm. Site Web officiel de PyCharm

Après le téléchargement, placez-le dans le dossier de l'application et l'installation est terminée.

Charger le projet

Choisissez Fichier> Ouvrir et choisissez le dossier racine de votre projet.

Connexion entre le conteneur Python de Docker et PyCharm

La version professionnelle est requise pour s'exécuter à partir de PyCharm à l'aide du conteneur Python de Docker. Si vous développez pour Light pour le moment, je pense que vous pouvez utiliser PyCharm comme éditeur.

c'est tout.

référence: https://nmmmk.hatenablog.com/entry/2018/05/01/101126 https://qiita.com/NickelCreate/items/bed3dc9d088b57127ba7