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.
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:
Después comprueba que Git lo ignora:
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:
Prueba estas direcciones desde el mismo Debian:
http://127.0.0.1:5000/→Esta es mi webhttp://127.0.0.1:5000/saludo→Esto es un saludo
También puedes comprobar las respuestas con curl desde otra terminal:
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 Linuxwhoami.subprocess.run(["ps", ...], ...)consulta los procesos pertenecientes al usuario que ejecuta Flask.os.getuid()obtiene el identificador de ese usuario.capture_output=Trueguarda la salida del comando.text=Truepermite trabajar con la salida como texto.resultado.stdoutcontiene 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:
Responde en /workspace/ud2/respuestas_ud2_4.md:
- ¿Qué diferencia hay entre una ruta (
@app.route) y una función Python? - ¿Para qué sirve
templates/index.html? - ¿Qué hace
subprocess.runy dónde almacena la salida? - ¿Quién ejecuta realmente
whoami: el navegador o el proceso Flask? - ¿Qué PID tiene Flask? ¿Qué puerto utiliza?
- ¿Por qué no debemos subir
.venval 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:
Debe aparecer systemd. Antes de instalar el servicio, cambia la última línea de la aplicación para desactivar la depuración:
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.