Si alguna vez has gestionado una plataforma educativa como Moodle, seguro que te suenan esas escenas: un plugin que se rompe el lunes por la mañana, un cron que no corre bien y te avisa tarde, o ese mensaje de “¿alguien ha hecho backup antes de actualizar?”. Y sí, también esos domingos de pánico que muchos hemos vivido.

En este artículo te cuento cómo abordamos las automatizaciones edTech desde la visión de un CTO, transformando cada uno de esos dolores en soluciones eficientes que nos permiten ganar tiempo, fiabilidad y tranquilidad.

Soy Andrés, CTO de Entornos de Formación (EDF), y quiero compartir contigo historias reales, aprendizajes y herramientas que hemos aplicado para convertir el caos en procesos automatizados. Porque automatizar no es un lujo: es, cada vez más, la única forma sostenible de trabajar bien en el mundo edTech.

¿Por qué apostamos por automatizaciones edTech?

Porque creemos que la tecnología está al servicio de la educación, y no al revés. Porque sabemos que un equipo técnico motivado, sin tareas tediosas ni fuegos que apagar cada día, puede centrarse en lo que realmente transforma. Y porque, desde Entornos de Formación, acompañamos cada año a decenas de universidades y centros educativos para que sus plataformas sean estables, rápidas, actualizadas… y seguras.

Como CTO, trabajo en un entorno donde la tecnología no se limita a mantener los servidores en marcha. Su función es asegurar que miles de estudiantes accedan sin problemas a sus cursos, y que el profesorado disponga de una herramienta fiable para enseñar. Pero para lograrlo, no basta con código: hay que escuchar, observar y entender a todas las personas implicadas en el proceso educativo.

Ese enfoque me ha permitido diseñar soluciones técnicas con impacto real. Soluciones que eliminan errores recurrentes, que nos devuelven horas de trabajo y que liberan al equipo para enfocarse en lo importante.

Y, siendo sincero, pocas cosas me dan tanta satisfacción como tachar una tarea repetitiva de la lista… sabiendo que gracias a una automatización, ya no volverá a aparecer.

Por eso, desde hace años, apostamos fuerte por las automatizaciones edTech: desde actualizaciones críticas hasta tareas rutinarias. No se trata de magia. Se trata de aplicar bien la tecnología, para dejar de perder el tiempo en lo mecánico y dedicarnos a lo humano: crear, pensar, mejorar.

Una historia real: 2 de la madrugada, Moodle y un permiso olvidado

Eran las 2 de la madrugada de un martes. El aula virtual Moodle de un cliente estaba caído. La web lanzaba un error 500 y nadie podía acceder. ¿La causa? Un cambio involuntario en los permisos de una carpeta crítica.

El problema no era solo técnico, sino también geográfico: el cliente se encontraba al otro lado del mundo, en plena jornada laboral y lectiva. La caída no solo interrumpía clases en directo, sino que dejaba a cientos de estudiantes sin acceso a materiales, foros y tareas. El impacto era inmediato y real.

Como administrador de sistemas, ya me había enfrentado antes a este tipo de situaciones: carpetas como moodledata, mod o incluso theme con permisos incorrectos tras una restauración manual o una actualización rápida mal rematada. Pero esa noche, con sueño acumulado y poco margen de maniobra, supe que esto no podía volver a pasar.

Al día siguiente, decidí automatizar una solución preventiva. Escribí un sencillo script en Bash que, cada madrugada, revisa y corrige los permisos de las carpetas más sensibles de Moodle. Compara los permisos actuales con los valores definidos como seguros en un archivo de configuración y, si detecta alguna discrepancia, la corrige automáticamente. Para cerrar el ciclo, me envía un correo notificando cualquier cambio.

Desde entonces, ni una sola llamada de emergencia por ese motivo.
Esa es la magia de las pequeñas automatizaciones: no solo resuelven el problema, te devuelven el control, la energía… y los domingos tranquilos.
Y lo reconozco, cada mañana que reviso los logs del script y todo está en verde, sonrío con satisfacción.

Script en Bash para comprobar y corregir permisos en Moodle:

#!/bin/bash
LOGFILE="/var/log/moodle-permissions.log"

# Corrige permisos de directorios
find /var/www/moodle -type d ! -perm 755 -exec chmod 755 {} \;

# Corrige permisos de archivos
find /var/www/moodle -type f ! -perm 644 -exec chmod 644 {} \;

# Registro
echo "$(date) - Permisos revisados y corregidos si era necesario" >> $LOGFILE

Una solución tan sencilla como eficaz, que encaja perfectamente con nuestra filosofía: automatizaciones edTech al servicio de la estabilidad, sin importar la franja horaria ni el continente.

Una madrugada de migración… sin sustos

Otra de esas noches largas —pero memorables— fue cuando migramos un Moodle con más de 1.200 usuarios activos, decenas de cursos, foros, tareas y registros desde el año 2015. La planificación fue minuciosa y, aun así, los nervios estaban ahí. Migrar una plataforma crítica no es un trámite, y lo sabíamos.

Sin embargo, esa vez fue diferente. Gracias a nuestras automatizaciones edTech desde la visión de un CTO, desplegamos scripts de verificación, backups programados y un proceso documentado paso a paso. Como resultado, a las 06:00 la nueva versión 4.5 ya estaba online, estable, con todos los datos migrados y accesos funcionando.

Durante las pruebas, analizamos a fondo la tabla mdl_logstore_standard_log para asegurarnos de que no se había perdido ninguna acción registrada. Confirmamos que los accesos funcionaban correctamente, que la navegación era fluida y que los logs continuaban recogiendo eventos posteriores con normalidad.

De hecho, esa tabla fue uno de los mayores retos: contenía casi una década de actividad. Solo su migración tardó unas 8 horas. Afortunadamente, no fue un cuello de botella. Antes de lanzar la operación, escalamos automáticamente la memoria RAM del servidor de base de datos y ajustamos valores críticos como innodb_buffer_pool_size, join_buffer_size, max_connections, entre otros.

Además, activamos la compresión de tablas temporales y extendimos los timeouts para que ningún proceso fallara por falta de recursos.

En resumen, la migración fue un éxito técnico… y humano. Nadie perdió acceso, nadie reportó errores. Lo único que cambió fue el diseño actualizado del tema. Y yo, en vez de estar apagando fuegos al amanecer, me fui a dormir con una sonrisa profesional de esas que solo da el trabajo bien hecho.

📝 Todo el proceso está documentado. Si tú también quieres planificar tu migración sin sobresaltos, échale un vistazo a este artículo: Mantén tu Moodle al Día: Guía Profesional para una actualización con éxito.

Backups automáticos: el seguro invisible

¿Quién no ha sentido ese escalofrío después de actualizar un plugin en Moodle y no recordar si hizo backup?

Automatizar las copias de seguridad puede no parecer glamuroso, pero es como llevar puesto el cinturón de seguridad: no lo notas… hasta que te salva. Y en el mundo edTech, evitar una pérdida de datos puede marcar la diferencia entre un lunes tranquilo o uno de auténtico caos.

Aunque Amazon RDS realiza snapshots automáticos, no todos nuestros clientes trabajan en AWS. Muchos cuentan con infraestructuras propias, alojadas en sus datacenters o en servicios de hosting dedicados. Por ello, aplicamos una política clara: mantener siempre una copia adicional en Amazon S3. Esta estrategia nos ofrece redundancia, control y tranquilidad. Es, literalmente, como guardar una copia en la nube… y otra bajo el colchón.

Nuestro proceso habitual

Para garantizar una copia de seguridad completa en cualquier instalación de Moodle, seguimos este flujo dentro de nuestras automatizaciones edTech:

1. Backup de la base de datos
   Usamos mysqldump para exportar la base de datos completa:

mysqldump -u moodle_user -p'MiPasswordSegura' moodle > /var/backups/moodle/moodle_db_$(date +%F).sql

2. Backup del código fuente de Moodle
Utilizamos rsync para copiar el contenido de /var/www/moodle:

rsync -avz /var/www/moodle/ /var/backups/moodle/code_$(date +%F)/

3. Backup del directorio de datos (moodledata)
Este directorio contiene archivos subidos por los usuarios. También lo copiamos con rsync:

rsync -avz /var/moodledata/ /var/backups/moodle/moodledata_$(date +%F)/

4. Subida automática a S3

Un script en Python con Boto3 gestiona la sincronización con nuestro bucket:.

import boto3
import os
from datetime import datetime

s3 = boto3.client('s3')
backup_dir = '/var/backups/moodle/'
bucket_name = 'mi-bucket-s3'
date_str = datetime.now().strftime('%Y-%m-%d')

for filename in os.listdir(backup_dir):
    if filename.endswith('.sql') or filename.endswith('.tar.gz'):
        file_path = os.path.join(backup_dir, filename)
        s3.upload_file(file_path, bucket_name, f"backups/{date_str}/{filename}")
        print(f"Subido: {filename}")

5. Automatización con cron
0 3 * * * /usr/local/bin/moodle_backup.sh

Gracias a esta automatización, podemos estar seguros de que ningún cambio importante se realiza sin red de seguridad. Y esa certeza, cuando gestionas plataformas educativas, no tiene precio.

Usuarios de prueba en segundos

Crear 100 usuarios manualmente es como escribir un libro con pluma: bonito al principio, pero innecesariamente largo. Gracias a las automatizaciones edTech, ahora lo resolvemos en segundos con Python y Faker.

Generamos usuarios con nombres realistas, correos únicos, ciudades y países. Cada usuario se inserta solo si no existe previamente y se matricula automáticamente en un curso de prueba. Esta técnica es ideal para entornos de desarrollo, demostración o pruebas de carga en Moodle.

Script en Python con Faker

from faker import Faker
import bcrypt

fake = Faker('es_ES')

for i in range(1, 101):
    firstname = fake.first_name()
    lastname = fake.last_name()
    email = fake.email()
    city = fake.city()
    country = fake.current_country()
    username = f"testuser{i:03d}"
    password_plain = 'Password123!'
    password_hashed = bcrypt.hashpw(password_plain.encode('utf-8'), bcrypt.gensalt()).decode()

    print(f"INSERT INTO mdl_user (auth, confirmed, mnethostid, username, password, firstname, lastname, email, city, country, timecreated, timemodified)
"
          f"SELECT 'email', 1, 1, '{username}', '{password_hashed}', '{firstname}', '{lastname}', '{email}', '{city}', '{country}', UNIX_TIMESTAMP(), UNIX_TIMESTAMP()
"
          f"WHERE NOT EXISTS (SELECT 1 FROM mdl_user WHERE username = '{username}');")

Este script genera automáticamente los INSERT listos para ejecutar directamente si el usuario aún no existe.

Matriculación masiva al curso de pruebas

Una vez creados, podemos matricularlos en el curso con ID 3 usando esta consulta SQL:

INSERT INTO mdl_user_enrolments (enrolid, userid, timestart, timecreated, timemodified)
SELECT 5, id, UNIX_TIMESTAMP(), UNIX_TIMESTAMP(), UNIX_TIMESTAMP()
FROM mdl_user
WHERE username LIKE 'testuser%';

Automatizaciones para entornos de demo personalizados

En Entornos de Formación, contamos con un entorno de Moodle preparado específicamente para demostraciones y pruebas. Lo utilizamos para mostrar a cada cliente cómo podría ser su plataforma educativa personalizada, sin necesidad de partir desde cero cada vez.

Gracias a una serie de automatizaciones edTech, podemos configurar en minutos un entorno completamente funcional, visualmente adaptado y listo para ser probado.

¿Cómo lo hacemos?

1. Instalamos Moodle automáticamente con Ansible, usando nuestro playbook de despliegue rápido.
   
2. Restauramos un dump de MySQL que contiene una versión base de Moodle preconfigurada: con un tema visual, bloques activos, configuraciones habituales y un curso de demostración.
   Para restaurarlo, usamos:

mysql -u moodle_user -p'MiPasswordSegura' moodleDatabase < /var/backups/moodle/moodle_demo_dump.sql

3. Ejecutamos un script en Python que lee un fichero JSON con los datos de personalización del cliente (colores, logotipo, fuentes, copyright…). Este script actualiza la configuración del theme en las tablas mdl_config y mdl_config_plugins, y copia los archivos gráficos mediante rsync.

Ejemplo de JSON para un cliente:

{
  "client_name": "Centro Educativo XYZ",
  "primary_color": "#004488",
  "secondary_color": "#ffaa00",
  "text_color": "#222222",
  "background_color": "#ffffff",
  "logo_path": "/home/moodleDemo/clientes/xyz/logo.png",
  "favicon_path": "/home/moodleDemo/clientes/xyz/favicon.ico",
  "footer_logo_path": "/home/moodleDemo/clientes/xyz/logo-footer.png",
  "login_background": "/home/moodleDemo/clientes/xyz/login-bg.jpg",
  "theme_font": "Open Sans",
  "copyright": "© 2025 Centro Educativo XYZ. Todos los derechos reservados."
}

Script en Python para aplicar los cambios visuales
Este ejemplo está pensado para un child theme de Boost llamado boost_custom

import json
import pymysql
import subprocess

with open('cliente_config.json') as f:
    config = json.load(f)

conn = pymysql.connect(host='localhost', user='root', password='MiPasswordSegura', db='moodle')
cursor = conn.cursor()

# Usamos un child theme de Boost llamado "boost_custom"
theme = 'theme_boost_custom'

cursor.execute(f"UPDATE mdl_config_plugins SET value=%s WHERE plugin='{theme}' AND name='brandcolor'", (config['primary_color'],))
cursor.execute(f"UPDATE mdl_config_plugins SET value=%s WHERE plugin='{theme}' AND name='secondarycolor'", (config['secondary_color'],))
cursor.execute(f"UPDATE mdl_config_plugins SET value=%s WHERE plugin='{theme}' AND name='backgroundcolor'", (config['background_color'],))
cursor.execute(f"UPDATE mdl_config_plugins SET value=%s WHERE plugin='{theme}' AND name='fontname'", (config['theme_font'],))
cursor.execute(f"UPDATE mdl_config_plugins SET value=%s WHERE plugin='{theme}' AND name='copyright'", (config['copyright'],))
conn.commit()

cursor.close()
conn.close()

# Copiar archivos gráficos
subprocess.run(["rsync", "-avz", config['logo_path'], f"/var/www/moodle/theme/boost_custom/pix/logo.png"])
subprocess.run(["rsync", "-avz", config['favicon_path'], f"/var/www/moodle/theme/boost_custom/pix/favicon.ico"])
subprocess.run(["rsync", "-avz", config['footer_logo_path'], f"/var/www/moodle/theme/boost_custom/pix/footer-logo.png"])
subprocess.run(["rsync", "-avz", config['login_background'], f"/var/www/moodle/theme/boost_custom/pix/login-bg.jpg"])

Con este enfoque, podemos ofrecer a cada institución una vista previa realista de su futuro Moodle. Y lo más importante: lo hacemos en cuestión de minutos, sin errores manuales ni tiempos muertos.

Automatizaciones edTech para la salud del servidor y SSL

Uno de nuestros mayores compromisos como equipo técnico es simple pero esencial: que los clientes no se enteren de los problemas… porque no llegan a ocurrir.

Para lograrlo, hemos diseñado un conjunto de automatizaciones edTech que monitorizan continuamente el estado de las plataformas Moodle y gestionan tareas críticas como la renovación de certificados SSL, sin intervención humana.

Monitorización proactiva para Moodle

Contamos con sistemas que revisan continuamente:

• El estado de los servicios Apache, PHP y MySQL, usando Prometheus junto con alertas automáticas en Slack.
• El acceso a la plataforma, mediante un login automático con Selenium y FastAPI que simula la experiencia de usuario. Si Moodle no responde, lo sabemos antes de que el cliente lo note.

Así, podemos anticiparnos a cualquier caída y actuar en cuestión de segundos.

Renovación automática de certificados SSL

Muchos de nuestros clientes utilizan certificados gratuitos de Let’s Encrypt. Otros, especialmente en entornos de pruebas o laboratorios, no cuentan con certificados wildcard. En todos esos casos, automatizamos completamente la renovación SSL con Certbot.

Nuestro flujo incluye:

1. Verificación y renovación con certbot renew.
2. Reinicio automático de Apache o Nginx si el certificado ha sido actualizado.
3. Alerta por correo o Slack si el certificado caduca en menos de 7 días.

Nuestro proceso para renovar certificados incluye:

1. Verificación con certbot renew.
2. Reinicio automático de Apache o Nginx si el certificado se actualiza.
3. Alerta vía correo o Slack si queda menos de 7 días de validez.

Script en Python para controlar fechas de caducidad

Este pequeño script se ejecuta cada madrugada desde la propia máquina del cliente. Si detecta que queda menos de una semana para que el certificado expire, lanza la renovación:

import ssl, socket, datetime
from subprocess import run

hostname = 'moodle.midominio.com'
context = ssl.create_default_context()
with socket.create_connection((hostname, 443)) as sock:
    with context.wrap_socket(sock, server_hostname=hostname) as ssock:
        cert = ssock.getpeercert()
        expiry = datetime.datetime.strptime(cert['notAfter'], '%b %d %H:%M:%S %Y %Z')
        days_left = (expiry - datetime.datetime.utcnow()).days

        if days_left < 7:
            run(["certbot", "renew"])
            run(["systemctl", "reload", "apache2"])
            print(f"Renovado el certificado SSL. Caducaba en {days_left} días.")

Con este sistema de vigilancia silenciosa, garantizamos plataformas seguras y funcionales. Y lo mejor: el cliente no tiene que preocuparse de nada.

Reflexión final: menos ruido, más impacto

Automatizar no va solo de ahorrar tiempo o reducir errores. Es, sobre todo, una forma de recuperar el control. De liberar la mente del ruido operativo y reenfocarla en lo que realmente transforma: crear, pensar, liderar.

Cada automatización que hemos implementado en Entornos de Formación —por pequeña que parezca— nos ha hecho un poco mejores. Más rápidos, sí. Pero también más serenos, más organizados y, en definitiva, más felices en nuestro trabajo diario.

Además, automatizar te obliga a entender. A detenerte, observar el proceso y documentarlo. Y eso mejora no solo tu productividad, sino también la del equipo, facilitando el onboarding de nuevas personas y construyendo una cultura técnica más sólida.

Porque no se trata de evitar el trabajo duro, sino de reservarlo para los desafíos que lo merecen. Es decirle a tu equipo: “esto ya no lo vamos a sufrir más”. Y cumplirlo.

Piensa en cada script como una promesa:
esto ya no volverá a ser un problema.

Y créeme, cuando llevas unas cuantas de esas promesas cumplidas, no hay vuelta atrás. Solo puedes avanzar.

¿Qué automatización vas a implementar hoy?

¿Tienes una tarea que odias repetir? Hoy es el día.
Hazme caso: tu yo del futuro te lo agradecerá.

Como decimos en el equipo:

«El mejor script es el que te quita el estrés.»

¡Cuéntamelo en los comentarios!