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 servir las aplicaciones de matraces que diseñe.

En este artículo, configuraremos una aplicación Python simple usando el micro-framework 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.

Prerrequisitos

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

Cree un usuario no root con sudo privilegios configurados:
1- Iniciar sesión como root
2- Creación de un nuevo usuario

# adduser bobby

3- Concesión de privilegios administrativos

Para agregar estos privilegios a nuestro nuevo usuario, necesitamos agregar el nuevo usuario a la sudo grupo. De forma predeterminada, en Ubuntu 18.04, los usuarios que pertenecen a la sudo el grupo puede utilizar el sudo mando.

# usermod -aG sudo bobby

Instale los componentes de los repositorios de Ubuntu

El primer paso será instalar todas las piezas que necesitemos 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. También instalaremos Nginx ahora.
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. Muévase 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 flaskprojectenv 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 de matraz

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 incluir 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 el matraz y crear una instancia de 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")

Esto básicamente define qué contenido presentar cuando se accede al dominio raíz. Save y close el archivo cuando haya terminado.

Si siguió la guía de configuración inicial del servidor, debe tener un firewall UFW habilitado. Para probar nuestra aplicación, necesitamos 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:

https://server_domain_or_IP:5000

Debería ver algo como esto:

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

Cree el punto de entrada WSGI

A continuación, crearemos un archivo que servirá como punto de entrada para nuestra aplicación. Esto le dirá 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()

Save y close el archivo cuando haya terminado.

Prueba de la capacidad de Gunicorn para servir al proyecto

Antes de continuar, debemos comprobar que Gunicorn pueda hacerlo correctamente. Podemos hacer esto simplemente pasándole el nombre de nuestro punto de entrada. Esto se construye con el nombre del módulo (menos el .py extensión, como de costumbre) más el nombre del llamante dentro de la aplicación. En nuestro caso, esto 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 adjunto al final en su navegador web nuevamente:

https://server_domain_or_IP:5000

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

Cuando haya confirmado que funciona correctamente, presione CTRL-C en la ventana de su terminal.
Ahora hemos terminado con nuestro entorno virtual, por lo que podemos desactivarlo:

(flaskprojectenv) $ deactivate

Cualquier comando de Python volverá a usar el entorno Python del sistema.

Crear un archivo de unidad systemd

La siguiente pieza de la que debemos ocuparnos 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 de /etc/systemd/system directorio para comenzar:

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

Adentro, 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. Le daremos a nuestra cuenta de usuario habitual la propiedad del proceso, ya que posee todos los archivos relevantes. Daremos propiedad grupal al www-data group para que Nginx pueda comunicarse fácilmente con los procesos de Gunicorn.

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

Le diremos que inicie 3 procesos de trabajo (ajústelo según sea necesario). También le diremos 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 que restringe otros accesos. Finalmente, necesitamos pasar el nombre del archivo del punto de entrada 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 normal 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. Save y close Es ahora.

Ahora podemos iniciar el servicio Gunicorn que creamos y habilitarlo para que comience 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 creando un nuevo archivo de configuración de bloque de servidor en Nginx sites-available directorio. Simplemente llamaremos a este flaskproject para mantenernos 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 necesitamos decirle que use este bloque para las solicitudes del nombre de dominio o la dirección IP de nuestro servidor.

La única otra cosa que necesitamos agregar es un location bloque que coincide con cada solicitud. Dentro de este bloque, incluiremos el proxy_params archivo que especifica algunos parámetros generales de proxy que deben configurarse. 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 https://unix:/home/bobby/flaskproject/flaskproject.sock;
    }
}

En realidad, eso es todo lo que necesitamos para atender nuestra aplicación. Save y close el archivo cuando haya terminado.

Para habilitar el Nginx server bloque de configuración que acabamos de crear, vincule el archivo a la 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 tenemos que hacer es volver a ajustar nuestro cortafuegos. Ya no necesitamos acceso a través del puerto 5000, por lo que podemos eliminar esa regla. Luego podemos permitir el acceso al servidor Nginx:

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

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

https://server_domain_or_IP

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

Nota: Después de configurar Nginx, el siguiente paso debería ser asegurar el tráfico al servidor mediante 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 utilizando Let’s Encrypt.

Leer también

  • Cómo instalar certificados SSL Let’s Encrypt en Ubuntu 18.04
  • Cómo configurar el entorno de desarrollo 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. Posteriormente, 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, transmitiendo solicitudes externas.