• 20 hours
  • Medium

Free online content available in this course.

course.header.alt.is_video

course.header.alt.is_certifying

Got it!

Last updated on 12/12/19

Déployez une application sur Heroku

Log in or subscribe for free to enjoy all this course has to offer!

Cette fois-ci, tout est vraiment prêt ! La plateforme inclut toutes les fonctionnalités désirées par le client, l'interface d'administration est configurée et les tests sont écrits.

Il ne reste plus qu'à rendre votre site public. Autrement dit, à le mettre sur Internet !

La mise en production se déroulera sur les serveurs d'Heroku, une plateforme en tant que service qui est gratuite pour les petits projets et très simple à configurer. Heroku se base sur le contenu de votre projet pour configurer les serveurs. Vous aurez très peu de manipulations à réaliser, vous verrez !

Préparation de la mise en production

Changement de la configuration

Avant d'envoyer l'application sur le serveur, vous devez en changer la configuration. Rien de très long mais il est important de le faire ! Voici les différents éléments que nous verrons ensemble :

  • désactiver le mode debug

  • générer une clé secrète pour la production

  • indiquer le nom de domaine

Commencez par désactiver le mode debug :

disquaire_project/settings.py

# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = False

Chaque environnement de développement est totalement distinct car il correspond à un ordinateur différent. Il est donc assez courant d'enregistrer des variables spécifiques à chaque environnement. Par exemple, vous pouvez associer la variable DEBUG à True en local et à False en production. Vous êtes alors sûr que vous n'oublierez jamais de désactiver le mode debug.

Nous les appelons des variables d'environnement. Il s'agit simplement d'une variable globale à laquelle vous avez accès dans tous les scripts d'un ordinateur.

Faisons cela ! Mais au lieu de créer la variable DEBUG, créez la variable ENV à laquelle vous associerez le nom de l'environnement. S'il est égal à PRODUCTION, dans ce cas le mode debug sera inactif. Sinon, il sera activé.

settings.py

# SECURITY WARNING: don't run with debug turned on in production!
if os.environ.get('ENV') == 'PRODUCTION':
    DEBUG = False
else:
    DEBUG = True

Il est également essentiel de changer la clé secrète car, comme son nom l'indique, elle ne doit pas être divulguée. Elle est notamment utilisée pour générer le jeton CSRF dont nous avons parlé dans la partie consacrée aux formulaires. Elle ne doit donc pas être publique ! Une bonne pratique consiste à avoir une clé secrète différente en développement et en production.

settings.py

SECRET_KEY = os.environ.get('SECRET_KEY', 'c@n%u@91tum=@j392g20b8znh7dqfo-v%81))gxbbmu$=dy_*)') # development key for the moment

Générez une nouvelle clé secrète en ouvrant une console Python :

$ python
>>> import random, string
>>> "".join([random.choice(string.printable) for _ in range(24)])
'-~aO;| F;rE[??/w^zcumh(9'

Copiez la clé et collez-la dans un endroit où vous pourrez la retrouver ultérieurement. En effet, pour l'instant l'environnement de production n'est pas configuré donc vous ne pouvez pas l'y enregistrer !

Le réglage suivant concerne le nom de domaine. Heroku héberge gratuitement votre application et l'associe à un nom de domaine. Ce dernier est de la forme suivante : nomdevotreapplication.herokuapp.com. L'adresse est générée automatiquement lors de la création de l'application.

La constante ALLOWED_HOSTS contient les adresses autorisées à communiquer avec votre application. Sous forme de liste, elle vous permet d'en indiquer plusieurs. Pour en savoir plus, lisez la documentation.

Choisissez un nom d'application et ajoutez l'URL correspondante dans la configuration :

settings.py

ALLOWED_HOSTS = ['disquaire.herokuapp.com']

Préparation des fichiers statiques

En développement, les fichiers statiques ne demandent pas une grande configuration. La preuve : vous les avez placés dans le dossier static et ils s'affichent bien. Sous le capot, Django réunit tous les fichiers statiques de toutes les applications et les met à disposition.

Néanmoins c'est loin d'être efficace car, en production, ces fichiers ne changent pas. Il est donc logique de les réunir en amont avant d'envoyer le projet sur le serveur. Cela est réalisé grâce à quelques réglages supplémentaires et à la commande magique manage.py collectstatic. C'est parti !

Commencez par créer un répertoire static dans le dossier du projet.

$ mkdir disquaire_project/static

Puis ajoutez les lignes suivantes :

settings.py

if os.environ.get('ENV') == 'PRODUCTION':

    # Static files settings
    PROJECT_ROOT = os.path.dirname(os.path.abspath(__file__))

    STATIC_ROOT = os.path.join(PROJECT_ROOT, 'staticfiles')

    # Extra places for collectstatic to find static files.
    STATICFILES_DIRS = (
        os.path.join(PROJECT_ROOT, 'static'),
    )

Enfin, vous devez installer une librairie pour rendre les fichiers statiques accessibles en production : WhiteNoise. Elle est disponible sur PyPI :

$ pip install whitenoise

Mettez de nouveau à jour le fichier de configuration pour indiquer que l'application utilise WhiteNoise :

    MIDDLEWARE = [
        # ...
        'django.middleware.security.SecurityMiddleware',
        'whitenoise.middleware.WhiteNoiseMiddleware',
        # ...
    ]

    if os.environ.get('ENV') == 'PRODUCTION':
        # ...
        # Simplified static file serving.
        # https://warehouse.python.org/project/whitenoise/
        STATICFILES_STORAGE = 'whitenoise.storage.CompressedManifestStaticFilesStorage'

Export de la base de données

La base de données actuelle peut être utilisée en production. Il est donc intéressant de l'exporter pour l'importer plus tard sur le serveur.

Créez un nouveau dossier dans l'application store, dumps, pour regrouper les exports.

Exécutez la commande suivante pour exporter la base de données dans le fichier store.json : manage.py dumpdata > store.json. Afin d'exporter exclusivement le contenu en lien avec l'application store (les albums, les artistes, ...) et non les autres tables, spécifiez son nom :

$ ./manage.py dumpdata store > store/dumps/store.json

Nous verrons plus tard comment l'importer sur le serveur.

Lorsqu'un projet Django est détecté, Heroku crée une base de données et enregistre le chemin vers celle-ci dans une variable d'environnement. Il ressemble à celui-ci :

postgres://ajmwflxktovfnn:pleindechiffresetdelettres@ec2-23-23-86-179.compute-1.amazonaws.com:5432/d7ki8hbemu00vg

Afin de pouvoir l'utiliser efficacement, il est nécessaire d'installer une dernière librairie : Database URL. Elle est également disponible sur PyPI :

$ pip install dj-database-url

Modifiez le fichier de configuration comme suit :

settings.py

import dj_database_url

# ...
if os.environ.get('ENV') == 'PRODUCTION':
    # ...
    db_from_env = dj_database_url.config(conn_max_age=500)
    DATABASES['default'].update(db_from_env)

Fichiers nécessaires pour Heroku

Heroku lit deux fichiers pour configurer l'environnement de production :

  • Procfile : contient les instructions pour démarrer l'application.

  • requirements.txt : contient les librairies nécessaires pour que le projet fonctionne.

Créez un nouveau document au même niveau que store et intitulé "Procfile". Ajoutez-y la ligne suivante :

Procfile

web: gunicorn disquaire_project.wsgi

Cette ligne contient la commande à exécuter par Heroku pour tout lancement de l'application. Elle dit : "lance gunicorn et lis le fichier disquaire_project.wsgi pour en connaître la configuration".

Il faut également installer Gunicorn, un serveur web plus efficace en production :

$ pip install gunicorn

Enfin, utilisez PIP pour générer le fichier requirements.txt en tapant la commande suivante :

$ pip freeze > requirements.txt

Tout est en place ! L'application est fin prête pour la production.

Création d'un nouveau projet sur Heroku

Si vous n'en avez pas déjà un, créez-vous un compte sur la page d'accueil d'Heroku. Puis rendez-vous sur le tableau de bord.

Ce dernier affiche la liste de vos applications. Pour le moment vous n'en avez aucune mais, patience, bientôt vous verrez une nouvelle ligne apparaître.

Installez Heroku CLI (Command Line Interface), l'outil en ligne de commande qui vous permet d'interagir avec les serveurs d'Heroku directement dans votre console.

Suivi du projet avec Git

Heroku utilise intensément Git, un logiciel de suivi de version. Si ce n'est pas déjà fait, démarrez le suivi en tapant git init.

env/
disquaire_project/__pycache__
store/__pycache__/
store/migrations/__pycache__/

Vérifiez les fichiers actuellement surveillés :

$ git status

Puis ajoutez les fichiers au prochain envoi :

$ git add nomdufichier
$ git commit -m "launching to production"

Création d'une nouvelle application

C'est très simple ! Tapez simplement la commande heroku create nom-de-votre-application. Par exemple :

$ heroku create disquaire
Creating ⬢ disquaire... done

Puis vous allez enregistrer les variables d'environnement. Mais si, souvenez-vous, nous en avons parlé au début de ce chapitre ! Reprenez la clé secrète et ajoutez-la dans les variables d'environnement en utilisant la commande heroku config:set :

$ heroku config:set SECRET_KEY="c@n%u@91tum=@j392g20b8znh7dqfo-v%81))gxbbmu$=dy_*)"

Faites-en de même pour la variable ENV :

$ heroku config:set ENV=PRODUCTION

Puis vérifiez que tout a bien été enregistré en tapant la commande heroku config :

$ heroku config
=== disquaire Config Vars
ENV:        PRODUCTION
SECRET_KEY: -~aO;| F;rE[??/w^zcumh(9

C'est terminé ! Envoyez à présent les fichiers sur le serveur en tapant la commande git push heroku master :

$ git push heroku master
remote: Compressing source files... done.
remote: Building source:
remote:
remote: -----> Python app detected
...
remote: -----> $ python manage.py collectstatic --noinput
remote:        94 static files copied to '/tmp/build_f8b69629a4673e7660382b04f75e8f61/disquaire_project/staticfiles', 106 post-processed.
remote:
remote: -----> Discovering process types
remote:        Procfile declares types -> web
remote:
remote: -----> Compressing...
remote:        Done: 54.7M
remote: -----> Launching...
remote:        Released v6
remote:        https://disquaire.herokuapp.com/ deployed to Heroku
remote:
remote: Verifying deploy... done.
To https://git.heroku.com/disquaire.git
 * [new branch]      master -> master

Finir la mise en production

Vous n'êtes plus qu'à quelques étapes de l'arrivée ! Il reste à lancer les migrations sur le serveur, à créer un administrateur et à importer la base de données. C'est parti !

Afin de lancer une commande sur les serveurs d'Heroku, préfixez-la simplement de heroku run. Comme ceci :

$ heroku run python manage.py migrate
Running python manage.py createsuperuser on ⬢ disquaire... up, run.4846 (Free)
Operations to perform:
Apply all migrations: admin, auth, contenttypes, sessions, store


$ heroku run python manage.py createsuperuser
Running python manage.py createsuperuser on ⬢ disquaire... up, run.8612 (Free)
Username (leave blank to use 'u17604'): freddie
Email address: freddie@forever.com
Password:
Password (again):
Superuser created successfully.

Enfin, importez la base de données :

$ heroku run python manage.py loaddata store/dumps/store.json
Running python manage.py loaddata store/dumps/store.json on ⬢ disquaire... up, run.1002 (Free)
Installed 46 object(s) from 1 fixture(s)

Naviguez alors sur le site et constatez qu'il fonctionne !

Code de ce chapitre

Retrouvez l'intégralité du code sur ce dépôt GitHub.

Example of certificate of achievement
Example of certificate of achievement