• 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

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/

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

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