¿Estás buscando una forma eficaz de automatizar el login de Moodle 4.3 y verificar su correcto funcionamiento? En este tutorial, aprenderás a implementar un sistema de Automatización Robótica de Procesos (RPA) utilizando Python, Selenium y FastAPI. Además, te mostraremos cómo encapsular esta funcionalidad en una API REST y cómo integrarla con herramientas de monitorización como Prometheus y Grafana, para supervisar el desempeño de tu plataforma Moodle en tiempo real.

En el entorno actual de desarrollo de software y administración de plataformas educativas, la automatización se ha convertido en una solución imprescindible para optimizar tareas repetitivas, minimizar errores y mejorar la eficiencia operativa. Aquí, la Automatización Robótica de Procesos (RPA) destaca como una herramienta clave, permitiendo a los desarrolladores emular acciones humanas en sistemas digitales.

Este tutorial práctico se centra en una tarea esencial para los administradores de Moodle: comprobar de manera automatizada el proceso de login en Moodle 4.3. A través de Python y Selenium, simularemos el inicio de sesión en la plataforma para garantizar que tu sistema funciona correctamente. Asimismo, encapsularemos esta solución en una API REST con FastAPI, lo que facilitará su integración en sistemas más complejos o su ejecución remota como parte de un esquema de monitorización integral.

¿Qué es RPA y por qué es relevante en este tutorial?

La Automatización Robótica de Procesos (RPA, por sus siglas en inglés) es una tecnología que permite automatizar tareas repetitivas mediante el uso de software especializado que simula la interacción humana con aplicaciones y sistemas. A través de scripts o bots, RPA ayuda a realizar procesos que de otro modo serían realizados manualmente, como la entrada de datos, la validación de información o la ejecución de pruebas.

La RPA tiene aplicaciones muy amplias en sectores como el financiero, el de atención al cliente y, por supuesto, el educativo. En este artículo, exploraremos cómo utilizar RPA para comprobar el login de Moodle mediante una combinación de Python, Selenium y FastAPI.

Objetivo: Comprobar el Login de Moodle con Python, Selenium y FastAPI

El objetivo de este artículo es mostrar cómo crear un script de automatización que verifique si un usuario puede acceder correctamente a la plataforma Moodle utilizando Python, Selenium y FastAPI. Para ello, se abordará el proceso de:

1. Configuración del entorno de desarrollo.
2. Instalación de las librerías necesarias.
3. Creación de un script automatizado que interactúe con la página de login de Moodle.
4. Integración de FastAPI para recibir solicitudes de verificación de login.

Este enfoque se enmarca dentro de la Automatización Robótica de Procesos (RPA) y demuestra cómo las herramientas adecuadas pueden facilitar tareas que normalmente llevarían tiempo y recursos, como verificar el acceso a plataformas educativas como Moodle.

¿Por Qué Usar Python, Selenium y FastAPI para Automatizar el Login de Moodle?

El uso combinado de Python, Selenium y FastAPI ofrece una solución eficaz y escalable para automatizar tareas como la comprobación de logins en plataformas como Moodle. A continuación, te explico brevemente por qué estos tres elementos son una excelente opción:

Python: El Lenguaje de Programación Ideal para RPA

Python es un lenguaje versátil y fácil de aprender que se ha ganado la preferencia para proyectos de automatización. Su amplia gama de bibliotecas y la comunidad activa lo convierten en una opción excelente para cualquier tarea relacionada con RPA. Para interactuar con aplicaciones web, la biblioteca Selenium permite automatizar tareas dentro del navegador, lo que es fundamental para comprobar logins en plataformas como Moodle.

Selenium: Automate Web Browsing

Selenium es una herramienta de automatización de navegadores web que permite interactuar con las páginas, simular clics, llenado de formularios, y validaciones, entre otras acciones. Para nuestro caso, Selenium se utilizará para automatizar la comprobación de logins en Moodle, de forma que el sistema puede verificar si el acceso es correcto o si el login ha fallado, todo sin intervención manual.

FastAPI: Desarrollando una API para la Integración

FastAPI es un moderno framework para la construcción de APIs en Python. Con su enfoque en el rendimiento y facilidad de uso, FastAPI permite crear interfaces web que interactúan de manera eficiente con nuestros bots de automatización. Con FastAPI, podemos construir un servicio backend que recibe las solicitudes de login y responde con los resultados de las comprobaciones.

Paso 1: Configuración del Entorno, creación del fichero .env

Una vez instaladas todas las librerías necesarias para poner en marcha el tutorial deberemos crear el fichero de configuración tipo .env en la raíz del proyecto para almacenar las credenciales de acceso a Moodle.
El fichero .env es un fichero de configuración que se utiliza para almacenar variables de entorno. Estas variables suelen contener información sensible o configuraciones específicas del entorno en el que se ejecuta una aplicación, como credenciales de acceso, claves de API, URLs de bases de datos, o ajustes de comportamiento.

¿Por qué usar un fichero .env en lugar de hardcodear los datos en el código?

1. Seguridad

• Evita exponer información sensible: Si incluyes credenciales directamente en el código fuente, cualquier persona con acceso al código podría verlas. Esto es especialmente peligroso si el código se sube a un repositorio público (como GitHub).
• Protección en entornos compartidos: Al usar un fichero .env, puedes excluirlo de los sistemas de control de versiones (como Git) agregándolo al fichero .gitignore. Esto asegura que las credenciales no se compartan accidentalmente.

2. Flexibilidad

• Configuraciones específicas por entorno: Puedes tener diferentes ficheros .env para distintos entornos (desarrollo, pruebas, producción). Por ejemplo, las credenciales de desarrollo pueden ser diferentes a las de producción.
• Cambios sin modificar el código: Si necesitas cambiar una credencial o configuración, solo debes modificar el fichero .env, sin tocar el código fuente.

3. Facilidad de mantenimiento

• Legibilidad del código: El código fuente no se llena de valores hardcodeados, lo que lo hace más limpio y fácil de entender.
• Centralización de configuraciones: Todas las configuraciones están en un solo lugar, lo que facilita su gestión y actualización.

Creación del fichero .env

Este fichero debe contener lo siguiente:

MOODLE_LOGIN_URL = https://sandbox.moodledemo.net/login/index.php
MOODLE_USERNAME  = admin
MOODLE_PASSWORD  = sandbox24

Web de pruebas de Moodle

En nuestro caso utilizaríamos un acceso web de nuestro cliente, pero dado que esto es un tutorial y no podemos mostrar datos reales, utilizaremos el login de Moodle 4.5 Sandbox, que podemos encontrar en https://sandbox.moodledemo.net/login/index.php y tiene el aspecto que vemos en la siguiente captura de pantalla.

Paso 2: Automatizar el Login con Selenium

En este paso, crearemos un script en Python que utiliza Selenium para automatizar el proceso de inicio de sesión en Moodle 4.3. El objetivo es validar si las credenciales almacenadas en el fichero .env funcionan correctamente. A continuación, desglosamos el código y explicamos cada componente clave.

Crearemos un fichero moodle_login.py y le introduciremos el siguiente código:

# moodle_login.py
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.chrome.options import Options
import time
import os
from dotenv import load_dotenv
import json

# Cargar credenciales desde .env
load_dotenv()
MOODLE_USERNAME = os.getenv("MOODLE_USERNAME")
MOODLE_PASSWORD = os.getenv("MOODLE_PASSWORD")

# Función para comprobar el login
def check_moodle_login():
    try:
        # Configurar ChromeDriver
        chrome_options = Options()
        chrome_options.add_argument("--headless")  # Ejecutar en modo headless
        chrome_options.add_argument("--disable-gpu")
        chrome_options.add_argument("--no-sandbox")
        chrome_options.add_argument("--disable-dev-shm-usage")

        # Ruta al ChromeDriver (ajusta según tu sistema)
        driver_path = "./chromedriver"
        service = Service(driver_path)
        driver = webdriver.Chrome(service=service, options=chrome_options)

        # Navegar a la página de login de Moodle
        driver.get(os.getenv("MOODLE_LOGIN_URL"))

        # Esperar a que la página cargue
        time.sleep(2)

        # Rellenar el formulario de login
        username_field = driver.find_element(By.ID, "username")
        password_field = driver.find_element(By.ID, "password")

        username_field.send_keys(MOODLE_USERNAME)
        password_field.send_keys(MOODLE_PASSWORD)

        # Hacer clic en el botón de login
        login_button = driver.find_element(By.ID, "loginbtn")
        login_button.click()

        # Esperar a que el login se complete
        time.sleep(5)

        # Verificar si el login fue con éxito
        if ("/dashboard" or "/my" or "https://sandbox.moodledemo.net/") in driver.current_url:
            result = {"login_successful": True}
        else:
            result = {"login_successful": False}

        # Cerrar el navegador
        driver.quit()

        return result

    except Exception as e:
        print(f"Error: {e}")
        return {"login_successful": False}

# Ejecutar la función y devolver el resultado en JSON
if __name__ == "__main__":
    result = check_moodle_login()
    print(json.dumps(result, indent=4))

Explicación Detallada del Código

1. Importación de Librerías

• selenium: Para interactuar con el navegador web.
• time: Para añadir pausas (esperas) entre acciones.
• os y dotenv: Para acceder a las variables de entorno del fichero .env.
• json: Para devolver el resultado en formato JSON.
  

2. Configuración de ChromeDriver

• Modo Headless:
  • .--headless: Ejecuta Chrome en segundo plano (sin interfaz gráfica), útil para servidores o entornos sin pantalla.
• Opciones de Rendimiento:
  • --disable-gpu: Desactiva la aceleración por GPU (recomendado en modo headless).
  • --no-sandbox: Desactiva el sandboxing para evitar conflictos en entornos restringidos.
  • --disable-dev-shm-usage: Evita errores de memoria en contenedores Docker o servidores.

3. Navegación a la Página de Login

• driver.get(os.getenv("MOODLE_LOGIN_URL")): Abre la página de login de Moodle, indicada en el fichero .env, en la variable MOODLE_LOGIN_URL .
• time.sleep(5): Espera 5 segundos para asegurar que la página cargue completamente.
  • Nota: En proyectos reales, se recomienda usar esperas implícitas o explícitas (WebDriverWait) en lugar de time.sleep() para mayor eficiencia.

4. Localización de Elementos HTML

• find_element(By.ID, "id"): Localiza los campos de usuario y contraseña por su atributo id (en este caso, username y password).
• send_keys(): Simula la escritura de texto en los campos del formulario.

5. Ejecución del Login

• login_button.click(): Hace clic en el botón de login (identificado por id="loginbtn").
• time.sleep(3): Espera 3 segundos para que el proceso de login se complete.

6. Verificación del Login con éxito

• driver.current_url: Comprueba si la URL actual contiene la palabra my, que suele aparecer tras un login con éxito en Moodle.
• driver.quit(): Cierra el navegador y libera recursos.

7. Manejo de Excepciones

• try/except: Captura cualquier error durante la ejecución (ej: elementos no encontrados, tiempo de espera agotado) y devuelve {"login_successful": False}.

from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

username_field = WebDriverWait(driver, 10).until(
    EC.presence_of_element_located((By.ID, "username"))
)

# moodle_login.py
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
import os
from dotenv import load_dotenv
import json

# Cargar credenciales desde .env
load_dotenv()
MOODLE_USERNAME = os.getenv("MOODLE_USERNAME")
MOODLE_PASSWORD = os.getenv("MOODLE_PASSWORD")

# Función para comprobar el login
def check_moodle_login():
    try:
        # Configurar ChromeDriver
        chrome_options = Options()
        chrome_options.add_argument("--headless")  # Ejecutar en modo headless
        chrome_options.add_argument("--disable-gpu")
        chrome_options.add_argument("--no-sandbox")
        chrome_options.add_argument("--disable-dev-shm-usage")

        # Ruta al ChromeDriver (ajusta según tu sistema)
        driver_path = "./chromedriver"
        service = Service(driver_path)
        driver = webdriver.Chrome(service=service, options=chrome_options)

        # Navegar a la página de login de Moodle
        driver.get(os.getenv("MOODLE_LOGIN_URL"))

        # Esperar a que los campos de login estén disponibles
        wait = WebDriverWait(driver, 10)
        username_field = wait.until(EC.presence_of_element_located((By.ID, "username")))
        password_field = wait.until(EC.presence_of_element_located((By.ID, "password")))

        # Rellenar el formulario de login
        username_field.send_keys(MOODLE_USERNAME)
        password_field.send_keys(MOODLE_PASSWORD)

        # Hacer clic en el botón de login
        login_button = wait.until(EC.element_to_be_clickable((By.ID, "loginbtn")))
        login_button.click()

    
        # Verificar si el login fue con éxito
        if "/dashboard" in driver.current_url or "/my" in driver.current_url or "https://sandbox.moodledemo.net/" in driver.current_url:
            result = {"login_successful": True}
        else:
            result = {"login_successful": False}



        # Cerrar el navegador
        driver.quit()

        return result

    except Exception as e:
        print(f"Error: {e}")
        return {"login_successful": False}

# Ejecutar la función y devolver el resultado en JSON
if __name__ == "__main__":
    result = check_moodle_login()
    print(json.dumps(result, indent=4))

# .env
CHROME_DRIVER_PATH=./chromedriver

Paso 3: Cómo Crear una API REST con FastAPI para Monitorización de Login en Moodle

En este paso del tutorial, encapsularemos la funcionalidad de login en una API REST utilizando FastAPI. Este paso es crucial porque transforma nuestra automatización de login en un servicio accesible y reutilizable, que puede ser consumido por otros sistemas, aplicaciones, o herramientas de monitoreo. A continuación, te explico la motivación, el desarrollo y cómo esta API puede ser utilizada para monitorización.

FastAPI es un framework web moderno y de alto rendimiento para construir APIs utilizando Python. Es conocido por ser rápido, sencillo y compatible con las últimas características del lenguaje Python, como las anotaciones de tipo. Se basa en Starlette (un framework ligero para aplicaciones web) y Pydantic (una biblioteca para validación de datos), lo que lo hace potente y fácil de usar.

¿Por Qué Usar FastAPI para Automatizar el Login en Moodle?

1. Alto rendimiento y eficiencia:
   • FastAPI está diseñado para manejar aplicaciones web de alto rendimiento, lo que significa que puede gestionar múltiples solicitudes concurrentes de manera eficiente gracias a su uso de Python asincrónico (async/await).
   • Esto lo hace ideal para servicios que requieren responder rápidamente, como APIs de monitorización.
2. Simplicidad y rapidez en el desarrollo:
   • La sintaxis es intuitiva y declarativa, lo que facilita la escritura de APIs con poco código repetitivo.
   • Con la ayuda de anotaciones de tipo, puedes definir rutas y parámetros de forma clara y concisa.
3. Documentación interactiva automática:
   • FastAPI genera automáticamente una documentación interactiva basada en OpenAPI (Swagger UI y ReDoc). Esto permite probar y explorar las rutas de la API directamente desde un navegador.
   • Es una ventaja clave para desarrolladores y equipos que necesitan entender y probar la API rápidamente.
4. Soporte para asincronía:
   • Gracias a su integración con funciones async, permite realizar tareas de entrada/salida (como peticiones HTTP o interacciones con bases de datos) de manera no bloqueante, mejorando el rendimiento general.
5. Facilidad de integración:
   • FastAPI es fácilmente integrable con otras bibliotecas y herramientas de Python. En este caso, puedes utilizarlo con Selenium para encapsular la funcionalidad de login automatizado en un endpoint REST.

Motivación del Paso 3

Este tutorial estaría incompleto sin el Paso 3, ya que limitaría la ejecución del script de RPA únicamente a un entorno local, reduciendo su utilidad práctica. El desarrollo de una API es esencial porque permite:

1. Ampliar el alcance y accesibilidad:
   • Al exponer el script como un endpoint REST, otros sistemas pueden consumirlo de manera remota, eliminando la dependencia del entorno local.
   • Esto facilita su integración en una infraestructura más amplia.
2. Integración con sistemas de monitorización serios:
   • Herramientas como Nagios, Zabbix, Prometheus, entre otras, permiten monitorizar la salud y el estado de diversos componentes de un sistema.
   • Al desarrollar una API, el script puede ser integrado como una comprobación adicional dentro de estas herramientas, garantizando que todo funciona correctamente.
3. Automatización avanzada y supervisión centralizada:
   • Una API facilita la automatización de tareas de verificación en lugar de depender de ejecuciones manuales.
   • Esto mejora la supervisión centralizada de sistemas, proporcionando alertas en tiempo real si algo falla.
4. Un caso de uso más realista:
   • Los scripts de RPA suelen ser parte de procesos más grandes y no una solución aislada. El desarrollo de una API ayuda a entender cómo estos scripts pueden formar parte de flujos de trabajo empresariales o de sistemas más robustos.

Por lo tanto, el desarrollo de la API no solo enriquece el tutorial, sino que también muestra un enfoque práctico y profesional al implementar este tipo de soluciones en entornos de producción reales.

Tutorial Paso a Paso: Crear una API con FastAPI y Selenium

1. Estructura del Proyecto

Antes de comenzar, asegúrate de que tu proyecto tenga la siguiente estructura:

moodle_login/
│
├── .env
├── moodle_login.py
├── main.py
└── requirements.txt

2. Código de la API (main.py)

En esta sección crearemos el código para poder utilizar la funcionalidad desarrollada en el paso 2 dentro de una aplicación FastAPI. Este código lo almacenaremos en el fichero main.py

from fastapi import FastAPI
from pydantic import BaseModel
from moodle_login import check_moodle_login
import uvicorn

# Crear la aplicación FastAPI
app = FastAPI()

# Modelo de respuesta
class LoginResponse(BaseModel):
    login_successful: bool

# Ruta para comprobar el login
@app.get("/check-login", response_model=LoginResponse)
def check_login():
    result = check_moodle_login()
    return result

# Servir en el puerto 8000
if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

3. Explicación del Código

• app = FastAPI(): Inicializa una nueva aplicación FastAPI.
• LoginResponse: Define la estructura de la respuesta JSON ({"login_successful": true/false}).
• @app.get("/check-login"): Crea un endpoint HTTP GET en la ruta /check-login.
• check_login(): Llama a la función check_moodle_login() y devuelve su resultado.
• uvicorn.run(): Inicia el servidor Uvicorn para ejecutar la API.

Cómo Usar la API de Login para Monitorización en Tiempo Real

Una vez que la API está en funcionamiento, puede ser utilizada para monitorizar el estado del login de Moodle. Aquí te explico cómo:

1. Verificación Manual

Puedes acceder a la API desde un navegador o usando curl:

$ curl -X GET "http://127.0.0.1:8000/check-login"

Si todo ha ido correctamente, la respuesta sería

{
  "login_successful": true
}

En caso contrario o que ocurriera cualquier error, la respuesta sería

{
  "login_successful": falso
}

2. Integración con Herramientas de Monitoreo

• Prometheus + Grafana:
  • Configura Prometheus para hacer solicitudes HTTP periódicas a la API.
  • Usa Grafana para visualizar el estado del login en un panel de control.
• Nagios:
  • Crea un chequeo personalizado en Nagios que utilice la API para verificar el login.
• Cron Jobs:
  • Configura un cron job en Linux para ejecutar curl periódicamente y registrar los resultados.

3. Alertas Automáticas

• Si la API devuelve {"login_successful": false}, puedes configurar alertas para notificar al equipo de soporte (por ejemplo, mediante correo electrónico, Slack, o Telegram).

Ejecución de la API

1. Iniciar la API:

Ejecuta el siguiente comando en la terminal:

$ python main.py

Esto hará que arranque FastAPI y empiece a servir la API en la URL http://127.0.0.1:8000 .

2. Acceder a la documentación (Swagger UI):
FastAPI genera automáticamente una interfaz de documentación interactiva (Swagger UI) en http://127.0.0.1:8000/docs .

3. Probar el endpoint:

Utiliza curl, Postman o tu navegador para acceder a http://127.0.0.1:8000/check-login

Conclusión: Automatización y Monitorización con FastAPI, Selenium y Moodle

En este tutorial, hemos desarrollado una solución integral para automatizar la comprobación del login de Moodle 4.3 utilizando tecnologías como Python, Selenium, ChromeDriver, y FastAPI. Este enfoque no solo facilita la verificación del acceso de manera eficiente, sino que encapsula la funcionalidad en una API REST lista para integrarse en otros sistemas y herramientas de monitorización. A continuación, recapitulamos los puntos clave y las conclusiones más importantes:

1. Automatización del Login con Selenium

• Objetivo: Simulamos la interacción de un usuario con el formulario de inicio de sesión en Moodle, incluyendo el ingreso de credenciales y la validación del resultado.
• Beneficios:
  • Ahorro de tiempo: Se eliminan pruebas manuales repetitivas.
  • Precisión: Minimiza los errores humanos en las pruebas.
  • Escalabilidad: Permite ejecutarse en diferentes entornos y navegadores.

2. Gestión de Credenciales con un Fichero .env

• Objetivo: Centralizamos las credenciales de acceso en un archivo .env para mejorar la seguridad y la flexibilidad.
• Beneficios:
  • Mayor seguridad: Las credenciales no quedan expuestas en el código fuente.
  • Configuración flexible: Cambios en las credenciales sin alterar el código.
  • Portabilidad: Adaptación sencilla a distintos entornos (desarrollo, pruebas, producción).

3. Creación de una API REST con FastAPI

• Objetivo: Convertimos la funcionalidad del login automatizado en una API accesible desde cualquier sistema conectado a la red.
• Beneficios:
  • Acceso remoto: Posibilidad de ejecutar la verificación desde cualquier lugar.
  • Integración sencilla: Conexión con herramientas externas y sistemas de monitorización.
  • Supervisión proactiva: Generación de alertas en tiempo real sobre el estado del login.

4. Aplicaciones Prácticas

• Monitorización continua: Integración con herramientas como Prometheus, Grafana o Nagios para verificar periódicamente el estado del login.
• Integración con aplicaciones: Uso en apps móviles o web para validar credenciales antes de conceder acceso a funcionalidades específicas.
• Automatización en DevOps: Uso en pipelines de CI/CD para garantizar el funcionamiento del login tras cada despliegue.

5. Buenas Prácticas Implementadas

• Seguridad: Uso de un fichero .env para proteger credenciales, excluyéndolo del control de versiones.
• Manejo de errores: Captura y registro de errores para facilitar la depuración.
• Eficiencia en las pruebas: Uso de WebDriverWait en lugar de time.sleep() para optimizar el script.
• Documentación automatizada: FastAPI genera una interfaz interactiva que facilita el uso y la comprensión de la API.

6. Posibles Mejoras Futuras

• Protección del endpoint: Añadir autenticación a la API mediante claves de acceso (API keys) o tokens JWT.
• Despliegue en la nube: Implementar la API con servidores como Gunicorn para manejar solicitudes simultáneas.
• Nuevas funcionalidades: Extender la API para verificar otros endpoints de Moodle o generar reportes detallados.

7. Conclusión Final

Este tutorial muestra cómo integrar Python, Selenium y FastAPI para crear una solución eficiente y escalable que automatiza la verificación del login en Moodle. La encapsulación de esta funcionalidad en una API REST no solo simplifica su uso, sino que también permite su integración en sistemas más amplios, como herramientas de monitorización y flujos de trabajo automatizados.

Este enfoque no se limita a Moodle: puede adaptarse fácilmente a otras aplicaciones web o sistemas que requieran pruebas automatizadas de inicio de sesión. Las técnicas y buenas prácticas aquí descritas son un recurso valioso para cualquier proyecto de automatización o desarrollo de software.

¿Qué Te Pareció Este Tutorial?

Si este tutorial te resultó útil, ¡compártelo en tus redes sociales para que otros también puedan beneficiarse de esta solución! Además, si tienes alguna pregunta, sugerencia o simplemente quieres compartir tu experiencia, ¡no dudes en dejarme un comentario abajo! Estaré encantado de ayudarte y escuchar tus ideas.