Looking for django Answers? Try Ask4KnowledgeBase
Looking for django Keywords? Try Ask4Keywords

Django Projet compatible avec le déploiement avec support Docker.


Exemple

Le modèle de projet par défaut de Django est correct, mais une fois que vous avez déployé votre code et que, par exemple, les devops mettent la main sur le projet, les choses se gâtent. Ce que vous pouvez faire est de séparer votre code source du reste qui doit être dans votre référentiel.

Vous pouvez trouver un modèle de projet Django utilisable sur GitHub .

Structure du projet

PROJECT_ROOT
├── devel.dockerfile
├── docker-compose.yml
├── nginx
│   └── project_name.conf
├── README.md
├── setup.py
└── src
    ├── manage.py
    └── project_name
        ├── __init__.py
        └── service
            ├── __init__.py
            ├── settings
            │   ├── common.py
            │   ├── development.py
            │   ├── __init__.py
            │   └── staging.py
            ├── urls.py
            └── wsgi.py

J'aime garder le répertoire de service nommé service pour chaque projet grâce à ce que je peux utiliser le même Dockerfile dans tous mes projets. La répartition des exigences et des paramètres est déjà bien documentée ici:
Utiliser plusieurs fichiers de besoins
Utiliser plusieurs paramètres

Dockerfile

En supposant que seuls les développeurs utilisent Docker (ce ne sont pas tous les développeurs qui lui font confiance de nos jours). Cela pourrait être un environnement de dev devel.dockerfile :

FROM python:2.7
ENV PYTHONUNBUFFERED 1

RUN mkdir /run/service
ADD . /run/service
WORKDIR /run/service

RUN pip install -U pip
RUN pip install -I -e .[develop] --process-dependency-links

WORKDIR /run/service/src
ENTRYPOINT ["python", "manage.py"]
CMD ["runserver", "0.0.0.0:8000"]

L'ajout des seules exigences permettra de tirer parti du cache Docker lors de la création. Il vous suffit de reconstruire en fonction des modifications apportées aux exigences.

Composer

Docker compose est pratique, en particulier lorsque vous avez plusieurs services à exécuter localement. docker-compose.yml :

version: '2'
services:
  web:
    build:
      context: .
      dockerfile: devel.dockerfile
    volumes:
      - "./src/{{ project_name }}:/run/service/src/{{ project_name }}"
      - "./media:/run/service/media"
    ports:
      - "8000:8000"
    depends_on:
      - db
  db:
    image: mysql:5.6
    environment:
      - MYSQL_ROOT_PASSWORD=root
      - MYSQL_DATABASE={{ project_name }}
  nginx:
    image: nginx
    ports:
      - "80:80"
    volumes:
      - "./nginx:/etc/nginx/conf.d"
      - "./media:/var/media"
    depends_on:
      - web

Nginx

Votre environnement de développement doit être aussi proche que possible de l'environnement de production, donc j'aime utiliser Nginx dès le début. Voici un exemple de fichier de configuration nginx:

server {
    listen   80;
    client_max_body_size 4G;
    keepalive_timeout 5;

    location /media/ {
        autoindex on;
        alias /var/media/;
    }

    location / {
        proxy_pass_header Server;
        proxy_set_header Host $http_host;
        proxy_redirect off;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Scheme $scheme;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Ssl on;
        proxy_connect_timeout 600;
        proxy_read_timeout 600;
        proxy_pass http://web:8000/;
    }
}

Usage

$ cd PROJECT_ROOT
$ docker-compose build web  # build the image - first-time and after requirements change
$ docker-compose up  # to run the project
$ docker-compose run --rm --service-ports --no-deps  # to run the project - and be able to use PDB
$ docker-compose run --rm --no-deps <management_command>  # to use other than runserver commands, like makemigrations
$ docker exec -ti web bash  # For accessing django container shell, using it you will be inside /run/service directory, where you can run ./manage shell, or other stuff
$ docker-compose start  # Starting docker containers
$ docker-compose stop  # Stopping docker containers