Django Tutoriel
Démarrer avec Django

Remarques

Versions

Lancer 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 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 avec Django doivent résider dans un projet Django. Vous pouvez utiliser la commande django-admin pour lancer un nouveau projet dans le répertoire actuel:

$ django-admin startproject myproject

où 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 fonctionne, http://127.0.0.1:8000/ vous sur http://127.0.0.1:8000/ avec votre navigateur Web. Vous verrez la page suivante:

Par défaut, la commande runserver démarre le serveur de développement sur l'adresse IP interne du port 8000 . Ce serveur redémarre automatiquement lorsque vous modifiez 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 pour les versions de débogage et les tests locaux. Les programmes de serveur spécialisés (tels qu'Apache) doivent toujours être utilisés en production.

Ajouter une application Django

Un projet Django contient généralement plusieurs apps . Ceci est simplement un moyen de structurer votre projet en modules plus petits et maintenables. Pour créer une application, accédez à votre dossier de projet (où manage.py est) et exécutez la commande startapp (modifiez myapp en fonction de ce que vous voulez):

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 au courant de myapp , ajoutez-le à vos settings.py :

# myproject/settings.py

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

La structure de dossier d'un projet Django peut être modifiée en fonction de 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:

Concepts Django

django-admin est un outil de ligne de commande fourni avec Django. Il est livré avec plusieurs commandes utiles pour démarrer et gérer un projet Django. La commande est la même que ./manage.py , à la différence ./manage.py 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 . Le projet a généralement un fichier appelé manage.py au niveau supérieur et un fichier URL racine appelé urls.py manage.py est une version spécifique à 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 à une application. Une application peut être créée via la commande django-admin startapp NAME (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 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èrent des choses comme l' authentification pour vous. Les applications peuvent être utilisées dans plusieurs projets Django.

L' ORM Django 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 en fonction de ces classes de modèles. Pour ce faire, commencez par configurer votre base de données en modifiant le paramètre DATABASES dans settings.py . Ensuite, une fois que vous avez défini vos modèles de base de données , exécutez les python manage.py makemigrations suivies de python manage.py migrate pour créer ou mettre à jour le schéma de votre base de données en fonction de vos modèles.

Un exemple complet de bonjour au monde.

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

pip install Django

Étape 2 Créer un nouveau projet

django-admin startproject hello

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

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

Etape 3 Dans le module hello (le dossier contenant le __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 mettre dans le contenu suivant:

from django.http import HttpResponse

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

Ceci s'appelle une fonction de vue.

É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

Naviguez jusqu'à http://localhost:8000/ dans un navigateur et vous verrez:

Bonjour le monde

Environnement virtuel

Bien que cela ne soit pas strictement requis, il est fortement recommandé de démarrer votre projet dans un "environnement virtuel". Un environnement virtuel est un conteneur (un répertoire) contenant une version spécifique de Python et un ensemble de modules (dépendances), qui n'interfère pas avec le Python natif du système d'exploitation ni avec 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 gérer 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 aux mêmes fonctionnalités en python3 -m venv directement le module 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 séparé de pip:

$ pip install virtualenv

Et puis créez l'environnement à l'aide de la commande virtualenv place:

$ virtualenv <env-folder>

Activer (n'importe quelle version)

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

Pour "activer" l'environnement virtuel (toute version de Python)

Linux aime:

$ source <env-folder>/bin/activate

Windows comme:

<env-folder>\Scripts\activate.bat

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

A partir de maintenant, tout ce qui est installé à l'aide de pip sera installé dans votre dossier env virtuel, pas à l'échelle du système.

Pour quitter l'environnement virtuel utilisation deactivate :

(<env-folder>) $ deactivate

Sinon, utilisez virtualenvwrapper

Vous pouvez également envisager d'utiliser virtualenvwrapper, ce qui rend la création et l'activation de virtualenv très pratique tout en le séparant de votre code:

# Create a virtualenv
mkvirtualenv my_virtualenv

# Activate a virtualenv
workon my_virtualenv

# Deactivate the current virtualenv
deactivate

Alternativement: utiliser 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

Lors de l'utilisation de virtualenvs, il est souvent utile de définir vos PYTHONPATH et DJANGO_SETTINGS_MODULE dans le script postactivate .

#!/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 le chemin de votre projet

Il est également utile de définir le chemin de votre projet dans un fichier .project spécial situé dans votre <env-folder> . Pour ce faire, chaque fois que vous activez votre environnement virtuel, le répertoire actif est remplacé par le 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 (en utilisant le source <env-folder>/bin/activate ou workon my_virtualenv ) et votre terminal changera de répertoire en /path/to/project/directory .

Exemple de fichier unique Hello World

Cet exemple vous montre un moyen minimal de créer une page Hello World dans Django. Cela vous aidera à réaliser que la commande django-admin startproject example crée fondamentalement 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 .

Projet compatible avec le déploiement avec support Docker.

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