Saltar a contenido

UD2.4 · Flask: primera web, botones y comandos Linux

Módulo: Sistemas Informáticos · 1.º DAM
Duración orientativa: 90–120 minutos
Modalidad: Individual · Debian GNU/Linux
Herramientas: Python, Flask, HTML, venv, subprocess, ps y whoami

En esta práctica crearás tu primera aplicación web con Flask. Empezarás mostrando dos mensajes y después incorporarás una página HTML con botones que consultarán información de Linux ejecutando comandos desde Python. Al final hay una ampliación opcional para estudiar systemd.

Dónde trabajar

Usa tu propio Debian de prácticas y la carpeta /workspace/ud2/flask/. No necesitas permisos de administrador para los apartados 1 a 6. El servidor de desarrollo debe permanecer solo en localhost (127.0.0.1).

1. Preparar el proyecto

Crea esta estructura (los archivos HTML y Python los escribirás en los siguientes pasos):

/workspace/ud2/flask/
├── .gitignore
├── .venv/                (NO se sube al repositorio)
├── app.py
└── templates/
    └── index.html

Crea la carpeta y prepara el entorno virtual:

mkdir -p /workspace/ud2/flask/templates
cd /workspace/ud2/flask

python3 -m venv .venv
source .venv/bin/activate
pip install flask

Si python3 -m venv falla porque falta soporte en Debian, el profesor podrá autorizar la instalación del paquete python3-venv.

¿Qué es venv?

Un entorno virtual contiene un intérprete de Python y las bibliotecas instaladas para este proyecto. Al activarlo, pip install flask instala Flask dentro de .venv, no globalmente para todos los programas del sistema.

which python
pip show flask

Para salir del entorno virtual, usa deactivate. Para activarlo de nuevo desde la carpeta del proyecto, ejecuta source .venv/bin/activate.

2. Crear .gitignore

El entorno virtual puede ocupar bastante espacio y no debe incluirse en Git. Crea /workspace/ud2/flask/.gitignore:

.venv/
__pycache__/
*.pyc

Después comprueba que Git lo ignora:

cd /workspace
git status --ignored

Si ya habías subido .venv

.gitignore evita que Git añada archivos nuevos, pero no elimina archivos que ya están en seguimiento. En ese caso puedes retirar el entorno virtual del índice con git rm -r --cached ud2/flask/.venv/, conservándolo en el disco.

3. Primera aplicación Flask

Crea /workspace/ud2/flask/app.py con este código:

from flask import Flask

app = Flask(__name__)

@app.route("/saludo")
def saludo():
    return "Esto es un saludo"

@app.route("/")
def inicio():
    return "Esta es mi web"

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

¿Qué significa cada parte?

Código Explicación
from flask import Flask Importa Flask
app = Flask(__name__) Crea nuestra aplicación web
@app.route("/saludo") Asocia la URL /saludo a la función saludo
def saludo(): Función que atiende la petición
return "Esto es un saludo" Texto devuelto al navegador
@app.route("/") La ruta principal de nuestra web
if __name__ == "__main__": Ejecuta el servidor si arrancamos este archivo directamente
app.run(debug=True) Arranca el servidor de desarrollo y facilita detectar errores

Ejecuta:

cd /workspace/ud2/flask
python3 app.py

Prueba estas direcciones desde el mismo Debian:

  • http://127.0.0.1:5000/ → Esta es mi web
  • http://127.0.0.1:5000/saludo → Esto es un saludo

También puedes comprobar las respuestas con curl desde otra terminal:

curl http://127.0.0.1:5000/
curl http://127.0.0.1:5000/saludo

Modo depuración

debug=True solo se utiliza para aprender y desarrollar en local. No publiques el servidor de desarrollo de Flask en Internet.

4. Incorporar HTML y botones

Ahora queremos una página que tenga botones y un espacio para mostrar información.

Crea /workspace/ud2/flask/templates/index.html:

<!DOCTYPE html>
<html lang="es">
<head>
    <meta charset="UTF-8">
    <title>Mi panel Linux</title>
</head>
<body>
    <h1>Mi panel Linux</h1>

    <form action="/saludo">
        <button>Mostrar saludo</button>
    </form>

    <form action="/usuario">
        <button>¿Quién soy?</button>
    </form>

    <form action="/procesos">
        <button>Ver procesos</button>
    </form>

    <h2>Resultado</h2>
    <pre>{{ salida }}</pre>
</body>
</html>

En HTML, un form envía una petición a la URL indicada en action. Como no indicamos method, se utiliza GET. Flask recibe la petición y devuelve una respuesta.

{{ salida }} es una variable de la plantilla: Flask la sustituye por el texto que queremos mostrar. Utilizamos <pre> para conservar los saltos de línea de la salida de los comandos.

5. Ejecutar comandos de Linux desde un endpoint

Vamos a utilizar subprocess.run() para ejecutar comandos concretos del sistema desde Python. Modifica app.py:

import os
import subprocess
from flask import Flask, render_template

app = Flask(__name__)

@app.route("/")
def inicio():
    return render_template("index.html", salida="Esta es mi web")

@app.route("/saludo")
def saludo():
    return render_template("index.html", salida="Esto es un saludo")

@app.route("/usuario")
def usuario():
    resultado = subprocess.run(
        ["whoami"], capture_output=True, text=True
    )
    return render_template("index.html", salida=resultado.stdout)

@app.route("/procesos")
def procesos():
    resultado = subprocess.run(
        ["ps", "-u", str(os.getuid()), "-o", "pid,comm"],
        capture_output=True,
        text=True
    )
    return render_template("index.html", salida=resultado.stdout)

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

¿Qué estamos haciendo?

  • @app.route("/usuario") crea un endpoint, una ruta a la que se puede llamar desde el navegador.
  • subprocess.run(["whoami"], ...) ejecuta el comando Linux whoami.
  • subprocess.run(["ps", ...], ...) consulta los procesos pertenecientes al usuario que ejecuta Flask.
  • os.getuid() obtiene el identificador de ese usuario.
  • capture_output=True guarda la salida del comando.
  • text=True permite trabajar con la salida como texto.
  • resultado.stdout contiene el texto que ha generado el comando.
  • render_template("index.html", salida=...) envía ese texto al HTML.

Nunca aceptes cualquier comando del navegador

Solo estamos ejecutando dos comandos fijos y de consulta, whoami y ps. No crees un endpoint del tipo /ejecutar?comando=... ni uses shell=True con texto enviado por un visitante. Un panel que administre procesos necesita autenticación, autorización y comprobaciones adicionales. No emplees sudo desde Flask.

Reinicia la aplicación si es necesario y pulsa los tres botones. Comprueba que el resultado aparece en el HTML.

6. Comprobar el proceso Flask desde Bash

Mientras Flask está funcionando, abre otra terminal:

ps -u "$USER"
ss -ltn
curl http://127.0.0.1:5000/procesos

Responde en /workspace/ud2/respuestas_ud2_4.md:

  1. ¿Qué diferencia hay entre una ruta (@app.route) y una función Python?
  2. ¿Para qué sirve templates/index.html?
  3. ¿Qué hace subprocess.run y dónde almacena la salida?
  4. ¿Quién ejecuta realmente whoami: el navegador o el proceso Flask?
  5. ¿Qué PID tiene Flask? ¿Qué puerto utiliza?
  6. ¿Por qué no debemos subir .venv al repositorio?

Detén Flask con Ctrl+C y comprueba que el navegador ya no puede consultar la página.

7. Ampliación: convertir Flask en un servicio de Linux

Esta parte se realizará cuando el profesor lo indique, en un Debian de laboratorio autorizado que utilice systemd. No todos los contenedores permiten crear servicios.

Comprueba:

ps -p 1 -o comm=

Debe aparecer systemd. Antes de instalar el servicio, cambia la última línea de la aplicación para desactivar la depuración:

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

Crea /workspace/ud2/flask/ud2-flask.service con:

[Unit]
Description=Panel Flask de la UD2
After=network.target

[Service]
Type=simple
User=TU_USUARIO
WorkingDirectory=/workspace/ud2/flask
ExecStart=/workspace/ud2/flask/.venv/bin/python /workspace/ud2/flask/app.py
Restart=on-failure

[Install]
WantedBy=multi-user.target

Sustituye TU_USUARIO por el usuario real del Debian (whoami). El servicio debe poder leer el proyecto.

Solo en tu máquina de laboratorio y con autorización:

sudo cp /workspace/ud2/flask/ud2-flask.service /etc/systemd/system/
sudo systemctl daemon-reload
sudo systemctl start ud2-flask
sudo systemctl status ud2-flask --no-pager
sudo journalctl -u ud2-flask -n 20 --no-pager
sudo systemctl stop ud2-flask

Así verás la diferencia entre ejecutar Python manualmente y dejar que systemd inicie y supervise el proceso. Deja el servicio detenido al terminar.

Entrega

Entrega desde tu repositorio de trabajo:

/workspace/ud2/flask/app.py
/workspace/ud2/flask/.gitignore
/workspace/ud2/flask/templates/index.html
/workspace/ud2/respuestas_ud2_4.md

La unidad ud2-flask.service es un archivo adicional solo si realizas la ampliación. No subas .venv/, datos sensibles ni archivos temporales.

cd /workspace
git status
git add ud2/flask/app.py ud2/flask/.gitignore ud2/flask/templates/index.html ud2/respuestas_ud2_4.md
git commit -m "Completar ejercicio UD2.4"
git pull
git push

Enlace con la UD3

Acabas de construir una aplicación que escucha en 127.0.0.1:5000. Es una dirección local: por ahora no necesitamos publicarla en la red.

En la siguiente unidad veremos IP, TCP, puertos y conectividad para explicar cómo se comunican un cliente y un servidor y cómo controlar de forma segura el acceso desde otras máquinas.