Pré-requis

• Une machine locale ou une vm sous ubuntu 20.04 ou équivalent (xubuntu 20.04 dans l’exemple)

Présentation de virtualenv

Virtualenv est un utilitaire permettant d’isoler vos projets python3 les uns des autres. Le but est d’activer un environnement virtuel différent pour chacun de vos projets afin d’y installer vos dépendances nécessaires (par exemple Django si vous faites un projet Django). Les dépendances sont comme vous le savez peut être installé par pip, le gestionnaire de dépendances Pyhton.

Résumé des étapes d’installation

Comme évoqué dans l’article sur l’environnement pour un projet Django, les étapes d’installation sont les suivantes pour une machine sous Ubuntu 20.04 :

sudo apt install python3-pip
pip3 install virtualenv

A partir de ce moment là vous devriez avoir accès à la commande virtualenv, malheureusement dans certains cas cela ne fonctionne pas est vous obtenez le message d’erreur suivant :

$ virtualenv venv3
Command 'virtualenv' not found, but can be installed with:
sudo apt install python3-virtualenv

A ce moment là il ne faut pas faire sudo apt install python3-virtualenv mais ajouter le chemin /home/USER/.local/bin dans votre variable d’environnement PATH dans votre fichier ~/.bashrc par exemple en fin de ce fichier insérer la ligne suivante en remplaçant USER par votre utilisateur Unix :

PATH="$PATH:/home/USER/.local/bin"

A partir de ce point il vous faut prendre en compte la modification réalisée ci-dessus. Pour cela il faut sourcer le fichier ~/.bashrc, soit en fermant et ouvrant de nouveau tous vos terminaux, soit en lançant la commande suivante : source ~/.bashrc

Vous devriez maintenant avoir accès à la commande comme ceci pour créer un environnement nommé venv3 :

$ virtualenv venv3
created virtual environment CPython3.8.2.final.0-64 in 919ms
creator CPython3Posix(dest=****/venv3, clear=False, global=False)
seeder FromAppData(download=False, pip=bundle, setuptools=bundle, wheel=bundle, via=copy, app_data_dir=***.local/share/virtualenv)
added seed packages: pip==20.1.1, setuptools==49.2.0, wheel==0.34.2
activators BashActivator,CShellActivator,FishActivator,PowerShellActivator,PythonActivator,XonshActivator

Si tout c’est bien passé vous devriez avoir un dossier venv3 créé dans votre dossier courant. Pour activer l’environnement il ne vous reste plus qu’à faire source venv3/bin/activate et devant votre prompt habituel vous devriez voir apparaître (venv3).

Dans le cas où vous avez fait sudo apt install python3-virtualenv, pas de panique vous pouvez avoir le message d’erreur suivant :

$ virtualenv venv3
ModuleNotFoundError: No module named 'virtualenv.seed.embed.via_app_data'

Dans ce cas faites sudo apt remove python3-virtualenv
Ensuite ajouter le chemin /home/USER/.local/bin dans votre variable d’environnement PATH dans votre fichier ~/.bashrc par exemple en fin de ce fichier insérer la ligne suivante en remplaçant USER par votre utilisateur Unix :

PATH="$PATH:/home/USER/.local/bin"

Prenons en compte le changement, soit en fermant et ouvrant de nouveau tous vos terminaux, soit en lançant la commande suivante : source ~/.bashrc

Vérifions que tout est de nouveau opérationnel en lançant la commande :

$ virtualenv venv3
created virtual environment CPython3.8.2.final.0-64 in 919ms
creator CPython3Posix(dest=****/venv3, clear=False, global=False)
seeder FromAppData(download=False, pip=bundle, setuptools=bundle, wheel=bundle, via=copy, app_data_dir=***.local/share/virtualenv)
added seed packages: pip==20.1.1, setuptools==49.2.0, wheel==0.34.2
activators BashActivator,CShellActivator,FishActivator,PowerShellActivator,PythonActivator,XonshActivator

De même, un dossier venv3 sera créé dans votre dossier courant. Pour activer l’environnement virtuel comme précédemment taper source venv3/bin/activate et il apparaîtra devant votre prompt habituel le contenu (venv3).

Voici pour un petit résumé des erreurs potentielles assez courante sur l’installation de virtualenv, pour information les indications donné dans cet article apparaîsse lorsque la commande pip3 install virtualenv se termine mais il n’est pas rare d’aller un peu vite et de ne pas faire attention aux indications donner par le retour de cette commande d’installation.

Pour la suite n’hésitez pas à tester le tutoriel sur un projet Django qui permet de voir quelques aspects de la mise en place de cette technologie.

Image par Falkenpost de Pixabay

Les symptômes

Ces derniers temps j’ai pas mal (pour pas dire beaucoup) travaillé sur mes machines virtuelles j’en ai créées, supprimées, dupliquées à partir de snapshot, … Et il arrive toujours un moment où on se mélange un peu les pinceaux entre les 5 vms Ubuntu et les 3 debian sans parler de la lubuntu et on se dit mais ça je suis sûr ça a marché il y a quelques semaines mais sur quelle vm et comment ? Le ça représente quelque chose d’assez simple, le but est d’accéder à une application django tournant en serveur de développement sur un système invité depuis le navigateur du système hôte. Trop facile vous dîtes, attendez la suite.

Par défaut sur un projet django, lorsque l’on lance la commande ./manage.py runserver, le serveur de développement se lance sur http://127.0.0.1:8000, ok classique pour un serveur de développement local, pas surpris. Ayant aisément fait une redirection de port dans virtualbox pour rediriger le port 2222 de la machine hôte vers le port 22 de la machine invitée, je pars la fleur au fusil faire une redirection tcp du port 8080 de la machine hôte vers le port 8000 de la machine invité, je prends mon plus beau navigateur et je tape dans ce dernier http://127.0.0.1:8080 et là ça ne marche pas (sinon j’écrirais pas cet article ).

La première solution mais pas la bonne à mon goût

Après avoir cherché vraiment longtemps, je me dis ce n’est pas grave on a une connexion ssh on peut donc tout faire passer par là avec un joli tunnel ssh (redirection de port à travers ssh et non plus virtualbox) comme ceci : ssh -L 8080:localhost:8000 user@localhost -p 2222, un peu d’explication -L pour redirection locale de port, 8080 le port de la machine hôte que j’ai choisi pour accéder à la machine distante (ici une machine invitée dans virtualbox). Localhost:8000, représente ici le localhost et le port de la machine sur laquelle la connexion ssh va s’opérer, ici cela représente donc bien le 127.0.0.1:8000 de base du serveur django. Enfin user@localhost -p 2222 représente la façon dont je me connecte sur la machine distante (ici la machine invitée sous virtualbox) car quand je veux me connecter en ssh sur la machine invitée je lance la commande suivante ssh -p 2222 user@localhost (fonctionnant par une redirection de port virtualbox). Ensuite je prends mon plus beau navigateur et je tape dans ce dernier http://127.0.0.1:8080 et là ça marche super on a dû « hacker » notre propre système sous notre maîtrise toute relative pour pouvoir accéder à une interface web. Enfin au passage ça rappelle de bon moyens de se faire un VPN pas chère ou toutes choses du genre…

La seconde solution, c’est la bonne

Bon le souci de la première solution c’est quelle laisse le doute sur le fait que la redirection de ports en virtualbox ne fonctionnerait que pour le port 22 forcément ce n’est pas possible, j’ai fait de nombreuses recherches sur internet qui m’indiquait le contraire. Ou alors serait-ce mon système hôte Ubuntu dans mon cas, pareil après quelques recherches cette hypothèse et écartée. Le firewall d’ubuntu à coup d’iptables et de ufw je m’aperçoit que non. Cela reste très gênant et enfin je décide d’orienter mes recherches vers django et là je tombe sur ce forum https://ubuntuforums.org/showthread.php?t=2260190 et là je comprends mieux, la redirection de port en tcp du port hôte 8080 vers le port 8000 de la machine invitée fonctionnait parfaitement bien depuis le début mais simplement django n’acceptez que les connexions locales. La solution est trouvée il faut lancer la commande suivante afin que le serveur accepte les connexions non locales ./manage.py runserver 0.0.0.0:8000 (bien évidemment il faut penser à reconfigurer la redirection de ports si vous l’aviez enlevé) et voilà tout fonctionne parfaitement. Le 0.0.0.0 indique dans ce cas toutes les adresses ips de la machine sur toutes ses interfaces réseaux, ce qui est bien plus ouvert que 127.0.0.1 qui lui n’autorisera la connexion que sur la boucle locale (=> localhost), des infos en détails ici : https://www.it-swarm.dev/fr/networking/quelle-est-la-difference-entre-127.0.0.1-et-0.0.0.0/958652984/

Mais alors pourquoi le pont ssh fonctionnait

Et bien simplement parce que lorsque que l’on met en place le pont à travers SSH, la connexion entrante est considérée comme une connexion locale pour django il n’y a pas de traces de la machine hôte pour django seulement pour ssh, une traduction en quelques sortes (souvenez vous le localhost de la machine distante ), tout s’explique et c’est bien mieux ainsi. Conclusion pour développer en python – django depuis une vm virtualbox et avoir le navigateur sur la machine hôte, il faut prendre le réflexe de lancer le serveur avec l’ip 0.0.0.0 plutôt que de laisser celle par défaut. Bon on peut faire autrement mais je vous en parlerais dans un prochain article où je vous donnerais un petit bonus patience…

Image par xresch de Pixabay

Les pré-requis

• Un poste de développement avec Ubuntu 20.04 installé
• Un projet Python3 Django opérationnel pour le tutoriel nous utiliserons le projet suivant : https://gitlab.com/julienanne/django-deploy-production-example

Installation des éléments nécessaires pour Python 3

Ubuntu 20.04 de son nom Focal Fossa est livré avec la version 3.8.2 de python sur la commande python3, cependant il nous faut installer pip, le gestionnaire de paquets Python ainsi que git à travers la commande suivante à exécuter en root :

apt install python3-pip git

Vérifions la bonne installation avec les 2 commandes suivantes :

python3 --version
# Python 3.8.2
pip3 --version
# pip 20.0.2 from /usr/lib/python3/dist-packages/pip (python 3.8)
git --version
# git version 2.25.1

Si vous obtenez une sortie similaire, tout c’est bien passé.

Maintenant nous allons installer le paquet pip virtualenv qui permet de séparer les environnements d’exécutions de vos différentes applications Python 3, avec la commande suivante, en tant qu’utilisateur :

pip3 install virtualenv

A ce moment là, il se peut que vous ayez un warning vous indiquant que le script est dans tel dossier et que celui-ci n’est pas dans la variable PATH.

Pour cela il faut éditer le fichier ~/.bashrc et injecter en fin de fichier la ligne suivante : PATH=$PATH:"CHEMIN_INDIQUE_DANS_LE_WARNING"

Puis appliquer les changements de ce fichier .bashrc en lançant la commande : source ~/.bashrc

Récupérons le code source de l’application

Pour cela en tant qu’utilisateur lancer la commande suivante dans votre dossier de travail : git clone https://gitlab.com/julienanne/django-deploy-production-example

Créons un environnement virtuel Pyhton3 pour notre projet Django

Entrer dans le dossier cd django-deploy-production-example/ et lancer la commande suivante en utilisateur afin de créer un environnement :

virtualenv monenv

Nous venons de créer un nouvel environnement pour notre projet il nous faut maintenant l’activer avec la commande :

source ./monenv/bin/activate

Ce qui devrait avoir pour effet de précéder votre prompt de terminal avec (monenv) cela indique que nous sommes dans l’environnement virtuel python3 se nommant « monenv ».

A partir de ce moment là vous n’aurez plus besoin de faire la commande pip3 pour accéder au gestionnaire de paquets Python3 mais simplement pip car virtualenv ayant été installé avec pip3, la commande pip dans un environnement virtualenv représente maintenant pip3.

Installons les dépendances Python de notre application Django

Pour cela rien de plus simple vu que nous avons figé les dépendances avec la méthode présentée dans ce tutoriel nous avons un fichier requirements.txt contenant tous les noms et les versions des packages pip à installer, il ne nous reste donc qu’à taper la commande suivante à la racine du projet en utilisateur :

pip install -r requirements.txt

Et vous verrez les différents packages s’installer automatiquement. Pour vérifier un petit pip list vous permettra de visualiser le résultat.

S’il n’y a pas de fichier requirements.txt dans votre projet il vous faut aller sur l’environnement où a été créé le projet afin de retrouver toutes les dépendances nécessaires ou suivre les différentes erreurs que vous trouverez lors de vos tests (c’est beaucoup moins marrant).

Lançons notre application afin de vérifier que tout est opérationnel

Pour lancer notre application rien de plus simple, il faut exécuter la commande suivante à la racine du projet : ./manage.py runserver

Pour vérifier que tout est ok il faut se rendre à l’url http://127.0.0.1:8000/, vous devriez voir le texte « Hello, world …. »

Ok donc à ce moment là nous avons un projet qui tourne sur notre poste de développement, vous pouvez donc maintenant le faire évoluer… Passons à la suite. Rendez-vous sur le sommaire du tutoriel pour continuer votre lecture.

Image par Jiradet Inrungruang de Pixabay

Les pré-requis

• Un serveur debian 10 installé
• Un serveur web apache2 installé
• Un projet django installé dans le dossier /opt/django-deploy-production-example, pour le tutoriel nous prendrons ce projet : https://gitlab.com/julienanne/django-deploy-production-example avec l’environnement configuré pour ce projet django sous le dossier /opt/django-deploy-production-example/venv
• Un virtualhost sur le port 80 pour notre projet ainsi que toutes les actions déjà réalisées dans l’article « Mise en production de notre projet Django sur une Debian 10 – Apache »
• Un nom de domaine pointant sur l’ip publique de votre serveur

Installons les dépendances nécessaires à Let’s encrypt

Afin de simplifier les commandes toutes les instructions suivantes sont à réaliser avec les droits root.

Pour utiliser Let’s encrypt sur notre serveur nous allons ajouter une source de données pour le gestionnaire de paquets apt, pour cela éditer le fichier /etc/apt/sources.list et ajouter en fin de fichier la ligne suivante :

deb http://ftp.debian.org/debian buster-backports main

Lancer ensuite les 2 commandes suivantes afin de respectivement mettre à jour la liste des paquets disponibles et installer le paquet certbot nécessaire pour simplifier l’installation de certificats Let’s encrypt :

apt update
apt install python-certbot-apache -t buster-backports

Mise en place de notre certificat ssl et particularité avec les instructions WSGI

Un petit point sur le fonctionnement du paquet certbot, afin de ne pas perdre vos configurations initiales, la commande certbot réalise une copie de votre virtualhost (port 80 – http) avant de réaliser des modifications afin de le passer en port 443 – https, ensuite en fonction des réponses que vous fournirez à la commande certbot ce dernier modifiera votre virtualhost (port 80) pour réaliser une redirection automatique vers le port 443 ou non.

Le souci que j’ai rencontré est que certaines directives dans notre virtualhost (port 80) ne peuvent être présentes et actives qu’une seule fois sur la totalité des virtualhosts et les directives WSGI font parties de ces directives, la duplication du virtualhost (port 80) entraîne donc une erreur pour Apache2 si nous ne prenons pas garde avant d’utiliser certbot.

Nettoyage de notre virtualhost (port 80 – http)

Pour nettoyer notre virtualhost (port 80), nous allons dans un premier temps commenter, avec un # en début de ligne, les directives WSGI suivantes : WSGIDaemonProcess, WSGIProcessGroup, WSGIScriptAlias

A partir de ce moment là si vous redémarrez votre apache2, votre application Django ne fonctionnera plus. Ne vous inquiétez pas nous allons remettre cela en ordre rapidement.

Demandons maintenant à certbot de nous générer et installer un certificat SSL

Pour cela rien de plus simple, en root, lancer la commande suivante (attention les crochets sont là seulement pour indiquer que vous pouvez précisez votre nom de domaine avec et sans www si vous souhaitez un certificat pour les 2, dans le cas où vous êtes sur un sous domaine la partie entre crochets et les crochets est à supprimer) :

certbot --apache -d votre_nom_de_domaine [-d www.votre_nom_de_domaine]

Si c’est votre premier certificat généré par certbot vous devrez répondre à quelques questions :

1. Un email de contact
2. A ou D pour indiquer si vous êtes d’accord avec les termes de la licence ou pas (A pour Agree et D pour Disagree)
3. Y ou N pour indiquer si vous désirez partager votre email avec certbot

Enfin dans tous les cas (premier certificat ou non) vous devrez répondre sur le choix de la redirection automatique entre le http et le https, le choix 2 permet cette redirection.

Certbot va ensuite communiquer avec les serveurs de Let’s encrypt afin de générer les certificats demandés et les installer sur votre serveur et les configurer dans votre virtualhost (c’est beau l’automatisation), et tout ceci après avoir certifié que vous possédez bien le nom de domaine mentionné et que ce dernier pointe bien sur votre serveur.

Enfin certbot va recharger les configurations Apache2. Et là c’est le drame votre application n’est plus en ligne, rappelez vous nous avions commenté dans le virtualhost (port 80) les directives WSGI, elles le sont donc aussi dans notre virtualhost (port 443 – https).

Remettons en ligne notre projet Django en https

Nous devons donc maintenant dé-commenter ces 3 directives WSGIDaemonProcess, WSGIProcessGroup, WSGIScriptAlias dans le virtualhost copié puis modifié par certbot, ce virtualhost prend le même nom que votre virtualhot (port 80) suivi de -le-ssl.conf

Ensuite nous pouvons vérifier le bon état de l’art de nos virtualhosts avec : apache2ctl configtest

Si tout est au vert, lancer systemctl restart apache2

Enfin afin de vérifier sans rien modifier la possibilité du renouvellement vous pouvez lancer : certbot renew --dry-run

Pour information vous pouvez retrouver le script de mise à jour automatique du certificat dans le fichier /etc/cron.d/certbot, ce fichier permet de lancer très régulièrement la vérification de la date d’expiration du certificat et ainsi faire le renouvellement du certificat si nécessaire

Parfait nous arrivons au bout de notre tutoriel car nous avons dorénavant un projet Django qui tourne sur un serveur debian 10 avec apache2 et son module WSGI, tout ceci derrière un certificat Let’s encrypt auto-renouvelé. Si vous souhaitez revoir des étapes de ce tutoriel, rendez-vous sur le sommaire du tutoriel pour continuer votre lecture.

Image par Tumisu de Pixabay

Les pré-requis

• Un serveur debian 10 installé
• Un serveur web apache2 installé
• Un projet django installé dans le dossier /opt/django-deploy-production-example, pour le tutoriel nous prendrons ce projet : https://gitlab.com/julienanne/django-deploy-production-example avec l’environnement configuré pour ce projet django sous le dossier /opt/django-deploy-production-example/venv

Configurons le serveur web apache2 pour notre projet Django

Nous avons donc un serveur web apache2 qui est installé sur le serveur, nous allons maintenant créer le virtualhost associé pour rendre accessible notre projet mais avant cela nous avons besoin d’un module spécifique WSGI.

Pour installer ce module rien de plus simple, en root lancer la commande suivante :

apt install libapache2-mod-wsgi-py3

Éditer maintenant un virtualhost /etc/apache2/sites-available/mon-site.conf et mettre les directives suivantes.

<VirtualHost *:80>
# Ne pas mettre cette directive si vous n'avez pas de nom de domaine et que vous accéder à votre serveur par ip
ServerName mon-nom-de-domaine 

# Les 4 lignes suivantes permettent de servir des fichiers dits statiques images, css, js, ...
Alias /static /opt/django-deploy-production-example/static
<Directory /opt/django-deploy-production-example/static>
Require all granted
</Directory>

<Directory /opt/django-deploy-production-example/djangoexample>
<Files wsgi.py>
Require all granted
</Files>
</Directory>

WSGIDaemonProcess djangoexample python-home=/opt/django-deploy-production-example/venv python-path=/opt/django-deploy-production-example
WSGIProcessGroup djangoexample
WSGIScriptAlias / /opt/django-deploy-production-example/djangoexample/wsgi.py
</VirtualHost>

Il nous faut maintenant donner les bons droits sur les dossier pour le groupe www-data

chmod 775 /opt/django-deploy-production-example/
chown :www-data /opt/django-deploy-production-example

Activons maintenant ce nouveau virtualhost avec la commande suivante a2ensite mon-site puis systemctl restart apache2.

Ok donc à ce moment là nous avons un projet qui tourne sur un serveur debian 10 avec apache2 et son module WSGI. Passons à la suite. Rendez-vous sur le sommaire du tutoriel pour continuer votre lecture.

Image par Gerd Altmann de Pixabay

Les pré-requis

• Un poste de développement (ou un serveur) avec MariaDB installé avec une base de données existante vide
• Un projet Django opérationnel sur le poste pour le tutoriel nous utiliserons le projet suivant : https://gitlab.com/julienanne/django-deploy-production-example

Configurons le projet Django avec le connecteur MySql

Pour cela rendez-vous dans le fichier djangoexample/settings.py, la configuration du connecteur de la base de données se trouve dans la variable DATABASES est ressemble à ça par défaut.

DATABASES = {
     'default': {
      'ENGINE': 'django.db.backends.sqlite3',
      'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    }
}

Il faut le remplacer par ceci.

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'OPTIONS': {
            'read_default_file': '/etc/mysql/my.cnf',
        },
    }
}

Quelques explications, déjà nous changeons de connecteur avec le paramètre ENGINE nous allons ici indiquer au connecteur mysql que toutes les informations de connexion seront dans le fichier /etc/mysql/my.cnf via le paramètre OPTIONS.

Éditons maintenant le fichier /etc/mysql/my.cnf et ajouter le contenu suivant à la fin du fichier

[client]
database = NOM_DE_VOTRE_BDD
user = UTILISATEUR_POUR_SE_CONNECTER
password = LEMOTDEPASSE
default-character-set = utf8

Sauver le fichier.

Nous repartons d’une base de données vide il faut donc exécuter les migrations, rendez-vous dans le dossier de votre projet django-deploy-production-example. Et lancer les commandes

./manage.py makemigrations
./manage.py migrate

Ok donc à ce moment là nous avons un projet Django connecté à votre base de données MySql / MariaDB qui tourne. Passons à la suite. Rendez-vous sur le sommaire du tutoriel pour continuer votre lecture.

Image par Johnson Martin de Pixabay

Les pré-requis

• Un poste de développement (ou un serveur) avec python et pip installé
• Un projet python3 opérationnel sur le poste pour le tutoriel nous utiliserons le projet suivant : https://gitlab.com/julienanne/django-deploy-production-example

Figeons les versions des packages pip utilisés

Pour cela rendez-vous via le terminal dans le dossier de votre projet (avec votre environnement activé si vous utilisez virtualenv).

Maintenant nous allons demander à pip de nous afficher la version des différents packages utilisés avec la commande suivante.

pip freeze

La sortie sur votre terminal devrez ressemblez à quelque chose comme cela pour un projet Django sans ajout de dépendances supplémentaires.

asgiref==3.2.7
Django==3.0.6
pytz==2020.1
sqlparse==0.3.1

Nous allons donc maintenant sauvegarder ce résultat dans un fichier communément appelé requirements.txt avec la commande suivante.

pip freeze > requirements.txt

Pensez bien à faire évoluer ce fichier au fur et à mesure de l’ajout de dépendances dans votre projet en exécutant la même commande.

Installons les versions des packages précédemment figés

Vous pouvez installer les dépendances de packages pip dans un nouvel environnement que ce soit sur un serveur ou sur le poste d’un collègue via la commande suivante.

pip install -r requirements.txt

Ensuite vous pourrez vérifier l’ajout des dépendances avec la commande suivante.

pip list

Ok donc à ce moment là nous avons un projet qui tourne avec une liste de dépendances figées afin de pouvoir installer de nouveau le projet dans un autre environnement. Passons à la suite. Rendez-vous sur le sommaire du tutoriel pour continuer votre lecture.

Image par Pexels de Pixabay

Les pré-requis

• Un serveur debian 10 installé (en vm ou chez un hébergeur) avec une connexion ssh opérationnel et les droits root
• Un projet Django que vous avez récupéré et uploadé sur le serveur dans le dossier /opt/django-deploy-production-example, pour le tutoriel nous prendrons ce projet : https://gitlab.com/julienanne/django-deploy-production-example

Installation des éléments nécessaires

Pour plus de simplicité toutes les commandes seront exécutées en tant qu’utilisateur root bien évidemment vous pouvez les exécuter à travers sudo si vous n’avez pas accès à l’utilisateur root.

Commençons par installer pip pour Python3 et ensuite le package virtualenv qui va nous permettre d’isoler pour chaque projet python un environnement spécifique.

apt install python3-pip
pip3 install virtualenv

Mise en place de l’environnement python

Maintenant rendons nous dans le dossier /opt/django-deploy-production-example pour créer et activer l’environnement du projet.

cd /opt/django-deploy-production-example
virtualenv venv
source venv/bin/activate

et pour vérifier que l’environnement est bien activé, vous devez voir le nom de l’environnement ici venv devant le prompt et vous pouvez aussi tapez pip list cette liste devrait être peu fournie mais bien présente. Maintenant installons les packages qui sont en dépendances (la liste est dans le fichier requirements.txt) et notamment Django avec la commande suivante.

pip install -r requirements.txt

Et avec un pip list vous verrez de nouveaux paquets installés.

A partir de là votre projet est opérationnel, vous pouvez le voir en lançant la commande suivante.

./manage.py runserver

Cela va lancé le serveur interne de django prévu pour le développement sur le port 8000, à vous maintenant de vous rendre sur l’url suivante http://IP_SERVEUR:8000 et vérifier que vous obtenez bien la page d’accueil, dans notre cas le contenu est

Hello, world 
Welcome to your first django application in production mode

Vous pouvez aussi vérifier que le super utilisateur est bien présent en vous rendant sur l’url suivante http://IP_SERVEUR:8000/admin/ le login est admin et le mot de passe adminadmin

Ok donc à ce moment là nous avons un projet qui tourne avec une base sqlite3 et en mode standalone. Passons à la suite. Rendez-vous sur le sommaire du tutoriel pour continuer votre lecture.

Image par Brian Ego de Pixabay

Sur ce premier article de la série, nous allons principalement retrouver les pré-requis avant de se lancer et le sommaire pointant sur chaque partie individuelle de ce tutoriel, ainsi qu’une courte description pour chaque partie. Les différentes parties de ce tutoriel sortiront au fur et à mesure, en commençant par les parties à plus fortes valeurs ajoutées pour les parties en constructions j’essaierai de trouver un tutoriel déjà présent sur Internet.

Les pré-requis

Il va nous falloir différents éléments pour mener à bien ce tutoriel :

• Un serveur avec une debian 10 installée, ou une vm où installer Debian 10 (https://www.it-connect.fr/installation-debian-10-buster-pas-a-pas/ tutoriel non testé)
• Un projet Django opérationnel et « stocké » sur Gitlab (Pour le tutoriel nous allons prendre ce projet https://gitlab.com/julienanne/django-deploy-production-example)

Sommaire

• Récupération du code source depuis Gitlab, dans ce tutoriel nous travaillerons avec un projet en public la récupération est donc faisable sans authentification. Pour des projets privés un article arrivera par la suite, en attendant voici la documentation pour ajouter une clé ssh à votre compte Gitlab et ainsi pouvoir s’authentifier à travers le protocole ssh : https://docs.gitlab.com/ee/ssh/, pour le moment un git clone https://gitlab.com/julienanne/django-deploy-production-example vous permettra de récupérer le code source pour la suite du tutoriel
• Installer le projet Django en local pour le faire évoluer
• Figer les dépendances (packages pip) de notre projet python Django pour les installer sur notre serveur de production
• Mise en place de l’environnement pour le projet django, dans cette partie du tutoriel nous allons voir comment à partir des sources du projets nous pouvons installer les dépendances nécessaires
• Installation de Maria DB sur le serveur debian 10 et création de la base de données de votre projet
• Configuration du projet Django avec un connecteur MySql
• Installation d’Apache2
• Installation du module WSGI et configuration
• Installation nécessaire pour Let’s encrypt puis génération et mise en place du certificat SSL et enfin renouvellement automatique

Chaque partie est indépendante mais le tout fera un tutoriel assez complet. Bonne lecture.

Image par Claire05 de Pixabay