Débuter avec Django

Démarrer un projet

Django est un framework de développement web basé sur Python. Django 1.11 (la dernière version stable) nécessite l’installation de Python 2.7, 3.4, 3.5 ou 3.6. En supposant que pip est disponible, l’installation est aussi simple que d’exécuter la commande suivante. Gardez à l’esprit que l’omission de la version comme indiqué ci-dessous installera la dernière version de django :

$ pip install django

Pour installer une version spécifique de django, supposons que la version soit django 1.10.5 , exécutez la commande suivante :

$ pip install django==1.10.5

Les applications Web créées à l’aide de Django doivent résider dans un projet Django. Vous pouvez utiliser la commande django-admin pour démarrer un nouveau projet dans le répertoire courant :

$ django-admin startproject myproject

myproject est un nom qui identifie de manière unique le projet et peut être composé de chiffres, de lettres et de traits de soulignement.

Cela créera la structure de projet suivante :

myproject/
    manage.py
    myproject/
        __init__.py
        settings.py
        urls.py
        wsgi.py

Pour exécuter l’application, démarrez le serveur de développement

$ cd myproject
$ python manage.py runserver

Maintenant que le serveur est en cours d’exécution, visitez http://127.0.0.1:8000/ avec votre navigateur Web. Vous verrez la page suivante :

[![entrez la description de l’image ici][1]][1]

Par défaut, la commande runserver démarre le serveur de développement sur l’IP interne au port 8000. Ce serveur redémarrera automatiquement lorsque vous apporterez des modifications à votre code. Mais si vous ajoutez de nouveaux fichiers, vous devrez redémarrer manuellement le serveur.

Si vous souhaitez modifier le port du serveur, transmettez-le en tant qu’argument de ligne de commande.

$ python manage.py runserver 8080

Si vous souhaitez modifier l’adresse IP du serveur, transmettez-la avec le port.

$ python manage.py runserver 0.0.0.0:8000
  • Notez que runserver est uniquement destiné aux versions de débogage et aux tests locaux. Les programmes serveur spécialisés (tels qu’Apache) doivent toujours être utilisés en production.*

Ajout d’une application Django

Un projet Django contient généralement plusieurs apps. Il s’agit simplement d’un moyen de structurer votre projet en modules plus petits et maintenables. Pour créer une application, accédez à votre dossier de projet (où se trouve manage.py) et exécutez la commande startapp (changez * myapp * comme vous le souhaitez):

python manage.py startapp myapp

Cela générera le dossier * myapp * et certains fichiers nécessaires pour vous, comme models.py et views.py.

Afin de rendre Django conscient de myapp, ajoutez-le à votre settings.py :

# myproject/settings.py

# Application definition
INSTALLED_APPS = [
    ...
    'myapp',
]

La structure des dossiers d’un projet Django peut être modifiée selon vos préférences. Parfois, le dossier du projet est renommé en /src pour éviter de répéter les noms de dossier. Une structure de dossier typique ressemble à ceci :

[![structure de répertoire][2]][2]

[1] : http://i.stack.imgur.com/sABAE.png [2] : http://i.stack.imgur.com/LRsRO.png

Environnement virtuel

Bien que cela ne soit pas strictement obligatoire, il est fortement recommandé de démarrer votre projet dans un “environnement virtuel”. Un environnement virtuel est un conteneur (un répertoire) qui contient une version spécifique de Python et un ensemble de modules (dépendances), et qui n’interfère pas avec le Python natif du système d’exploitation ou d’autres projets sur le même ordinateur.

En configurant un environnement virtuel différent pour chaque projet sur lequel vous travaillez, divers projets Django peuvent s’exécuter sur différentes versions de Python et peuvent maintenir leurs propres ensembles de dépendances, sans risque de conflit.

Python 3.3+

Python 3.3+ inclut déjà un module venv standard, que vous pouvez généralement appeler pyvenv. Dans les environnements où la commande pyvenv n’est pas disponible, vous pouvez accéder à la même fonctionnalité en appelant directement le module en tant que python3 -m venv.

Pour créer l’environnement virtuel :

$ pyvenv <env-folder>
# Or, if pyvenv is not available
$ python3 -m venv <env-folder>

Python 2

Si vous utilisez Python 2, vous pouvez d’abord l’installer en tant que module distinct de pip :

$ pip install virtualenv

Et créez ensuite l’environnement en utilisant la commande virtualenv à la place :

$ virtualenv <env-folder>

Activer (toute version)

L’environnement virtuel est maintenant configuré. Pour l’utiliser, il doit être activé dans le terminal où vous souhaitez l’utiliser.

Pour ‘activer’ l’environnement virtuel (toute version de Python)

Linux comme :

$ source <env-folder>/bin/activate

Windows comme :

<env-folder>\Scripts\activate.bat

Cela modifie votre invite pour indiquer que l’environnement virtuel est actif. (<dossier-env>) $

À partir de maintenant, tout ce qui est installé à l’aide de pip sera installé dans votre dossier env virtuel, et non à l’échelle du système.

Pour quitter l’environnement virtuel, utilisez deactivate :

(<env-folder>) $ deactivate

Alternativement : utilisez virtualenvwrapper

Vous pouvez également envisager d’utiliser [virtualenvwrapper] [1] qui rend la création et l’activation de virtualenv très pratiques tout en les séparant de votre code :

# Create a virtualenv
mkvirtualenv my_virtualenv

# Activate a virtualenv
workon my_virtualenv

# Deactivate the current virtualenv
deactivate

Alternativement : utilisez pyenv + pyenv-viritualenv

Dans les environnements où vous devez gérer plusieurs versions de Python, vous pouvez bénéficier de virtualenv avec pyenv-virtualenv :

# Create a virtualenv for specific Python version
pyenv virtualenv 2.7.10 my-virtual-env-2.7.10

# Create a vritualenv for active python verion
pyenv virtualenv venv34

# Activate, deactivate virtualenv
pyenv activate <name>
pyenv deactivate

Lorsque vous utilisez virtualenvs, il est souvent utile de définir votre PYTHONPATH et DJANGO_SETTINGS_MODULE dans le [postactivate script][2].

#!/bin/sh
# This hook is sourced after this virtualenv is activated

# Set PYTHONPATH to isolate the virtualenv so that only modules installed
# in the virtualenv are available
export PYTHONPATH="/home/me/path/to/your/project_root:$VIRTUAL_ENV/lib/python3.4"

# Set DJANGO_SETTINGS_MODULE if you don't use the default `myproject.settings`
# or if you use `django-admin` rather than `manage.py`
export DJANGO_SETTINGS_MODULE="myproject.settings.dev"

Définissez votre chemin de projet

Il est également souvent utile de définir le chemin de votre projet dans un fichier .project spécial situé dans votre <env-folder> de base. Ce faisant, chaque fois que vous activez votre environnement virtuel, il changera le répertoire actif au chemin spécifié.

Créez un nouveau fichier appelé <env-folder>/.project. Le contenu du fichier doit UNIQUEMENT être le chemin du répertoire du projet.

/path/to/project/directory

Maintenant, lancez votre environnement virtuel (soit en utilisant source <env-folder>/bin/activate ou workon my_virtualenv) et votre terminal changera de répertoire en /path/to/project/directory.

[1] : http://virtualenvwrapper.readthedocs.io/ [2] : http://virtualenvwrapper.readthedocs.io/en/latest/scripts.html#postactivate

Concepts Django

django-admin est un outil en ligne de commande livré avec Django. Il est livré avec [plusieurs commandes utiles] [1] pour démarrer et gérer un projet Django. La commande est la même que ./manage.py , à la différence que vous n’avez pas besoin d’être dans le répertoire du projet. La variable d’environnement DJANGO_SETTINGS_MODULE doit être définie.

Un projet Django est une base de code Python qui contient un fichier de paramètres Django. Un projet peut être créé par l’administrateur Django via la commande [django-admin startproject NAME][2]. Le projet a généralement un fichier appelé manage.py au niveau supérieur et un fichier d’URL racine appelé urls.py. manage.py est une version spécifique au projet de django-admin et vous permet d’exécuter des commandes de gestion sur ce projet. Par exemple, pour exécuter votre projet localement, utilisez python manage.py runserver. Un projet est composé d’applications Django.

Une application Django est un package Python qui contient un fichier de modèles (models.py par défaut) et d’autres fichiers tels que des URL et des vues spécifiques à l’application. Une application peut être créée via la commande [django-admin startapp NAME][3] (cette commande doit être exécutée depuis le répertoire de votre projet). Pour qu’une application fasse partie d’un projet, elle doit être incluse dans la liste [INSTALLED_APPS][4] dans settings.py. Si vous avez utilisé la configuration standard, Django est livré avec plusieurs applications de ses propres applications préinstallées qui géreront des choses comme [authentification][5] pour vous. Les applications peuvent être utilisées dans plusieurs projets Django.

Django ORM collecte tous les modèles de base de données définis dans models.py et crée des tables de base de données basées sur ces classes de modèles. Pour ce faire, commencez par configurer votre base de données en modifiant le paramètre [DATABASES][6] dans settings.py. Ensuite, une fois que vous avez défini vos [modèles de base de données][7], exécutez [python manage.py makemigrations][8] suivi de [python manage.py migrate][9] pour créer ou mettre à jour le schéma de votre base de données. sur vos modèles.

[1] : https://docs.djangoproject.com/en/stable/ref/django-admin/ [2] : https://docs.djangoproject.com/en/stable/ref/django-admin/#startproject [3] : https://docs.djangoproject.com/en/stable/ref/django-admin/#startapp [4] : https://docs.djangoproject.com/en/stable/ref/settings/#installed-apps [5] : https://docs.djangoproject.com/en/stable/topics/auth/ [6] : https://docs.djangoproject.com/en/stable/ref/settings/#databases [7] : https://docs.djangoproject.com/en/stable/topics/db/models/ [8] : https://docs.djangoproject.com/en/stable/ref/django-admin/#makemigrations [9] : https://docs.djangoproject.com/en/stable/ref/django-admin/#migrate

Exemple de fichier unique Hello World

Cet exemple vous montre une manière minimale de créer une page Hello World dans Django. Cela vous aidera à réaliser que la commande django-admin startproject example crée essentiellement un tas de dossiers et de fichiers et que vous n’avez pas nécessairement besoin de cette structure pour exécuter votre projet.

  1. Créez un fichier appelé file.py.

  2. Copiez et collez le code suivant dans ce fichier.

     import sys
    
     from django.conf import settings
    
     settings.configure(
         DEBUG=True,
         SECRET_KEY='thisisthesecretkey',
         ROOT_URLCONF=__name__,
         MIDDLEWARE_CLASSES=(
             'django.middleware.common.CommonMiddleware',
             'django.middleware.csrf.CsrfViewMiddleware',
             'django.middleware.clickjacking.XFrameOptionsMiddleware',
         ),
     )
    
     from django.conf.urls import url
     from django.http import HttpResponse
    
     # Your code goes below this line.
    
     def index(request):
         return HttpResponse('Hello, World!')
    
     urlpatterns = [
         url(r'^$', index),
     ]
    
     # Your code goes above this line
    
     if __name__ == "__main__":
         from django.core.management import execute_from_command_line
    
         execute_from_command_line(sys.argv)
    
  3. Accédez au terminal et exécutez le fichier avec cette commande python file.py runserver.

  4. Ouvrez votre navigateur et accédez à [127.0.0.1:8000][1].

[1] : http://127.0.0.1:8000

Un exemple complet de hello world.

Étape 1 Si Django est déjà installé, vous pouvez ignorer cette étape.

pip install Django

Étape 2 Créer un nouveau projet

django-admin startproject hello

Cela créera un dossier nommé hello qui contiendra les fichiers suivants :

hello/
├── hello/
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
└── manage.py

Étape 3 Dans le module hello (le dossier contenant __init.py__), créez un fichier appelé views.py :

hello/
├── hello/
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   ├── views.py  <- here
│   └── wsgi.py
└── manage.py

et mettez le contenu suivant :

from django.http import HttpResponse

def hello(request):
    return HttpResponse('Hello, World')

C’est ce qu’on appelle une fonction de visualisation.

Étape 4 Modifiez hello/urls.py comme suit :

from django.conf.urls import url
from django.contrib import admin
from hello import views

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^$', views.hello)
]

qui lie la fonction de vue hello() à une URL.

Étape 5 Démarrez le serveur.

python manage.py runserver

Étape 6

Accédez à http://localhost:8000/ dans un navigateur et vous verrez :

Bonjour, Monde

Projet convivial pour le déploiement avec prise en charge de Docker.

Le modèle de projet Django par défaut est correct, mais une fois que vous arrivez à déployer votre code et que, par exemple, les devops mettent la main sur le projet, les choses deviennent désordonnées. Ce que vous pouvez faire, c’est séparer votre code source du reste qui doit se trouver 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 service nommé service pour chaque projet grâce au fait 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 : https://www.wikiod.com/fr/django/reglages#Utilisation de plusieurs fichiers d’exigences https://www.wikiod.com/fr/django/reglages#Utilisation de plusieurs paramètres

Dockerfile

En partant du principe que seuls les développeurs utilisent Docker (tous les développeurs ne lui font pas confiance de nos jours). Cela pourrait être un environnement de développement 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 uniquement d’exigences tirera parti du cache Docker lors de la construction - vous n’avez qu’à reconstruire en cas de modification des 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, j’aime donc utiliser Nginx dès le départ. 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/;
    }
}

Utilisation

$ 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