Créer un environnement django avec docker-compose (MariaDB + Nginx + uWSGI)

introduction

Ceci est le premier message de qiita. Si vous trouvez quelque chose qui ne va pas, je vous serais reconnaissant de bien vouloir commenter ~ Partiellement modifié le 2019/12/18

J'utilise Pycharm.

annuaire

Le répertoire ressemble à ceci

.
├── db
│   ├── data
│   └── sql
│       └── init.sql
├── docker-compose.yml
├── nginx
│   ├── conf
│   │   └── app_nginx.conf
│   ├── log
│   └── uwsgi_params
├── python
│   ├── Dockerfile
│   └── requirements.txt
├── src
│   └── project
│       ├── app
│       ├── project
│       └── manage.py
│       └── uwsgi.ini
└── static

Base de données

Utilisez MariaDB. Créez un dossier de données et init.sql pour l'initialisation dans le répertoire db.

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

FLUSH PRIVILEGES;

Lors du téléchargement sur github, placez-le dans .gitigonre afin que le mot de passe, etc. ne puisse pas être vu.
Ne créez pas de fichier docker, mais écrivez-le dans docker-compose.yml.

Nginx

Ignorez les fichiers statiques tels que les images vers nginx, qui est un serveur proxy inverse.

app_nginx.conf

upstream django {
    ip_hash;
    server python:8001;
}

# configuration of the server
server {
    # the port your site will be served on
    listen      8000;
    # the domain name it will serve for
    server_name 127.0.0.1; # substitute your machine's IP address or FQDN
    charset     utf-8;

    # max upload size
    client_max_body_size 75M;   # adjust to taste

    location /static {
        alias /static;
    }


    # Finally, send all non-media requests to the Django server.
    location / {
        uwsgi_pass  django;
        include /etc/nginx/uwsgi_params; # the uwsgi_params file you installed
    }
}

Tout d'abord, s'il y a un accès, il sera reçu sur le port 8000 de nginx, s'il y a un accès au fichier statique static, il sera ignoré vers static de nginx qui est un serveur proxy inverse, et les autres seront sautés vers le serveur d'application (uWSGI) du port 8001.

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;

params est ok avec la copie

python

Dockerfile/python


# The first instruction is what image we want to base our container on
# We Use an official Python runtime as a parent image
FROM python:3.8-alpine
# The enviroment variable ensures that the python output is set straight
# to the terminal with out buffering it first
ENV PYTHONUNBUFFERED 1
ENV PYTHONIOENCODING utf-8
ENV APP_PATH  code
# Set the working directory to /code
WORKDIR /$APP_PATH
COPY ./requirements.txt /$APP_PATH
# Install any needed packages specified in requirements.txt
RUN apk add --no-cache --virtual .build-deps bash gcc musl-dev libffi-dev \
 g++ libgcc libstdc++ libxml2-dev libxslt-dev openssl-dev curl \
 && apk add --no-cache --virtual --update-cache\
 jpeg-dev zlib-dev freetype-dev lcms2-dev openjpeg-dev tiff-dev tk-dev tcl-dev \
 mariadb-dev mariadb-connector-c-dev \
 && pip install cython && pip install -U pip && pip install -r requirements.txt
 # Make alpine lighter
RUN rm -rf /var/cache/apk/* && \
    rm -rf /tmp/*

Erreurs d'installation fréquentes en fonction des sauts de ligne et des délimiteurs lors de l'ajout d'apk Depuis que cela a fonctionné, la situation actuelle est correcte, alors ...

Django==3.0
flake8==3.7.9
ipython==7.10.1
mysqlclient==1.4.6
Pillow==6.2.1
uWSGI==2.0.18

J'inclus également flake8, qui vérifie le code, et ipython, qui a un interpréteur puissant pour python. Il existe de nombreux pilotes pour la connexion à la base de données, mais nous utilisons le mysqlclient officiellement recommandé. https://docs.djangoproject.com/ja/3.0/ref/databases/#mysql-db-api-drivers

docker-compose.yml


version: '3.4'
services:
  nginx:
    image: nginx:1.13
    container_name: app_nginx
    ports:
      - "8000:8000"
    volumes:
      - ./nginx/conf:/etc/nginx/conf.d
      - ./nginx/uwsgi_params:/etc/nginx/uwsgi_params
      - ./static:/static
      - ./nginx/log:/var/log/nginx
    depends_on:
      - python
  db:  # the same name as 'host' in DATABASES setting, otherwise Django won't find the database
    image: mariadb:10.1
    container_name: app_mariadb
    ports:
      - 3306:3306
    environment:
      MYSQL_DATABASE: app
      MYSQL_ROOT_USER: root
      MYSQL_ROOT_PASSWORD: root
      TZ: 'Asia/Tokyo'
    volumes:
      - ./db/data:/var/lib/mysql
      - ./db/sql:/docker-entrypoint-initdb.d
  python:
    build: ./python
    image: python_blog
    container_name: app_python
    command: uwsgi --ini /code/project/uwsgi.ini
    volumes:
      - ./src:/code
      - ./static:/static
    expose:
      - "8001"
    depends_on:
      - db 

Faites correspondre la base de données du nom du service avec la base de données de l'hôte dans les paramètres de base de données de django settings.py.


Si tu vas aussi loin Où docker-compose.yml est

$ docker-compose up -d --build

Lançons le conteneur. Le conteneur nginx et python ne démarre pas.


command: uwsgi --ini /code/project/uwsgi.ini

Comme uwsgi.ini n'existe pas encore, créez un projet django et placez-le.

$ docker-compose run --rm python django-admin.py startproject project

Créez un projet django. La partie python est le nom de service de docker-compose.yml Si vous n'ajoutez pas --rm, de nombreux conteneurs python seront créés, supprimez-les à chaque exécution.

[uwsgi]
socket = :8001
module = project.wsgi
wsgi-file = /code/project/project/wsgi.py
logto = /code/project/project/uwsgi.log
chdir=/code/project
py-autoreload = 1

Placez uwsgi.ini

$ docker-compose down
$ docker-compose up -d
$ docker ps -a

Tous les conteneurs semblent être en place

$ docker exec -it app_python /bin/bash
$ cd ./project/
$ python manage.py startapp app

L'environnement python est fait avec alpine linux, et bash n'est pas inclus dans alpine, donc / bin / sh ou / bin / ash. Cette fois je mets bash donc bash Créer une application pour django

Paramètres dans django

settings.py


INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'app.apps.AppConfig',  #ajouter à


#Changement
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'app',
        'USER': 'root',
        'PASSWORD': 'root',
        'HOST': 'db',
        'PORT': '3306',
        'OPTIONS': {
            'charset': 'utf8mb4',
        },
    }

#Changez à votre goût
LANGUAGE_CODE = 'ja'

TIME_ZONE = 'Asia/Tokyo'


STATIC_ROOT = './../../../static/'  #Omoto pour la distribution pour l'environnement de production
STATIC_URL = '/static/'  #URL utilisée dans l'environnement de production

# Custom Useer
AUTH_USER_MODEL = 'app.User'

Selon le responsable, avant de migrer, j'ai créé un utilisateur personnalisé pour le moment. Créer un utilisateur personnalisé https://docs.djangoproject.com/ja/3.0/topics/auth/customizing/#using-a-custom-user-model-when-starting-a-project

models.py

from django.contrib.auth.models import AbstractUser

class User(AbstractUser):
	pass

admin.py

from django.contrib import admin
from django.contrib.auth.admin import UserAdmin

from .models import User

admin.site.register(User, UserAdmin)

Dans le conteneur Docker

$ python manage.py makemigrations
$ python manage.py migrate
$ python manage.py createsuperuser

http://localhost:8000/ Django devrait être en place S'il y a une erreur sur le serveur, réessayez docker-compose up

Après la migration, créez un utilisateur pour l'administrateur django Accédez à http: // localhost: 8000 / admin / djangoadmin Depuis que j'utilise uwsgi, le CSS ne fonctionne pas


$ python manage.py collectstatic

css fonctionne également pour l'administrateur django

Vous devriez maintenant pouvoir vous développer. .. ..

référence

Python3.6 + NGINX + MariaDB10 + uWSGI Django Environment Greedy Set avec Docker-Compose

Recommended Posts

Créer un environnement django avec docker-compose (MariaDB + Nginx + uWSGI)
Créer un environnement de Nginx + uWSGI + Python (Django) avec docker
Construction de l'environnement de développement Django avec Docker-compose + Nginx + uWSGI + MariaDB (édition macOS)
Créez un environnement de développement Django avec Docker! (Docker-compose / Django / postgreSQL / nginx)
Créer un environnement Python + uWSGI + Nginx avec Docker
Créer une page d'accueil avec django
Créez un environnement virtuel avec Python!
Créer un téléchargeur de fichiers avec Django
Créer une application Todo avec Django ① Créer un environnement avec Docker
[Python] Créez un environnement virtuel avec Anaconda
Créez un environnement d'API rapide avec docker-compose
J'ai créé un environnement de développement pour Django 3.0 avec Docker, Docker-compose, Poetry
[DynamoDB] [Docker] Créer un environnement de développement pour DynamoDB et Django avec docker-compose
Créez rapidement un environnement d'exécution d'application Web Python3.4 + Nginx + uWSGI + Flask en utilisant pyenv sur Ubuntu 12.04
Démarrez Django dans un environnement virtuel à l'aide de Pipenv
Créer un environnement virtuel avec conda avec Python
[Python] Créer un environnement de développement Django avec Docker
Créer un environnement de construction python3 avec Sublime Text3
Créez un environnement Django avec Vagrant en 5 minutes
Créez un tableau de bord pour les appareils réseau avec Django!
Créer un environnement de développement Django à l'aide de Doker Toolbox
Créez une application Hello World avec un seul fichier avec django
Créez rapidement un environnement Python Django avec IntelliJ
Créer un planning Django
environnement python avec docker-compose
Créer un environnement Python
Créer une application Todo avec Django REST Framework + Angular
Créez rapidement un environnement d'exécution d'application Web Python3.4 + Nginx + uWSGI + Flask en utilisant venv sur Ubuntu 14.04 LTS
Créez un environnement virtuel avec Anaconda installé via Pyenv
Créez un environnement de développement python avec vagrant + ansible + fabric
environnement en ligne de serveur de code (2) Créer un réseau virtuel avec Boto3
Lancer Django sur un conteneur Docker à l'aide de docker-compose up
Créer un environnement OCR japonais avec Anaconda (tesseract + pyocr)
Déboguer à distance l'environnement Django créé avec docker-compose avec VS Code
Créez un environnement de développement avec Poetry Django Docker Pycharm
Construire un environnement Django pour Win10 (avec espace virtuel)
Créez un environnement d'apprentissage automatique à partir de zéro avec Winsows 10
Créer un environnement avec virtualenv
Environnement de site Web de configuration minimale avec django
Créer une API avec Django
API avec Flask + uWSGI + Nginx
Créer un répertoire avec python
Essayez d'exécuter python dans l'environnement Django créé avec pipenv
[Memo] Construire un environnement de développement pour Django + Nuxt.js avec Docker
[Django] Créez rapidement un environnement de développement de conteneur Django (Docker) avec PyCharm
Créez une API Web capable de fournir des images avec Django
Déployer l'application Django sur EC2 avec Nginx + Gunicorn + Supervisor
Créez une API d'intégration sociale pour les applications smartphone avec Django
[Python] Créer un écran pour le code d'état HTTP 403/404/500 avec Django
Créer un environnement Kubernetes avec Ansible 2
Construisez FastAPI + uvicorn + nginx avec docker-compose
Créer un environnement d'exécution Windows Python avec VScode + Remote WSL
Étapes pour créer un projet Django