web-dev-qa-db-fra.com

Démarrer le serveur de flacon en arrière-plan

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?

pythonpython-2.7flaskcelery
18
Uday

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
10
RaphDG
$ 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) 

13
Joran Beasley

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.

0
allo

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 ):

  1. importer werkzeug._internal
  2. créer un demi-logger
  3. Attribuez la nouvelle classe à werkzeug._internal._log (log class)

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
0
Bizzu