Fonctionnalités

• développement rapide d’applications web complexes.
• suppression les tâches rébarbatives et répétitives.
• assure des applications sécurisés et faciles à maintenir.
• supporte les opérations de caches et de bases de données.
• couvre à la fois le front end et le back end de l'application.
  • back end: gestion base de données côté serveur (Administration Django ORM).
  • front end: interface utilisateur (html, css, javascript).

Pour mémoire

• Date de création 2000
• Open source depuis 2005
• Framework web le plus utilisé dans le monde
  • Instagram
  • Spotify
  • Washington Post
  • DropBox
  • Mozilla
  • YouTube
  • Pinterest
  • National Geographic

Architecture MVT, (Model-View-Template)

• Model: le modèle définit la structure et la gestion de la base de données
  • Django ORM (Object Relational Mapping)
  • Modèles de données définis par des classes Python
• View: une vue reçoit les requêtes HTTP et renvoie les réponses HTTP.
  • accède aux données requises pour satisfaire les requêtes par une fonction ou classe python via les modèles
  • formate la réponse aux templates ou rendu html
• Template
  • interface html ou rendu visuel
  • langage de balisage personnel
  • interfaces dynamiques et interactives

Principe DRY (Don’t Repeat Yourself)

• environnement de travail propre et gérable
• un espace unique pour stocker chaque objet distinct
• supprime les redondances pour se concentrer sur la logique de l'application

Authentification et sécurité

• un système d'authentification utilisateur complet et sécurisé
• comptes d'utilisateurs, groupes d'utilisateurs et sessions
• un système de sécurité de pointe contre les failles de sécurité courantes

DRF (Django REST Framework)

• une boîte à outils de composants pour créer des API RESTFUL
• Une API est une interface permettant d'interagir avec des bases de données.
• Les API RESTFUL sont utilisées pour répertorier, modifier, créer et supprimer des données sur des serveurs Web

Les projets sont organisés suivant une hiérarchie de répertoires et de fichiers organisés en arbre.

Environnement de développement pour Django

Installation des librairies à partir des dépôts ou des sources

• De préférence on utilisera le dépôt PyPi (Packages Python).
• Quand cela est nécessaire, depuis les sources.
• Dans certain cas, le gestionnaire de package du système d'exploitation.
• Enfin en combinant 1, 2, 3

1. Choisir un répertoire pour contenir le projet entier
2. Installer ensuite un environnement python avec au moins le paquet django

Projet Django

.
└── demo
    ├── demo
    │   ├── asgi.py
    │   ├── __init__.py
    │   ├── settings.py
    │   ├── urls.py
    │   └── wsgi.py
    └── manage.py
    

• manage.py: ‣ la boîte à outils de Django
• Un répertoire demo (nom du projet) est l'application principale composée des fichiers suivants:
  • __init__.py: ‣ marque le répertoire comme un paquet python
  • wsgi.py: ‣ module de l'application en mode wsgi
  • asgi.py: ‣ module de l'application en mode asgi
  • urls.py: ‣ module de routage (liens vers les pages)
  • settings.py: ‣ module de configuration de l'application./ma
  • On placera à ce niveau les répertoires suivants:
    • Répertoire static: ‣ (css, image, icon, javascript, webfont, etc ...)
    • Répertoire templates: ‣ (fichiers de gabari généralement en html)

Application Django

.
└── demo
    ├── boutique
    │   ├── admin.py
    │   ├── apps.py
    │   ├── __init__.py
    │   ├── migrations
    │   │   └── __init__.py
    │   ├── models.py
    │   ├── tests.py
    │   └── views.py
    ├── demo
    ...
    └── manage.py
    

• test.py: ‣ module de test
• apps.py: ‣ module de configuration de l'application
• admin.py: ‣ module d'administration de la base de données (back end)
• views.py: ‣ module de traitement des requêtes et des réponses HTTP
• models.py: ‣ module de gestion la gestion de la base de données
• On placera à ce niveau, si besoin, les répertoires suivants:
  • Répertoire static: ‣ (css, image, icon, javascript, webfont, etc ...)
  • Répertoire templates: ‣ (fichiers de gabari généralement en html)
• On placera à ce niveau, en fonction des applications installées les modules:
  • forms.py: ‣ Formulaires de saisie
  • filters.py: ‣ Filtres des requêtes ORM de Django (django-filter)
  • signals.py: ‣ Répartiteur de signaux (récupérer des actions executées ailleurs dans un projet)
  • tasks.py: ‣ Gestionnaire de tâches (django-celery-beat)

Principes pour développer un projet Django

1. Créer l'environnement python dans un répertoire:
   $> python -m venv .venv
2. Démarrer l'environnement python et installer django:
   $> source .venv/bin/python (démarrer l'environnement python)
   (.venv) $> pip install django
3. Le projet est créé avec la commande suivante:
   (.venv) $> django-admin startproject demo
4. Faire une première migration pour créer la base de donées (sqlite3 par défaut):
   (.venv) $> cd demo (se placer dans le répertoire projet)
   (.venv) $> python manage.py migrate
5. Créer le super utilisateur pour l'administration du back end:
   (.venv) $> python manage.py createsuperuser
6. On peut maintenant lancer le serveur de développement:
   (.venv) $> python manage.py runserver
7. Tester les adresse suivantes:
   http://127.0.0.1:8000/admin/ (Administration du back end)
   http://127.0.0.1:8000 (Le site front end)
8. Tout est prêt pour commencer son projet

Prendre un IDE pour éditer le projet

• Spyder + Anaconda (libre)
• Eclipse + pydev (libre)
• Pycharm (libre pour python mais payant pour django
• Visualstudio (libre)

Modifier les variables du projet et adapter le settings.py

1. Par défaut le mode DEBUG = True, on le laisse tel que en mode développement
2. Ajouter boutique dans la liste des applications installées: INSTALLED_APPS

   INSTALLED_APPS = [
       ...
       'boutique',
   ]
               

3. Configurer l'accès à la base de données par défaut c'est sqlite3: DATABASES
4. Configuration du fuseau horaire: TIME_ZONE
5. Changer la langue: LANGUAGE_CODE
6. Paramétrer les fichiers statiques: STATIC_URL et STATICFILES_DIRS
7. Indiquer les dossiers templates: TEMPLATES
8. Indiquer les dossiers média: MEDIA_URL et MEDIA_ROOT

On est prêt pour créer une application et créer une première page

1. (.venv) $> python manage.py startapp boutique (création de l'application boutique)
2. Créer une route vers la page home dans demo/url.py:

   from boutique import views
   urlpatterns = [
       ...
       path('', 'views.home', name='home'),
   [
               

3. Créer une fonction home dans boutique/views:

   def home(request):
       return render(request, 'boutique/home.html')
               

4. Créer la template dans boutique/templates/boutique/home.html:
   (.venv) $> mkdir -p boutique/templates/boutique
   (.venv) $> echo "Bonjour tout le monde" > boutique/templates/boutique/home.html
5. Le rendu de la page home est alors visible en 127.0.0.1:8000

Données

• Exemple création de la table articles dans boutique/models.py:

  class Article(models.Model):
      name = models.CharField("Name", max_length=200, null=True, blank=False)
      #description = models.TextField("Description", null=True, blank=True)
          

• Procéder à la migation à chaque modification ou mise à jour des models.

  (.venv) $> python manage.py makemigrations
  (.venv) $> python manage.py migrate
          

Administration de la base de données

• Il suffit d'enregistrer le modèle dans le module boutique/admin.py

  from boutique import models
  admin.site.register(models.Article)
          

• Le rendu de la page admin est alors visible en 127.0.0.1:8000/admin

Formulaires de saisie

from django import forms
from boutique import models

class ArticleForm(forms.ModelForm):

    class Meta:
        model = models.Article
        fields = ['name', 'description', ]
    

Traitement d'un formulaire

• La route:

  urlpatterns = [
      ...
      path('article/', 'views.article', name='article'),
   ]
          

• La vue:

  ...
  from boutique.forms import ArticleForm
  
  def article(request):
      formulaire = ArticleForm()
      return render(request, 'boutique/article.html', context={'formulaire': ArticleForm()})
          

• La template dans boutique/article.html

  {{ formulaire.as_p }}
          

• Le rendu de la page article est alors visible en 127.0.0.1:8000/article/

• Le minimum pour compiler et installer des libraries python et outils système

  #> apt -y install build-essential git wget curl unzip python3-venv python3-pip
  #> apt -y install libz-dev libjpeg-dev libfreetype6-dev python-dev
  #> apt -y install supervisor nginx redis openssl libnss3-tools ssl-cert
  #> apt -y install certbot python3-certbot-nginx
  #> apt -y install iptables fail2ban
  #> apt -y install sqlite3
              

• On génère la clef dhparam pour compléter la certification

  #> openssl dhparam -out /etc/ssl/certs/dhparam.pem 2048
              

• Créer un utilisateur shop par ex:

  #> adduser shop
  #> adduser shop www-data (ajouter shop au groupe de nginx)
              

  Copier par ftp ou git le projet derrière /home/shop
• On se logue en tant que shop

  #> su - shop
              

  On se retrouve donc en donc /home/shop
  • Comme en mode développement on installe l'environnement python
    (.venv) $> pip install django gunicorn
  • On modifie le settings.py
    DEGUG = False
    ALLOWED_HOSTS = ['127.0.0.1', 'shop.domain.com']
  • Faire la migration pour créer la base de donées (sqlite3 par défaut):
    (.venv) $> python manage.py migrate
  • Créer le super utilisateur pour l'administration du back end:
    (.venv) $> python manage.py createsuperuser
  • Générer les fichiers de type static
    (.venv) $> python manage.py collectstatic
  • Tout est prêt pour lancer l'application

Application synchrone

• Extrait du fichier de configuration de /etc/supervisor/conf.d/demo.conf:

  [program:shop]
  directory = /home/shop
  command=/home/shop/.venv/bin/gunicorn
          --chdir /home/shop/demo
          --bind 127.0.0.1:8000
          --user shop
          --group www-data
          --log-level error
           demo.wsgi:application
  user=root
  stopasgroup=true
  stopsignal=SIGINT
  autostart=true
  autorestart=true
  redirect_stderr=true
  redirect_stdout=true
              

• Configurer l'application dans supervisor

  #> supervisorctl reread
  #> supervisorct update
  	       

• Lancer ou relancer le serveur

  #> supervisorct restart shop
  	       

• Extrait du fichier de configuration de /etc/nginx/sites-enabled/demo.conf

  # virtualhost
  server {
      if ($host = shop.domain.com) {
          return 301 https://$host$request_uri;
      }
      listen                  80;
      listen                  [::]:80;
      server_name             shop.domain.comg;
      return                  https://$host$request_uri;
  }
  
  server {
      listen                  443 ssl http2;
      listen                  [::]:443 ssl http2;
      server_name             shop.domain.com;
  
      set $base_path          /home/shop;
      keepalive_timeout       5;
      client_max_body_size    4G;
  
      access_log              /var/log/nginx/shop.domain.com-access.log;
      error_log               /var/log/nginx/shop.domain.com-error.log;
      ssl_certificate         /etc/letsencrypt/live/shop.domain.com/fullchain.pem;
      ssl_certificate_key     /etc/letsencrypt/live/shop.domain.com/privkey.pem;
      ssl_dhparam             /etc/letsencrypt/ssl-dhparams.pem;
      include                 /etc/letsencrypt/options-ssl-nginx.conf;
  
      set $root_path          $base_path/demo;
      root $root_path;
  
      location /static/ {
          alias $root_path/staticfiles/;
      }
  
      location /media/ {
          alias $root_path/media/;
      }
  
      location /favicon.ico {
          alias $root_path/staticfiles/img/logo.png;
      }
  
      location /robots.txt {
          alias $root_path/staticfiles/robots.txt;
      }
  
      location / {
          include proxy_params;
          proxy_redirect off;
          proxy_http_version 1.1;
          proxy_set_header Upgrade $http_upgrade;
          proxy_set_header Connection "upgrade";
          proxy_pass http://127.0.0.1:8000;
      }
  }
  	       

• Lancer ou relancer le serveur

  #> systemctl restart nginx
             

• L'application est maintenant disponible en https://shop.domain.com

Application asynchrone

INSTALLED_APPS = [
    'daphne',
    ...
    ]
        

• Extrait du fichier de configuration de /etc/supervisor/conf.d/demo.conf

  [program:demo]
  directory = /home/shop
  command=/home/shop/.venv/bin/daphne
          --bind 127.0.0.1
          --port 8000
          --access-log -
          --proxy-headers
           demo.asgi:application
  user=root
  stopasgroup=true
  stopsignal=SIGINT
  autostart=true
  autorestart=true
  redirect_stderr=true
  redirect_stdout=true
              

• Configuration nginx comme synchrone