Hasta ahora, hemos iniciado aplicaciones Flask a través de app.run()métodos. En el entorno de desarrollo, esto es ciertamente factible, pero en el entorno de producción, está obligado a utilizar un servidor de aplicaciones web robusto y potente para manejar diversas situaciones complejas. Al mismo tiempo, debido a que la aplicación cambia con frecuencia durante el proceso de desarrollo, es tedioso implementar manualmente cada cambio en el entorno de producción, lo mejor es tener una herramienta automatizada para simplificar el trabajo de integración continua. En este artículo, presentaremos cómo empaquetar, distribuir e implementar automáticamente aplicaciones Flask en servidores como Apache, Nginx, etc.
Utilice herramientas de configuración para empaquetar aplicaciones Flask
En primer lugar, debe comprender el método básico de usar herramientas de configuración para empaquetar y distribuir aplicaciones Python . A continuación, comencemos a escribir un archivo "setup.py":
from setuptools import setup
setup(
name='MyApp',
version='1.0',
long_description=__doc__,
packages=['myapp','myapp.main','myapp.admin'],
include_package_data=True,
zip_safe=False,
install_requires=[
'Flask>=0.10',
'Flask-Mail>=0.9',
'Flask-SQLAlchemy>=2.1'
]
)
Coloque el archivo en el directorio raíz del proyecto. Además, no olvide escribir un archivo "MANIFEST.in":
recursive-include myapp/templates *
recursive-include myapp/static *
Después de escribir, puede crear un entorno virtual limpio y luego ejecutar el comando de instalación para probar el efecto.
$ python setup.py install
Utilice Fabric para implementar aplicaciones Flask de forma remota
De manera similar, debe comprender cómo usar Fabric para implementar aplicaciones Python de forma remota . Luego, escribamos el archivo "fabfile.py":
from fabric.api import *
env.hosts = ['example1.com', 'example2.com']
env.user = 'bjhee'
def package():
local('python setup.py sdist --formats=gztar', capture=False)
def deploy():
dist = local('python setup.py --fullname', capture=True).strip()
put('dist/%s.tar.gz' % dist, '/tmp/myapp.tar.gz')
run('mkdir /tmp/myapp')
with cd('/tmp/myapp'):
run('tar xzf /tmp/myapp.tar.gz')
run('/home/bjhee/virtualenv/bin/python setup.py install')
run('rm -rf /tmp/myapp /tmp/myapp.tar.gz')
run('touch /var/www/myapp.wsgi')
En el ejemplo anterior, la tarea "paquete" se usa para empaquetar la aplicación, y la tarea "implementar" se usa para instalar el paquete Python en el entorno virtual del servidor remoto. Se supone que el entorno virtual está en "/ home / bjhee / virtualenv" . Después de la instalación, actualizamos la hora de modificación del archivo "/var/www/myapp.wsgi" para notificar al servidor WSGI (como Apache) que lo vuelva a cargar. Para servidores que no son WSGI, como uWSGI, esta declaración se puede omitir.
Después de escribir, ejecute el script de implementación para probar:
$ fab package deploy
Use Apache + mod_wsgi para ejecutar la aplicación Flask
La aplicación Flask se basa en la especificación WSGI, por lo que puede ejecutarse en cualquier servidor de aplicaciones web que admita el protocolo WSGI El método más utilizado es Apache + mod_wsgi . El script de Fabric anterior ha completado la implementación de la aplicación Flask en el servidor remoto, lo siguiente que debe hacer es escribir el archivo de entrada WSGI "myapp.wsgi", asumimos que está ubicado en el directorio raíz del documento Apache en "/ var / www "debajo.
activate_this = '/home/bjhee/virtualenv/bin/activate_this.py'
execfile(activate_this, dict(__file__=activate_this))
import os
os.environ['PYTHON_EGG_CACHE'] = '/home/bjhee/.python-eggs'
import sys;
sys.path.append("/var/www")
from myapp import create_app
import config
application = create_app('config')
Tenga en cuenta que debe crear el archivo de configuración "config.py" de antemano y colocarlo en la ruta de importación del módulo Python del servidor remoto. En el ejemplo anterior, agregamos "/ var / www" a la ruta de importación del módulo Python, por lo que podemos poner "config.py" en él. Además, recuerde no incluir "config.py" al empaquetar con herramientas de configuración, para no sobrescribir el entorno de producción con la configuración en el entorno de desarrollo durante el proceso de implementación.
Agregue la actualización automática de la secuencia de comandos y la asignación de rutas de URL en "httpd.conf" de Apache:
WSGIScriptReloading On
WSGIScriptAlias /myapp /var/www/myapp.wsgi
Después de reiniciar el servidor Apache, puede http://example1.com/myappacceder a la aplicación a través de.
Utilice Nginx + uWSGI para ejecutar aplicaciones Flask
Primero debe preparar el entorno operativo Nginx + uWSGI y luego escribir el archivo de inicio de uWSGI "myapp.ini":
[uwsgi]
socket=127.0.0.1:3031
callable=app
mount=/myapp=run.py
manage-script-name=true
master=true
processes=4
threads=2
stats=127.0.0.1:9191
virtualenv=/home/bjhee/virtualenv
Luego modifique el archivo de configuración de Nginx, el valor predeterminado en Linux es "/ etc / nginx / sites-enabled / default", más la configuración del directorio:
location /myapp {
include uwsgi_params;
uwsgi_param SCRIPT_NAME /myapp;
uwsgi_pass 127.0.0.1:3031;
}
Después de reiniciar Nginx y uWSGI, puede http://example1.com/myappacceder a la aplicación a través de.
También puede configurar nuestra aplicación como un servidor virtual, simplemente mueva la configuración de uWSGI anterior al archivo de configuración del servidor virtual. Para la configuración del servidor virtual Nginx, puede consultar mi artículo anterior .
Utilice Tornado para ejecutar aplicaciones Flask
El poder de Tornado es que es un modelo Epoll y E / S asíncrono sin bloqueo. El uso de Tornado puede admitir decenas de miles de conexiones simultáneas y tiene un buen rendimiento para aplicaciones altamente simultáneas. Este artículo no ampliará la introducción de Tornado, y los amigos interesados pueden consultar su documentación oficial . Usar Tornado para ejecutar aplicaciones Flask es muy simple, simplemente escriba el siguiente programa en ejecución y ejecútelo:
from tornado.wsgi import WSGIContainer
from tornado.httpserver import HTTPServer
from tornado.ioloop import IOLoop
from myapp import create_app
import config
app = create_app('config')
http_server = HTTPServer(WSGIContainer(app))
http_server.listen(5000)
IOLoop.instance().start()
Después de eso, puede http://example1.com:5000acceder a la aplicación a través de.
Usa Gunicorn para ejecutar aplicaciones Flask
Gunicorn es un servidor de aplicaciones web Python WSGI, portado desde Ruby's Unicorn. Se basa en el modelo de "trabajador previo a la bifurcación", es decir, se abren una gran cantidad de procesos con anticipación, esperando y procesando las solicitudes recibidas. Cada proceso individual puede procesar sus propias solicitudes al mismo tiempo, evitando los gastos generales de inicio y destrucción del proceso. Sin embargo, Gunicorn se basa en el bloqueo de IO y su rendimiento de concurrencia no se puede comparar con Tornado. Para obtener más información, consulte su sitio web oficial . Además, Gunicorn, como uWSGI, generalmente se usa con servidores web como Nginx.
Primero instalemos la aplicación en el servidor remoto, y luego iniciemos la aplicación con Gunicorn, use el siguiente comando:
$ gunicorn run:app
Explique, debido a que nuestra aplicación usa el método de fábrica, solo el objeto de la aplicación se crea en el archivo "run.py". appEl argumento del comando gunicorn debe ser el objeto de la aplicación, así que aquí está "ejecutar: aplicación". Ahora puede utilizar http://example1.com:8000para acceder a la aplicación. El puerto de escucha predeterminado es "8000".
Supongamos que queremos iniciar 4 procesos de trabajo por adelantado y monitorear el puerto local "5000", podemos cambiar el comando de inicio a:
$ gunicorn -w 4 -b 127.0.0.1:5000 run:app
El código de muestra de este artículo se puede descargar aquí .