Cómo instalar Flask con Python 3 en Ubuntu 18.04

Flask es un marco muy simple, pero extremadamente flexible, destinado a proporcionar funcionalidad a sus aplicaciones sin ser demasiado restrictivo en cuanto a estructura y diseño. Puede utilizar la pila general descrita en este artículo para las aplicaciones de matraz que diseñe.

En este artículo, configuraremos una aplicación Python simple utilizando el micromarco Flask en Ubuntu 18.04.

La mayor parte de este artículo tratará sobre cómo configurar el servidor de aplicaciones Gunicorn para iniciar la aplicación y Nginx para que actúe como un proxy inverso de front-end.

Requisitos

Antes de comenzar con este artículo, debe tener un usuario no root configurado en su servidor. Este usuario necesita tener privilegios sudo para poder realizar funciones administrativas.

Cree un usuario no root con privilegios sudo configurados:
1- Iniciar sesión como root
2- Creando un Nuevo Usuario

# adduser bobby

3- Concesión de privilegios administrativos

Para agregar estos privilegios a nuestro nuevo usuario, debemos agregar el nuevo usuario al grupo sudo. De forma predeterminada, en Ubuntu 18.04, los usuarios que pertenecen al grupo sudo pueden usar el comando sudo.

# usermod -aG sudo bobby

Instalar los Componentes desde los Repositorios de Ubuntu

El primer paso será instalar todas las piezas que necesitamos de los repositorios. Instalaremos pip, el administrador de paquetes de Python 3, para instalar y administrar nuestros componentes de Python 3. También obtendremos los archivos de desarrollo de Python 3 necesarios para construir algunos de los componentes de Gunicorn. Instalaremos Nginx ahora también.
Actualice su índice de paquetes local y luego instale los paquetes. Los paquetes específicos que necesita dependerán de la versión de Python que esté utilizando para su proyecto.
Instalando Python 3, escriba:

$ sudo apt-get update
$ sudo apt-get install python3-pip python3-dev nginx

Cree un entorno virtual de Python 3

A continuación, configuraremos un entorno virtual para aislar nuestra aplicación Flask de los otros archivos de Python en el sistema.
Comience instalando el paquete virtualenv usando pip.
Si está utilizando Python 3, escriba:

sudo pip3 install virtualenv

Ahora, podemos crear un directorio principal para nuestro proyecto Flask. Vaya al directorio después de crearlo:

mkdir ~/flaskproject
cd ~/flaskproject

Podemos crear un entorno virtual para almacenar los requisitos de Python de nuestro proyecto Flask escribiendo:

virtualenv flaskprojectenv

Esto instalará una copia local de Python y pip en un directorio llamado matrazprojectenv dentro del directorio de su proyecto.
Antes de instalar aplicaciones dentro del entorno virtual, debemos activarlo. Puede hacerlo escribiendo:

source flaskprojectenv/bin/activate

Su mensaje cambiará para indicar que ahora está operando dentro del entorno virtual. Se verá algo como esto (flaskprojectenv)user@host:~/flaskproject$ .

Configurar una aplicación Flask

Ahora que está en su entorno virtual, podemos instalar Flask y Gunicorn y comenzar a diseñar nuestra aplicación:

Instalar Flask y Gunicorn

Podemos usar la instancia local de pip para instalar Flask y Gunicorn. Escriba los siguientes comandos para obtener estos dos componentes:

Nota: Independientemente de la versión de Python que esté usando, cuando el entorno virtual está activado, debe usar el pip comando (no pip3 ).

(flaskprojectenv) $ pip install gunicorn flask

Crear una aplicación de muestra

Ahora que tenemos Flask disponible, podemos crear una aplicación sencilla. Flask es un micro-marco. No incluye muchas de las herramientas que podrían tener los marcos de trabajo más completos, y existe principalmente como un módulo que puede importar a sus proyectos para ayudarlo a inicializar una aplicación web.
Si bien su aplicación puede ser más compleja, crearemos nuestra aplicación Flask en un solo archivo, al que llamaremos Flaskproject.py:

(flaskprojectenv) $ nano ~/flaskproject/flaskproject.py

Dentro de este archivo, colocaremos nuestro código de aplicación. Básicamente, necesitamos importar un matraz e instanciar un objeto Flask. Podemos usar esto para definir las funciones que deben ejecutarse cuando se solicita una ruta específica:

~/flaskproject/flaskproject.py
from flask import Flask
app = Flask(__name__)

@app.route("/")
def greeting():
    return "<h1 style='color:green'>Hello World!</h1>"

if __name__ == "__main__":
    app.run(host='0.0.0.0')

Básicamente, esto define qué contenido presentar cuando se accede al dominio raíz. Guarde y cierre el archivo cuando haya terminado.

Si siguió la guía de configuración inicial del servidor, debería tener habilitado un firewall UFW. Para probar nuestra aplicación, debemos permitir el acceso al puerto 5000.

Abra el puerto 5000 escribiendo:

(flaskprojectenv) $ sudo ufw allow 5000

Ahora, puede probar su aplicación Flask escribiendo:

(flaskprojectenv) $ python flaskproject.py

Visite el nombre de dominio o la dirección IP de su servidor seguido de :5000 en su navegador web:

http://server_domain_or_IP:5000

Debería ver algo como esto:

Cuando termines, presiona CTRL-C en la ventana de su terminal varias veces para detener el servidor de desarrollo de Flask.

Crear el punto de entrada WSGI

A continuación, crearemos un archivo que servirá como punto de entrada para nuestra aplicación. Esto le indicará a nuestro servidor Gunicorn cómo interactuar con la aplicación.

Llamaremos al archivo wsgi.py :

(flaskprojectenv) $ nano ~/flaskproject/wsgi.py

El archivo es increíblemente simple, simplemente podemos importar la instancia de Flask desde nuestra aplicación y luego ejecutarla:

~/flaskproject/wsgi.py
from flaskproject import app

if __name__ == "__main__":
    app.run()

Guarde y cierre el archivo cuando haya terminado.

Prueba de la capacidad de Gunicorn para servir al proyecto

Antes de continuar, debemos comprobar que Gunicorn puede hacerlo correctamente. Podemos hacer esto simplemente pasándole el nombre de nuestro punto de entrada. Esto se construye por el nombre del módulo (menos el .py extensión, como de costumbre) más el nombre del invocable dentro de la aplicación. En nuestro caso, sería wsgi:app .

También especificaremos la interfaz y el puerto al que enlazar para que se inicie en una interfaz disponible públicamente:

(flaskprojectenv) $ cd ~/flaskproject
(flaskprojectenv) $ gunicorn --bind 0.0.0.0:5000 wsgi:app

Visite el nombre de dominio o la dirección IP de su servidor con :5000 agregado al final en su navegador web nuevamente:

http://server_domain_or_IP:5000

Debería volver a ver el resultado de su aplicación:

Cuando hayas confirmado que funciona correctamente, presiona CTRL-C en la ventana de tu terminal.
Ya hemos terminado con nuestro entorno virtual, por lo que podemos desactivarlo:

(flaskprojectenv) $ deactivate

Todos los comandos de Python volverán a utilizar el entorno de Python del sistema.

Crear un archivo de unidad systemd

La siguiente pieza que debemos cuidar es el archivo de la unidad de servicio systemd. La creación de un archivo de unidad systemd permitirá que el sistema de inicio de Ubuntu inicie automáticamente Gunicorn y sirva nuestra aplicación Flask cada vez que se inicie el servidor.

Cree un archivo de unidad que termine en .service dentro del /etc/systemd/system directorio para comenzar:

$ sudo nano /etc/systemd/system/flaskproject.service

En el interior, comenzaremos con el [Unit] sección, que se utiliza para especificar metadatos y dependencias. Pondremos una descripción de nuestro servicio aquí y le diremos al init sistema para iniciar esto solo después de que se haya alcanzado el objetivo de red

A continuación, abriremos el [Service] sección. Especificaremos el usuario y el grupo bajo el que queremos que se ejecute el proceso. Daremos a nuestra cuenta de usuario habitual la propiedad del proceso, ya que posee todos los archivos relevantes. Daremos propiedad de grupo a www-data group para que Nginx pueda comunicarse fácilmente con los procesos de Gunicorn.

Luego trazaremos el directorio de trabajo y estableceremos la variable ambiental PATH para que init El sistema sabe dónde se encuentran nuestros ejecutables para el proceso (dentro de nuestro entorno virtual). Luego especificaremos el comando para iniciar el servicio. Systemd requiere que proporcionemos la ruta completa al ejecutable Gunicorn, que está instalado dentro de nuestro entorno virtual.

Le diremos que inicie 3 procesos de trabajo (ajustar esto según sea necesario). También le indicaremos que cree y se vincule a un archivo de socket Unix dentro de nuestro directorio de proyecto llamado flaskproject.sock . Estableceremos un valor de umask de 007 para que el archivo de socket se cree dando acceso al propietario y al grupo, mientras restringe otros accesos. Finalmente, necesitamos pasar el nombre del archivo del punto de entrada de WSGI y el Python invocable dentro.

Finalmente, agregaremos un [Install] sección. Esto le dirá a systemd a qué vincular este servicio si lo habilitamos para que se inicie en el arranque. Queremos que este servicio se inicie cuando el sistema multiusuario regular esté en funcionamiento:

/etc/systemd/system/flaskproject.service
[Unit]
Description=Gunicorn instance to serve flaskproject
After=network.target

[Service]
User=bobby
Group=www-data
WorkingDirectory=/home/bobby/flaskproject
Environment="PATH=/home/bobby/flaskproject/flaskprojectenv/bin"
ExecStart=/home/bobby/flaskproject/flaskprojectenv/bin/gunicorn --workers 3 --bind unix:flaskproject.sock -m 007 wsgi:app

[Install]
WantedBy=multi-user.target

Con eso, nuestro archivo de servicio systemd está completo. Guárdelo y ciérrelo ahora.

Ahora podemos iniciar el servicio de Gunicorn que creamos y habilitarlo para que se inicie en el arranque:

$ sudo systemctl start flaskproject
$ sudo systemctl enable flaskproject

Configuración de Nginx para solicitudes de proxy

Nuestro servidor de aplicaciones Gunicorn ahora debería estar en funcionamiento, esperando solicitudes en el archivo de socket en el directorio del proyecto. Necesitamos configurar Nginx para pasar solicitudes web a ese socket haciendo algunas pequeñas adiciones a su archivo de configuración.

Comience por crear un nuevo archivo de configuración de bloque de servidor en los sites-available de Nginx. directorio. Simplemente llamaremos a este proyecto de matraz para estar en línea con el resto del artículo:

$ sudo nano /etc/nginx/sites-available/flaskproject

Abre un server bloquear y decirle a Nginx que escuche en el puerto predeterminado 80. También debemos decirle que use este bloque para las solicitudes del nombre de dominio o la dirección IP de nuestro servidor.

Lo único que necesitamos agregar es una location bloque que coincide con cada solicitud. Dentro de este bloque, incluiremos los proxy_params archivo que especifica algunos parámetros generales de proxy que deben establecerse. Luego pasaremos las solicitudes al socket que definimos usando el proxy_pass directiva:

/etc/nginx/sites-available/flaskproject
server {
    listen 80;
    server_name server_domain_or_IP;

    location / {
        include proxy_params;
        proxy_pass http://unix:/home/bobby/flaskproject/flaskproject.sock;
    }
}

Eso es en realidad todo lo que necesitamos para servir nuestra aplicación. Guarde y cierre el archivo cuando haya terminado.

Para habilitar el server de Nginx configuración de bloque que acabamos de crear, vincule el archivo a sites-enabled directorio:

$ sudo ln -s /etc/nginx/sites-available/flaskproject /etc/nginx/sites-enabled

Con el archivo en ese directorio, podemos probar los errores de sintaxis escribiendo:

$ sudo nginx -t

Si esto regresa sin indicar ningún problema, podemos reiniciar el proceso de Nginx para leer nuestra nueva configuración:

$ sudo systemctl restart nginx

Lo último que debemos hacer es ajustar nuestro firewall nuevamente. Ya no necesitamos acceso a través del puerto 5000, por lo que podemos eliminar esa regla. Entonces podemos permitir el acceso al servidor Nginx:

$ sudo ufw delete allow 5000
$ sudo ufw allow 'Nginx Full'

Ahora debería poder ir al nombre de dominio o dirección IP de su servidor en su navegador web:

http://server_domain_or_IP

Debería ver el resultado de su aplicación:

Nota:Después de configurar Nginx, el próximo paso debe ser asegurar el tráfico al servidor usando SSL/TLS. Esto es importante porque sin él, toda la información, incluidas las contraseñas, se envía a través de la red en texto sin formato. La forma más fácil de obtener un certificado SSL para proteger su tráfico es usando Let's Encrypt.

Leer también

• Cómo instalar certificados Let's Encrypt SSL en Ubuntu 18.04
• Cómo configurar el entorno de desarrollo de Django en Ubuntu 18.04
• Cómo instalar LEMP en Ubuntu 18.04

Conclusión: En este artículo, hemos creado una aplicación Flask simple dentro de un entorno virtual de Python. Creamos un punto de entrada WSGI para que cualquier servidor de aplicaciones compatible con WSGI pueda interactuar con él y luego configuramos el servidor de aplicaciones Gunicorn para proporcionar esta función. Luego, creamos un archivo de unidad systemd para iniciar automáticamente el servidor de aplicaciones en el arranque. Creamos un bloque de servidor Nginx que pasa el tráfico del cliente web al servidor de aplicaciones, retransmitiendo solicitudes externas.