TOC

Comment déployer des applications Web2py Python avec uWSGI et Nginx sur Ubuntu 14.04

introduction

Le framework web2py est un outil puissant et facile à utiliser pour le développement rapide d’applications Web Python complètes. Avec web2py, vous pouvez facilement développer et gérer vos applications grâce à une interface utilisateur Web administrative.

Dans ce guide, nous montrerons comment déployer une application web2py sur Ubuntu 14.04. Nous utiliserons le serveur d’applications uWSGI pour assurer l’interface avec l’application avec plusieurs processus de travail. Devant uWSGI, nous allons configurer Nginx dans une configuration de proxy inverse pour gérer les connexions client réelles. Il s’agit d’une stratégie de déploiement beaucoup plus robuste que l’utilisation du serveur Web2py ou de uWSGI seul.

Prérequis et objectifs

Afin de compléter ce guide, vous devez disposer d’une nouvelle instance de serveur Ubuntu 14.04 avec un utilisateur non root avec les privilèges + sudo + configurés. Vous pouvez apprendre à configurer ceci en parcourant notre initial guide de configuration du serveur.

Nous allons télécharger le framework web2py et le tester pour nous assurer que l’environnement d’application par défaut fonctionne correctement. Ensuite, nous téléchargerons et installerons le conteneur d’application uWSGI pour servir d’interface entre les requêtes et le code web2py Python. Nous allons configurer Nginx devant celui-ci afin qu’il puisse gérer les connexions client et les requêtes proxy à uWSGI. Nous allons configurer chacun de nos composants pour qu’ils démarrent au démarrage afin de minimiser les interventions administratives.

Télécharger le framework web2py

Notre première étape sera de télécharger le framework web2py actuel. Ceci est maintenu dans un référentiel + git + sur GitHub, le meilleur moyen de le télécharger est donc `` + git + `lui-même.

Nous pouvons télécharger et installer + git + à partir des référentiels Ubuntu par défaut en tapant:

sudo apt-get update
sudo apt-get install git

Une fois que + git + est installé, nous pouvons cloner le référentiel dans le répertoire de base de nos utilisateurs. Nous pouvons nommer l’application comme bon nous semble. Dans notre exemple, nous utilisons le nom ++ pour plus de simplicité. Nous devons ajouter l’indicateur + - récursif + car la couche d’abstraction de la base de données est gérée comme son propre sous-module + git +:

git clone --recursive https://github.com/web2py/web2py.git ~/

Le framework web2py sera téléchargé dans un répertoire nommé + myapp + dans votre répertoire personnel.

Nous pouvons tester l’application par défaut en allant dans le répertoire:

cd ~/

L’interface administrative doit être sécurisée par SSL afin que nous puissions créer un simple certificat auto-signé pour le tester. Créez la clé du serveur et le certificat en tapant:

openssl req -x509 -new -newkey rsa:4096 -days 3652 -nodes -keyout .key -out .crt

Vous devrez renseigner certaines informations pour le certificat que vous générez. Le seul élément qui importe réellement dans cette situation est le champ + Common Name +, qui doit référencer le nom de domaine ou l’adresse IP de votre serveur:

. . .

Country Name (2 letter code) [AU]:US
State or Province Name (full name) [Some-State]:New York
Locality Name (eg, city) []:New York City
Organization Name (eg, company) [Internet Widgits Pty Ltd]:DigitalOcean
Organizational Unit Name (eg, section) []:
Common Name (e.g. server FQDN or YOUR name) []:
Email Address []:[email protected]

Lorsque vous avez terminé, une clé SSL et un certificat doivent figurer dans votre répertoire d’application. Celles-ci seront appelées + .key + et + .crt + respectivement.

Une fois cette opération terminée, nous pouvons démarrer l’interface Web web2py pour la tester. Pour ce faire, nous pouvons taper:

python web2py.py -k .key -c .crt -i 0.0.0.0 -p 8000

Vous serez invité à sélectionner un mot de passe pour l’interface administrative.

Maintenant, vous pouvez visiter votre application dans votre navigateur Web en accédant à:

https://:8000

Assurez-vous d’utiliser + https + au lieu de + http + à l’adresse ci-dessus. Vous serez averti que votre navigateur ne reconnaît pas le certificat SSL:

image: https: //assets.digitalocean.com/articles/web2py_uwsgi_nginx_1404/ssl_warning.png [avertissement SSL de web2py]

Ceci est attendu puisque nous avons signé notre propre certificat. Cliquez sur le lien "Avancé" ou sur tout autre lien fourni par votre navigateur, puis accédez au site comme prévu. Vous verrez l’interface web2py:

image: https: //assets.digitalocean.com/articles/web2py_uwsgi_nginx_1404/welcome_app.png [application de bienvenue web2py]

En cliquant sur le bouton «Interface administrative» à l’extrême droite, vous devriez pouvoir saisir le mot de passe que vous avez sélectionné lors de l’exécution du serveur et accéder au site d’administration:

image: https: //assets.digitalocean.com/articles/web2py_uwsgi_nginx_1404/admin_interface.png [interface d’administration web2py]

Cela vous donne accès au code réel qui exécute vos applications, vous permettant d’éditer et de peaufiner les fichiers à partir de l’interface elle-même.

Lorsque vous avez terminé, tapez CTRL-C dans la fenêtre de votre terminal. Nous avons testé notre application et démontré qu’elle était accessible sur le Web lorsque le serveur de développement web2py était en cours d’exécution.

Installer et configurer uWSGI

Maintenant que l’application web2py est opérationnelle, nous pouvons configurer uWSGI. uWSGI est un serveur d’applications pouvant communiquer avec des applications via une interface standard appelée WSGI. Pour en savoir plus à ce sujet, lisez https://www.digitalocean.com/community/tutorials/how-to-set-up-uwsgi-and-nginx-to-serve-python-apps-on-ubuntu-14-04 # définitions-et-concepts [cette section] de notre guide sur la configuration de uWSGI et Nginx sur Ubuntu 14.04.

Installer uWSGI

Contrairement au guide cité ci-dessus, dans ce tutoriel, nous allons installer uWSGI globalement. Avant de pouvoir installer uWSGI, nous devrons installer + pip +, le gestionnaire de paquets Python et les fichiers de développement Python sur lesquels repose uWSGI. Nous pouvons les installer directement à partir des dépôts d’Ubuntu:

sudo apt-get install python-pip python-dev

Nous pouvons maintenant installer uWSGI globalement avec + pip + en tapant:

sudo pip install uwsgi

Le serveur de conteneur d’applications uWSGI s’interface avec les applications Python à l’aide de la spécification d’interface WSGI. Le framework web2py inclut un fichier conçu pour fournir cette interface dans son répertoire + handlers +. Pour utiliser le fichier, nous devons le déplacer hors du répertoire et dans le répertoire principal du projet:

mv ~//handlers/wsgihandler.py ~/

Avec le gestionnaire WSGI dans le répertoire principal du projet, nous pouvons vérifier que uWSGI est capable de servir l’application en tapant:

uwsgi --http :8000 --chdir ~/ -w wsgihandler:application

Cela devrait redémarrer l’application sur le port 8000. Comme nous n’utilisons pas le certificat et la clé SSL, cette fois-ci, ils seront servis via HTTP simple au lieu de HTTPS. Vous pouvez le tester à nouveau dans votre navigateur en utilisant le protocole + http +. Vous ne pourrez pas tester l’interface d’administration car web2py le désactive lorsque le chiffrement n’est pas disponible.

Lorsque vous avez terminé, tapez CTRL-C dans la fenêtre de votre terminal pour arrêter le serveur.

Création d’un fichier de configuration uWSGI

Maintenant que nous savons que uWSGI peut servir l’application, nous pouvons créer un fichier de configuration uWSGI avec les informations de notre application.

Créez un répertoire dans + / etc / uwsgi / sites + pour stocker nos configurations, puis accédez à ce répertoire:

sudo mkdir -p /etc/uwsgi/sites
cd /etc/uwsgi/sites

Nous appellerons notre fichier de configuration + myapp.ini +:

sudo nano .ini

Dans le fichier de configuration, nous devons commencer par un en-tête + [uwsgi] + sous lequel seront placées toutes nos directives de configuration. Après l’en-tête, nous indiquerons le chemin du répertoire de notre application et lui indiquerons le module à exécuter. Ce seront les mêmes informations que nous avons utilisées précédemment sur la ligne de commande. Vous n’avez pas besoin de modifier la ligne de module:

[uwsgi]
chdir = /home//
module = wsgihandler:application

Ensuite, nous devons spécifier que nous voulons que uWSGI fonctionne en mode maître. Nous voulons générer cinq processus de travail:

[uwsgi]
chdir = /home//
module = wsgihandler:application

master = true
processes = 5

Ensuite, nous devons spécifier comment nous voulons que uWSGI obtienne des connexions. Lors de notre test du serveur uWSGI, nous avons accepté les connexions HTTP normales. Cependant, puisque nous allons configurer Nginx en tant que proxy inverse devant uWSGI, nous avons d’autres options. Nginx peut utiliser un proxy en utilisant le protocole + uwsgi +, un protocole binaire rapide conçu par uWSGI pour communiquer avec les autres serveurs. Nous communiquerons en utilisant ce protocole, qui est la valeur par défaut si nous ne spécifions pas un autre protocole.

Puisque nous communiquons avec Nginx en utilisant le protocole + uwsgi +, nous n’avons pas besoin d’un port réseau. Au lieu de cela, nous utiliserons un socket Unix, qui est plus sécurisé et plus rapide. Nous allons placer ceci dans notre répertoire d’application. Nous devons modifier les autorisations afin que le groupe puisse lire et écrire sur le socket. Dans quelques instants, nous allons donner au groupe de processus Nginx la propriété du socket afin qu’uWSGI et Nginx puissent communiquer via ce socket:

[uwsgi]
chdir = /home//
module = wsgihandler:application

master = true
processes = 5

socket = /home///.sock
chmod-socket = 660
vacuum = true

La directive + vacuum + ci-dessus nettoie le fichier de socket lorsque le processus uWSGI se termine.

Notre fichier de configuration uWSGI est maintenant complet. Enregistrez et fermez le fichier.

Créer un fichier de démarrage uWSGI

Nous avons créé un fichier de configuration pour uWSGI, mais nous n’avons toujours pas configuré notre serveur d’applications pour qu’il démarre automatiquement au démarrage. Pour implémenter cette fonctionnalité, nous pouvons créer un simple fichier Upstart. Nous lui indiquerons d’exécuter uWSGI en «mode Emperor», ce qui permet au serveur d’applications de lire un nombre illimité de configurations et de démarrer le serveur pour chacune d’elles.

Créez un fichier dans le répertoire + / etc / init + où le processus Upstart cherche ses fichiers de configuration:

sudo nano /etc/init/uwsgi.conf

Nous commencerons par donner une description de notre fichier de service et en indiquant les niveaux d’exécution sur lesquels nous voulons le démarrer automatiquement. Les niveaux d’exécution multi-utilisateurs conventionnels sont 2, 3, 4 et 5. Upstart arrêtera le service lorsque le serveur passera à d’autres niveaux d’exécution (par exemple, en mode arrêt, redémarrage ou en mode mono-utilisateur):

description "uWSGI application server in Emperor mode"

start on runlevel [2345]
stop on runlevel [!2345]

Ensuite, nous devons spécifier l’utilisateur et le groupe pour exécuter le processus. Nous utiliserons notre compte d’utilisateur normal car il possède tous nos fichiers de projet. Pour notre groupe, nous devons autoriser la propriété du groupe + www-data, qui est le groupe dans lequel opère Nginx. Cela permettra au serveur Web de communiquer librement avec uWSGI puisque notre configuration uWSGI a donné des privilèges de lecture et d’écriture au groupe de sockets.

Ensuite, nous devons simplement spécifier la commande à exécuter pour démarrer uWSGI. Nous devons juste utiliser le drapeau + - emperor + et lui passer le répertoire contenant notre fichier de configuration:

description "uWSGI application server in Emperor mode"

start on runlevel [2345]
stop on runlevel [!2345]

setuid
setgid www-data

exec /usr/local/bin/uwsgi --emperor /etc/uwsgi/sites

Ceci démarrera un serveur d’application uWSGI pour gérer notre site web2py. Le mode Emperor nous permet d’ajouter facilement des fichiers de configuration dans ce répertoire pour d’autres projets. Ils seront traités automatiquement.

Nous avons maintenant terminé avec notre script Upstart. Enregistrez et fermez le fichier. À ce stade, nous ne pouvons pas démarrer le service uWSGI car nous n’avons pas encore installé Nginx. Cela signifie que le groupe sous lequel notre script a été exécuté n’est pas encore disponible.

Installer et configurer Nginx en tant que proxy inverse

Avec uWSGI configuré et prêt à fonctionner, nous pouvons maintenant installer et configurer Nginx en tant que proxy inverse. Ceci peut être téléchargé à partir des dépôts par défaut d’Ubuntu:

sudo apt-get install nginx

Une fois que Nginx est installé, nous pouvons continuer et modifier la configuration du bloc serveur. Nous allons utiliser le bloc de serveur par défaut comme base, car il contient l’essentiel de ce dont nous avons besoin:

sudo nano /etc/nginx/sites-available/default

L’application web2py détecte si vous vous connectez avec un cryptage HTTP simple ou avec un cryptage SSL. Pour cette raison, notre fichier contiendra en fait un bloc de serveur pour chacun. Nous allons commencer par le bloc de serveur configuré pour fonctionner sur le port 80.

Changez le + nom_serveur + pour référencer le nom de domaine ou l’adresse IP où votre site devrait être accessible. Ensuite, nous allons créer un bloc + emplacement {} + qui correspondra aux demandes de contenu statique. Fondamentalement, nous voulons utiliser des expressions régulières pour faire correspondre les demandes se terminant par + / static / + avec un composant de chemin précédent. Nous voulons mapper ces requêtes au répertoire + applications + de notre projet web2py. Assurez-vous de référencer le répertoire de base de votre utilisateur et le nom de l’application:

server {
   listen 80 default_server;
   listen [::]:80 default_server ipv6only=on;

   root /usr/share/nginx/html;
   index index.html index.htm;

   server_name ;





   . . .

Ensuite, nous devons ajuster le bloc + location / {} + pour transmettre les requêtes à notre socket uWSGI. Nous devons simplement inclure le fichier de paramètres uWSGI fourni avec Nginx et transmettre les requêtes au socket que nous avons configuré (dans notre fichier uWSGI + .ini +):

server {
   listen 80 default_server;
   listen [::]:80 default_server ipv6only=on;

   root /usr/share/nginx/html;
   index index.html index.htm;

   server_name ;

   location ~* /(\w+)/static/ {
       root /home///applications/;
   }

   location / {


   }
}

Ce sera tout ce dont nous avons besoin pour notre premier bloc de serveurs.

Au bas du fichier, il y a une section commentée qui contient la plupart des directives nécessaires pour servir du contenu avec SSL. Vous pouvez identifier ce bloc car il a + listen 443; + comme première directive. Décommentez ce bloc pour commencer à le configurer.

Pour commencer, modifiez à nouveau le + nom_serveur + pour qu’il corresponde au nom de domaine ou à l’adresse IP de votre serveur. Nous pouvons ensuite passer aux directives + ssl_certificate + et + ssl_certificate_key +. Nous allons placer les certificats SSL que nous avons générés dans un répertoire situé dans + / etc / nginx / ssl +, spécifiez donc le chemin d’accès aux fichiers situés à cet emplacement:

server {
   listen 443;
   server_name ;

   root html;
   index index.html index.htm;

   ssl on;
   ssl_certificate ;
   ssl_certificate_key ;

   . . .

Dans la liste + ssl_protocols +, supprimez SSLv3, qui présente des vulnérabilités inhérentes au protocole lui-même.

Nous pouvons ensuite passer au bloc + location / {} + et mettre les mêmes informations de proxy uWSGI que celles que nous avons utilisées dans le dernier bloc de serveur:

server {
   listen 443;
   server_name ;

   root html;
   index index.html index.htm;

   ssl on;
   ssl_certificate /etc/nginx/ssl/.crt;
   ssl_certificate_key /etc/nginx/ssl/.key;

   ssl_session_timeout 5m;

   ssl_protocols SSLv3 TLSv1 TLSv1.1 TLSv1.2;
   ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
   ssl_ciphers "HIGH:!aNULL:!MD5 or HIGH:!aNULL:!MD5:!3DES";
   ssl_prefer_server_ciphers on;

   location / {


   }
}

Vous devez maintenant avoir deux blocs de serveur configurés dans ce fichier. Enregistrez et fermez-le lorsque vous avez terminé.

Étapes finales

Ensuite, nous devons déplacer les certificats SSL dans le répertoire que nous avons spécifié. Créez d’abord le répertoire:

sudo mkdir -p /etc/nginx/ssl

Maintenant, déplacez le certificat et la clé que vous avez créés dans ce répertoire. Si vous avez un certificat SSL signé par une autorité de certification commerciale, vous pouvez remplacer le certificat et la clé correspondante ici afin d’éviter des avertissements de certificat SSL non fiables pour vos visiteurs:

sudo mv ~//.crt /etc/nginx/ssl
sudo mv ~//.key /etc/nginx/ssl

Modifiez les autorisations afin que les utilisateurs non root ne puissent pas accéder à ce répertoire:

sudo chmod 700 /etc/nginx/ssl

Maintenant, vérifiez votre fichier de configuration Nginx pour les erreurs de syntaxe:

sudo nginx -t

Si aucune erreur de syntaxe n’est signalée, nous pouvons continuer et redémarrer Nginx:

sudo service nginx restart

Nous pouvons également démarrer notre service uWSGI:

sudo service uwsgi start

La dernière chose à faire est de copier le fichier de paramètres de notre application afin qu’il soit lu correctement lors de la connexion au port 443. Ceci contient le mot de passe que nous avons configuré pour l’interface administrative. Nous devons simplement le copier sous un nouveau nom qui indique le port 443 au lieu du port 8000:

cp ~//parameters_8000.py ~//parameters_443.py

Avec cela, vous devriez pouvoir accéder à votre serveur en utilisant son nom de domaine ou son adresse IP. Utilisez + https + si vous souhaitez vous connecter à l’interface administrative.

Conclusion

Dans ce guide, nous avons configuré un exemple de projet web2py pour s’exercer au déploiement. Nous avons configuré uWSGI pour agir en tant qu’interface entre les demandes de nos applications et celles de nos clients. Nous avons ensuite configuré Nginx devant uWSGI pour permettre les connexions SSL et traiter efficacement les demandes des clients.

Le projet web2py simplifie le développement de sites et d’applications Web en fournissant une interface Web fonctionnelle dès le début. En exploitant la chaîne d’outils générale décrite dans cet article, vous pouvez facilement desservir les applications que vous créez à partir d’un seul serveur.

Related