J'ai une application de flacon que je lance actuellement de la manière suivante:
#phantom.py
__author__ = 'uruddarraju'
from phantom.api.v1 import app
app.run(Host='0.0.0.0', port=8080, debug=True)
et quand j'exécute ce script, il s'exécute avec succès en imprimant:
loading config from /home/uruddarraju/virtualenvs/PHANTOMNEW/Phantom/etc/phantom/phantom.ini
* Running on http://0.0.0.0:8080/
Mais cela ne revient jamais et si je fais un CTRL-C, le serveur s’arrête. J'essaie de le déployer en production et de lancer ce démarrage en arrière-plan, où le processus reste actif tant que le serveur est actif.
Quelle est la meilleure façon de procéder?
Ma façon préférée de le faire en production est de combiner flacon avec uwsgi et nginx pour conserver la persistance. Voici les instructions d'installation utiles pour bien commencer: http://www.markjberger.com/flask-with-virtualenv-uwsgi-nginx/
Jist:
Tout d’abord, assurez-vous que votre vps dispose des dernières mises à jour:
Sudo apt-get update
Sudo apt-get upgrade
Maintenant, installez python et virtualenv:
Sudo apt-get install build-essential python-dev python-pip
Sudo pip install virtualenv
Créez un dossier pour votre site web:
Sudo mkdir -p /var/www/mysite
Sudo chown -R <your user id> /var/www/mysite
cd /var/www/mysite
Configurez virtualenv et installez le flacon:
virtualenv .env --no-site-packages
source .env/bin/activate
pip install flask
Placez votre application de flacon dans ce dossier. Assurez-vous que votre hôte est défini sur 0.0.0.0 et que votre application est sous if __== '__main__':
. Si votre application est dans une fonction, uwsgi ne pourra pas l'appeler.
Il est maintenant temps de tester votre application avec le serveur de développement de flacon pour voir si tout fonctionne jusqu'à présent. Si tout se passe bien, installez nginx et uwsgi:
deactivate
Sudo apt-get install nginx uwsgi uwsgi-plugin-python
Ensuite, nous devons créer un fichier de socket pour que nginx puisse communiquer avec uwsgi:
cd /tmp/
touch mysite.sock
Sudo chown www-data mysite.sock
En changeant le propriétaire de mysite.sock en www-data, nginx pourra écrire dans le socket. Il ne nous reste plus qu'à ajouter nos fichiers de configuration pour nginx et uwsgi. Commencez par supprimer la configuration par défaut pour nginx:
cd /etc/nginx/sites-available
Sudo rm default
Créez un nouveau fichier de configuration mysite et ajoutez ce qui suit:
server {
listen 80;
server_tokens off;
server_name www.mysite.com mysite.com;
location / {
include uwsgi_params;
uwsgi_pass unix:/tmp/mysite.sock;
}
location /static {
alias /var/www/mysite/static;
}
## Only requests to our Host are allowed
if ($Host !~ ^(mysite.com|www.mysite.com)$ ) {
return 444;
}
}
Pour activer le site, nous devons lier notre fichier de configuration à/etc/nginx/sites-enabled /:
Sudo ln -s /etc/nginx/sites-available/mysite /etc/nginx/sites-enabled/mysite
Le processus est similaire pour uwsgi. Créez le fichier /etc/uwsgi/apps-available/mysite.ini et ajoutez ce qui suit:
[uwsgi]
vhost = true
socket = /tmp/mysite.sock
venv = /var/www/mysite/.env
chdir = /var/www/mysite
module = app
callable = app
Module est le nom de votre script python et callable est le nom de votre instance de flacon. Donc, si votre site de flacon se trouvait dans un fichier nommé mysite.py qui ressemblait à ceci:
from flask import Flask
my_app = Flask(__name__)
@my_app.route('/')
def hello_world():
return 'Hello World!'
if __== '__main__':
my_app.run(Host='0.0.0.0')
Votre fichier mysite.ini serait:
module = mysite
callable = my_app
Liez le fichier de configuration au dossier enabled-apps:
Sudo ln -s /etc/uwsgi/apps-available/mysite.ini /etc/uwsgi/apps-enabled/mysite.ini
Enfin, redémarrez nginx et uwsgi:
Sudo service nginx restart
Sudo service uwsgi restart
$ python phantom.py &
C'est probablement le moyen le plus simple de le faire fonctionner en arrière-plan. Cela dit, vous ne devriez pas utiliser le serveur app.run () pour servir votre application de flacon si vous le mettez en production comme le mentionne @LukasGraf (ainsi que leur documentation, je crois)
Essayez Supervisord . Il lance les commandes en tant qu'utilisateur spécifié et les redémarre après leur arrêt. La configuration est très simple pour ce que vous voulez faire.
La meilleure façon de faire est probablement derrière nginx comme @RaphDG a répondu, Mais si vous voulez le lancer en arrière-plan pour votre usage personnel, j’ai trouvé que le système de journalisation .__ ne vous permettait pas d’utiliser uniquement " "à la fin de la ligne de commande, j’ai également constaté que le consignateur est un consignateur interne de la bibliothèque Werkzeug.
Pour contourner cela, vous pouvez faire les prochaines étapes ( code ci-dessous ):
Il évitera les notifications et les enregistreurs et vous permettra d’exécuter ce processus en arrière-plan (avec "&")
code:
import werkzeug._internal
def demi_logger(type, message,*args,**kwargs):
pass
la première ligne du_MAIN_:
werkzeug._internal._log = demi_logger