Forem: Daniel J. Saldaña

Cómo crear un podcast generado con IA usando Azure

Daniel J. Saldaña — Mon, 23 Mar 2026 23:24:20 +0000

Llevo tiempo viendo cómo los podcasts no paran de crecer en popularidad. Cada vez somos más los que preferimos consumir contenido en audio en lugar de leer largos artículos o ver vídeos que requieren el 100% de nuestra atención. Ya sea mientras programamos un nuevo componente, vamos de camino al trabajo en el coche, o simplemente cuando salimos a hacer deporte; el podcasting se ha convertido en el compañero perfecto para nuestro día a día.

Y no es para menos, plataformas como Spotify, Apple Podcasts o iVoox nos lo han puesto facilísimo para distribuir o descubrir lo que otros tienen que contar.

Pero claro, la realidad del creador de contenido es muy distinta. Si alguna vez te ha picado el gusanillo y has intentado producir uno, sabrás de sobra que lleva su tiempo. No se trata solo de sentarse frente a un micrófono y hablar. Tienes que pensar la idea, estructurar y escribir un guion medianamente coherente, grabar (y regrabar porque te has trabado en la misma frase cuarenta veces), y finalmente pelearte con el editor de audio para cortar los silencios incómodos y darle fluidez.

Por suerte, la Inteligencia Artificial está aquí para echarnos un cable tremendo.

Seguro que a estas alturas ya has trasteado con cosas como ChatGPT para pedirle que te genere textos, te resuma documentos o incluso te ayude a debuggear algo de código. Pero la cosa va mucho más allá. ¿Sabías que la síntesis de voz ha evolucionado hasta el punto de sonar casi 100% humana? Atrás quedaron los tiempos de Loquendo y esas voces robóticas sin alma.

En este artículo te quiero enseñar paso a paso cómo he logrado montar un podcast entero de forma semiautomática usando Inteligencia Artificial. Y para conseguir ese nivel de calidad en el audio que marque la diferencia, me he apoyado en los servicios de Azure. Vamos a repasar juntos todo el flujo de trabajo: desde que le pedimos a la IA que nos escupa el texto, hasta que picamos un script para convertirlo a un archivo de audio con un sonido espectacular y un acento de España que da el pego por completo.

¿Por qué elegir Azure para esta locura?

Es probable que te preguntes por qué me he decantado por la nube de Microsoft habiendo otras opciones como Google Cloud, AWS o plataformas específicas como ElevenLabs. He probado varios sistemas y APIs de Text-to-Speech durante estos últimos meses, pero al final siempre acabo volviendo a Azure por varios motivos de peso que, para mí, marcan la diferencia.

El primero y más evidente: Azure Speech ofrece unas voces neuronales que son una auténtica pasada. Cuentan con un abanico de tonalidades muy variadas y, lo más importante, su acento en español de España (al igual que el de otros muchos países hispanohablantes) prácticamente no suena a robot. Puedes jugar con voces como la de "Álvaro" o "Elvira" y notar la cadencia y la entonación que esperarías de un humano normal y corriente leyendo un texto.

Además, hay otras ventajas clave en el entorno de desarrollo:

La API es híper robusta: Se nota que es un servicio maduro. La documentación es completísima y Microsoft mantiene los SDKs súper actualizados.
Integración sin fricciones: Instalar su paquete de NPM en cualquier script de Node.js o Python y tenerlo funcionando te lleva literalmente un par de minutos.
SSML (Speech Synthesis Markup Language): Si la voz de base no te convence del todo, puedes usar etiquetas estándar XML para meter pausas de un segundo, subir el tono de voz al final de una pregunta o cambiar la velocidad de ciertas frases clave de forma súper granular. Esto da mucho juego si quieres automatizar hasta la respiración del locutor.
La capa gratuita (Free Tier): Azure te da una tarifa F0 en el servicio de Speech que te ofrece miles de caracteres gratuitos al mes, lo que da de sobra para hacer pruebas, proyectos personales y validar ideas sin tener que pasar la tarjeta por caja a las primeras de cambio.

Lo que vas a necesitar antes de empezar

Antes de ponernos a ensuciarnos las manos picando código, asegúrate de tener todo esto preparado en tu entorno de trabajo:

Una cuenta de Azure activa. Si no la tienes, te puedes registrar totalmente gratis desde su portal y te dan crédito inicial.
Preferiblemente Node.js instalado en su versión 16 LTS o superior.
Tu editor de código favorito listo para la acción (yo soy "team VS Code" a muerte).
Una cuenta de OpenAI (o Azure OpenAI) con su API Key lista por si quieres seguir el flujo completo y automatizar también la parte creativa de la generación de guiones.

Paso 1: Configurar nuestro servicio de Azure Speech

Lo primero de todo es irnos al portal de Azure para levantar el servicio que hará el trabajo duro de poner voz a nuestras palabras.

Una vez dentro de tu dashboard de Azure, haz clic en "Crear un recurso" (el clásico botón del menú superior) y usa la barra de búsqueda para encontrar "Speech" (o Voz, dependiendo del idioma de tu portal).
Dale al botón de crear. Se te abrirá un formulario para rellenar los datos. Ponle un nombre descriptivo a la instancia, algo como podcast-ia-demo.
Selecciona la suscripción que vayas a usar, escoge un grupo de recursos existente (o crea uno nuevo para tenerlo todo organizadito) y como tarifa asegúrate de escoger la F0 (gratuita) para empezar. Esta tarifa es tu mejor amiga para hacer experimentos.
Asígnalo a tu región más cercana. En mi caso, estando en España, casi siempre suelo elegir West Europe.
Una vez que Azure termine de desplegar el recurso (suele tardar muy poco), vete al panel del servicio y busca la sección "Claves y punto de conexión" en el menú lateral de la izquierda.
Aquí verás dos claves y el nombre de la región. Te va a hacer falta copiar la "Clave 1" y la región exacta. Guárdalas a buen recaudo que luego las vamos a inyectar en nuestras variables de entorno. ¡Y recuerda no subirlas a ningún repositorio público!

Paso 2: Preparando nuestra estructura local

Con el backend en la nube preparado, vamos a montar la estructura de nuestro proyecto en el PC desde la terminal:

mkdir podcast-ia-azure
cd podcast-ia-azure
npm init -y

Ahora nos toca instalar las tres librerías de NPM que nos van a dar la vida y hacer que todo esto conecte con apenas un par de bloques de código: el SDK oficial de Azure, la librería de OpenAI, y dotenv para no tener que harcodear nuestras credenciales.

npm install microsoft-cognitiveservices-speech-sdk openai dotenv

Para organizarme un poco mejor y no acabar con un mar de archivos sueltos, yo me creo un par de subcarpetas para ir almacenando de forma limpia los guiones generados, los audios resultantes y los propios scripts de ejecución. Tu proyecto debería quedar parecido a esto:

podcast-ia-azure/
├── guiones/
├── audios/
├── scripts/
│ ├── generarGuion.js
│ └── generarPodcast.js
├── .env
├── package.json

Paso 3: Poniendo a GPT a currar como nuestro guionista

Llegados a este punto podrías ser tú quien escriba el texto si ya tienes inspiración o quieres narrar un post tuyo. Pero ya que estamos automatizando cosas, ¿por qué no le pedimos a un modelo de lenguaje que nos haga él el borrador del guion?

Crea un archivo llamado .env en la raíz de tu proyecto e introduce ahí tu key de OpenAI:

OPENAI_API_KEY=sk-tu_clave_super_secreta_de_openai

Después, crea tu primer script al que vamos a llamar scripts/generarGuion.js. Le pasaremos un tema por consola y nos tiene que devolver un archivo con el speech completo:

require('dotenv').config();
const fs = require('fs');
const { Configuration, OpenAIApi } = require('openai');

const configuration = new Configuration({
  apiKey: process.env.OPENAI_API_KEY,
});

const openai = new OpenAIApi(configuration);

async function generarGuion(tema, archivoSalida) {
  // Ajustamos el prompt para que suene a locutor amigable y casual
  const prompt = `Escribe un guion para un podcast de unos 5 minutos. El tema del que tienes que hablar de manera amena es: ${tema}. Exprésate con un tono muy cercano, entretenido y natural. Puedes saludar a la audiencia como si estuvieran contigo.`;

  console.log(`Pensando el guion para el tema: "${tema}"... Dame un momento.`);

  const response = await openai.createChatCompletion({
    model: 'gpt-4',
    // La temperatura a 0.7 suele ir genial para equilibrar creatividad y coherencia narrativa
    temperature: 0.7,
    messages: [
      { role: 'system', content: 'Eres el locutor principal de un podcast de éxito sobre desarrollo y curiosidades tech. Hablas como si estuvieras charlando tranquilamente con un buen amigo.' },
      { role: 'user', content: prompt }
    ]
  });

  const guion = response.data.choices[0].message.content;

  // Guardamos el texto en la ruta que le hayamos indicado
  fs.writeFileSync(archivoSalida, guion);
  console.log(`¡Guion escrito y pulido! Lo he guardado sano y salvo en ${archivoSalida}`);
}

// Capturamos los argumentos de la terminal
const [tema, archivoSalida] = process.argv.slice(2);
generarGuion(tema || "Por qué migrar a la nube no es magia negra", archivoSalida || "guiones/episodio1.txt");

¡Es la hora de probarlo! Vamos a ejecutar el script pasándole el parámetro de lo que queremos hablar:

node scripts/generarGuion.js "La revolución de los desarrollos Serverless" guiones/episodio_serverless.txt

En cuestión de segundos tendrás tu guion esperándote en la carpeta de guiones. Es muy recomendable que le eches un primer vistazo, ya que el modelo suele organizar muy bien el saludo, el desarrollo del contenido y suele incluir hasta una buena llamada a la acción al final ("no olvides suscribirte si te ha gustado...").

Paso 4: La magia ocurre (Convertir texto a voz)

Es aquí donde el código cobra vida, literalmente. Volvemos un segundo a nuestro .env y añadimos los valores que nos apuntamos del portal de Azure hace un rato:

AZURE_SPEECH_KEY=la_clave_que_sacaste_del_portal
AZURE_SPEECH_REGION=tu_region_ejemplo_westeurope

A continuación toca armar nuestro plato principal: scripts/generarPodcast.js. En este archivo le vamos a decir al SDK de Voz de Azure: "Coge este fichero de texto, aplícale tus modelos neuronales, y devuélveme un clip de audio prístino".

require('dotenv').config();
const fs = require('fs');
// Importamos el SDK oficial
const sdk = require('microsoft-cognitiveservices-speech-sdk');

const speechKey = process.env.AZURE_SPEECH_KEY;
const serviceRegion = process.env.AZURE_SPEECH_REGION;

// Recuperamos el archivo origen y el destino de los argumentos, o pillamos los default
const archivoGuion = process.argv[2] || 'guiones/episodio1.txt';
const archivoAudio = process.argv[3] || 'audios/episodio1.wav';

const texto = fs.readFileSync(archivoGuion, 'utf8');

// Inicializamos la config con las keys
const speechConfig = sdk.SpeechConfig.fromSubscription(speechKey, serviceRegion);

// Asignamos una voz específica. 'es-ES-AlvaroNeural' funciona increíble para un tono neutro español.
// Si prefieres intentar con voz femenina, la variante 'es-ES-ElviraNeural' también tiene matices tremendos.
speechConfig.speechSynthesisVoiceName = 'es-ES-AlvaroNeural'; 

// Le decimos al SDK que en vez de hablar por los altavoces de tu portátil, renderice directo a un archivo
const audioConfig = sdk.AudioConfig.fromAudioFileOutput(archivoAudio);
const synthesizer = new sdk.SpeechSynthesizer(speechConfig, audioConfig);

console.log(`Renderizando la voz del archivo ${archivoGuion}. Esto suele tardar unos segundos...`);

// Lanzamos la acción asíncrona principal
synthesizer.speakTextAsync(texto, result => {
  if (result.reason === sdk.ResultReason.SynthesizingAudioCompleted) {
    console.log(`¡Boom! Renderización completada al 100%. Tienes el audio esperándote en ${archivoAudio}`);
  } else {
    // Si algo falla (ej. clave mal puesta), nos escupe el error por consola
    console.error('Ha ocurrido un error al intentar sintetizar la voz:', result.errorDetails);
  }
  // Importante: cerrar el sintetizador para liberar recursos
  synthesizer.close();
});

Probemos a ejecutar esta maravilla por primera vez:

node scripts/generarPodcast.js guiones/episodio_serverless.txt audios/episodio_serverless.wav

De verdad, ponte unos buenos auriculares, navega hasta tu carpeta de audios, y dale al play al WAV resultante. Si es tu primera vez usando voces neuronales de Azure, te va a sorprender una barbaridad lo humana que llega a sonar la entonación y las pausas que hace al leer las comas y los puntos.

Un paso más allá: Expandiendo tu automatización

A estas alturas ya tenemos lo fundamental: un archivo con una voz narrando el contenido. Sin embargo, si lo escuchas tal cual, posiblemente notes el audio un pelín "clínico" o vacío, ya que el locutor está hablando en el absoluto de los vacíos sonoros.

Para darle el toque maestro, hay un par de cositas de post-producción que te recomiendo aplicar siempre.

Si buscas el control absoluto y no te importa invertir un par de minutos más, te puedes abrir el archivo directamente en un programa libre de edición como Audacity. Te echas el WAV generado a la pista principal, añades una pista secundaria pregrabada con alguna melodía de Lo-Fi o jazz relajante (ojo con los derechos de autor, Free Music Archive es genial para esto) y un par de "woosh" de efectos de sonido para la intro y el outro. Subirle unos decibelios a la voz y bajar la música te dará un nivel súper profesional al instante.

Pero si, al igual que a nosotros, te va la marcha pura y dura y prefieres ser fiel a la filosofía de automatizarlo absolutamente todo , puedes usar herramientas como ffmpeg desde la propia terminal para mezclar automáticamente tu podcast con una base musical. La idea es que baje el volumen de la música de fondo para que tu voz se escuche clara (el famoso efecto "ducking"):

ffmpeg -i audios/episodio1.wav -i musica_fondo.mp3 -filter_complex "[0:a][1:a]amix=inputs=2:duration=first:dropout_transition=2" audios/episodio1_final.mp3

¿Te sabe a poco? Vamos a subir el nivel integrando la API de YouTube. Imagina que fabricamos un vídeo MP4 con una carátula estática y nuestro audio final. Puedes usar este comando rapidísimo de ffmpeg:

ffmpeg -loop 1 -i portada.png -i audios/episodio1_final.mp3 -c:v libx264 -tune stillimage -c:a aac -b:a 192k -pix_fmt yuv420p -shortest videos/episodio1.mp4

Una vez que tienes el archivo MP4 listo en tu carpeta videos/, el siguiente paso lógico de automatización es subirlo directamente a tu canal usando OAuth 2.0 y el cliente oficial de Google APIs. Te dejo aquí un snippet bastante avanzado donde he creado un objeto uploadToYouTube para enviar el archivo directamente a los servidores de YouTube sin tener que abrir el navegador:

const fs = require('fs');
// Lógica que envuelve la llamada a googleapis e instanciación del cliente de YouTube
const { uploadToYouTube } = require('../utils/youtube-upload');

// Le pasamos el buffer de nuestro vídeo recién renderizado
const videoBuffer = fs.readFileSync('videos/episodio1.mp4');

// Rellenamos los metadatos. ¡Esto también te lo podría generar GPT!
const post = {
  title: 'Episodio 1: La historia de la IA',
  description: 'Podcast generado con IA y Azure. En este episodio hablamos sobre la historia de la inteligencia artificial.',
  tags: [{ name: 'podcast' }, { name: 'inteligencia artificial' }, { name: 'azure' }],
  featureImage: 'portada.png'
};

const scriptData = {}; 
const env = process.env;

console.log("Subiendo vídeo a YouTube...");

// Lanzamos nuestra mega-integración
uploadToYouTube(videoBuffer, post, scriptData, env)
  .then(result => {
    console.log('¡Vídeo subido y listado con éxito!', result.url);
  })
  .catch(err => {
    console.error('El script ha petado subiendo a YouTube:', err);
  });

Si metes esto último en un entorno de integración continua (como GitHub Actions) tras hacer un push de tus guiones en texto plano, tienes un bot autónomo que renderiza voces neuronales, hace postproducción de vídeo final al vuelo, y auto-publica la obra maestra en YouTube sin que te hayas despeinado.

Espero que de verdad este recorrido te haya aportado ideas frescas de todo lo que puedes lograr combinando tan solo un entorno básico de Node, junto a un par de servicios cloud impresionantes como los que tenemos a nuestra disposición hoy en día. ¿Te imaginas configurando una alarma matutina que te lea el resumen de los pull requests que te han asignado en voz de locutor de radio? Porque con estas herramientas, la barrera principal acaba siendo puramente la imaginación.

Si acabas de probar el código, encuentras alguna cosa curiosa en Azure Speech o te apetece enseñarme los resultados, ya sabes dónde estoy en los comentarios o puedes buscar mis redes sociales. ¡Dale duro!

Cómo diseñar una pasarela de pagos resiliente con Stripe y Azure

Daniel J. Saldaña — Thu, 19 Feb 2026 08:15:00 +0000

Integrar pagos parece sencillo hasta que deja de serlo. Mientras todo funciona, un webhook que guarda datos en una base de datos puede parecer suficiente. El problema aparece cuando hay latencia, duplicados, fallos temporales o errores de lógica. En ese momento descubres que procesar dinero no es solo recibir un evento HTTP.

En este artículo quiero explicarte cómo plantear una arquitectura de pagos sólida usando Stripe sobre Microsoft Azure, desplegada como infraestructura como código con Terraform. No vamos a centrarnos en fragmentos de código, sino en las decisiones arquitectónicas que marcan la diferencia entre algo que “funciona” y algo que está preparado para producción real.

Separar responsabilidades desde el primer momento

Cuando Stripe envía un webhook, exige una respuesta rápida. Si no contestas en pocos segundos, reintentará el envío. Eso es parte de su modelo de garantía de entrega.

El error habitual es procesarlo todo dentro del mismo endpoint:

Validar firma.
Consultar base de datos.
Crear o actualizar usuario.
Registrar pago.
Enviar correos.
Devolver respuesta.

Si algo falla en ese flujo —una consulta lenta, un timeout, un problema de red— puedes terminar con estados inconsistentes o duplicados.

La solución es simple conceptualmente, pero potente arquitectónicamente: desacoplar.

La función de entrada debe hacer únicamente esto:

Validar la firma criptográfica.
Publicar el evento en un sistema de eventos.
Devolver 200 inmediatamente.

Nada más.

Event Grid como columna vertebral

En esta arquitectura, Azure Event Grid actúa como intermediario entre el webhook y la lógica de negocio.

Esto cambia completamente el comportamiento del sistema:

Si una función falla, Event Grid reintenta automáticamente.
Si el fallo persiste, el evento puede enviarse a Dead Letter.
Cada tipo de evento puede procesarse en una función distinta.

El sistema deja de depender de un único punto crítico.

Separar eventos como:

checkout.session.completed
invoice.payment_succeeded
customer.subscription.deleted

en funciones independientes permite escalar y evolucionar cada dominio sin romper los demás.

Cosmos DB para el estado

Cosmos DB almacena el estado actual:

Usuarios.
Suscripciones.
Pagos procesados.
Identificadores de eventos para idempotencia.

El modo Serverless permite pagar solo por consumo real y escalar automáticamente según tráfico.

Además, su modelo NoSQL se adapta bien a la naturaleza variable de los eventos de Stripe.

Storage Account para auditoría y resiliencia

Una única Storage Account cumple tres funciones importantes:

Table Storage para auditoría ligera.
Blob Storage como Dead Letter.
Queue Storage para errores lógicos.

Si un evento no puede procesarse tras múltiples reintentos, no desaparece. Se almacena en Blob Storage para reprocesarlo cuando el problema esté resuelto.

Si el error es de negocio (por ejemplo, datos inconsistentes), se envía a una cola específica para revisión manual.

Este diseño permite diferenciar entre fallos técnicos y fallos funcionales.

Idempotencia: imprescindible en sistemas de pagos

Stripe puede enviar el mismo evento más de una vez. Esto no es un error, es una característica de fiabilidad.

Por eso, antes de procesar cualquier evento, es obligatorio comprobar si ya fue tratado.

Normalmente se guarda el eventId en Cosmos DB o en una tabla de control. Si ya existe, se ignora. Si no existe, se procesa y se registra.

Sin este control puedes acabar con:

Pagos duplicados.
Suscripciones dobles.
Estados incoherentes.

La idempotencia no es opcional cuando trabajas con dinero.

Seguridad basada en identidad

La seguridad debe basarse en identidad, no en secretos distribuidos por el código.

Cada Azure Function puede tener una Managed Identity asignada. Los permisos se gestionan mediante RBAC:

La función de entrada puede publicar en Event Grid.
Las funciones de procesamiento pueden acceder a Cosmos DB y Storage.
No se usan connection strings en el código.

Además, la validación de la firma de Stripe en el webhook es obligatoria. Si la firma no coincide, se devuelve 401 inmediatamente.

Este enfoque reduce superficie de ataque y simplifica la gestión de credenciales.

Qué ocurre cuando algo falla

Una arquitectura madura define qué pasa cuando el sistema no funciona perfectamente.

Si Cosmos DB tiene una caída temporal, Event Grid reintentará automáticamente durante horas.
Si hay un bug persistente, el evento terminará en Dead Letter y podrá reprocesarse.
Si hay un error de lógica, se enviará a una cola para revisión manual.

Nada se pierde. Todo queda registrado.

Ese es el objetivo real de la arquitectura: garantizar consistencia incluso cuando el entorno falla.

Infraestructura como código

Desplegar todo esto con Terraform aporta ventajas claras:

Entornos reproducibles.
Versionado de infraestructura.
Integración con pipelines de despliegue.
Control de cambios auditable.

La infraestructura deja de ser algo manual y pasa a ser parte del ciclo de desarrollo.

Reflexión final

Procesar pagos no es añadir un endpoint HTTP. Es diseñar un sistema distribuido que debe ser consistente, seguro y tolerante a fallos.

Separar entrada y procesamiento, utilizar un backbone de eventos, aplicar idempotencia, implementar seguridad basada en identidad y definir mecanismos claros de recuperación transforma una integración básica en una arquitectura preparada para producción.

La simplicidad inicial puede ser atractiva. Pero cuando el tráfico crece o aparece el primer incidente serio, la arquitectura es lo que marca la diferencia.

Arquitectura Evolutiva en Azure: El Arte de no Sobre-diseñar

Daniel J. Saldaña — Sun, 01 Feb 2026 10:15:00 +0000

Si llevas tiempo en el mundo de la arquitectura Cloud, conoces esa sensación. Estás frente al lienzo en blanco (o un main.tf vacío) y te encuentras en ese punto crítico: la delgada línea entre sentar unas bases sólidas y caer en la trampa del sobre-diseño (over-engineering).

Recientemente, trabajando en la arquitectura base para una Prueba de Concepto (PoC) en Azure, me vi tentado a desplegar todo el arsenal que Microsoft nos ofrece. Sin embargo, recordé una máxima que a veces olvidamos: La arquitectura no es solo tecnología; es contexto y momento.

Hoy quiero compartir cómo he abordado este diseño, diferenciando entre lo que es "innegociable" desde el día 1 y lo que es "evolutivo".

El Enfoque: Sólido pero Ligero

En los diagramas que acompañan este post, podéis ver el enfoque actual que he implementado. No es la arquitectura final de una multinacional, pero tampoco es un "Hello World" inseguro.

1. Gestión del Estado y Ciclo de Vida (Terraform)

Como se ve en el diagrama de secuencia, he optado por una estrategia de Infraestructura como Código (IaC) en capas. No todo se despliega a la vez.

Fase de Fundación: Storage Accounts, Networking base.
Fase de Orquestación: Identidades, Recursos compartidos (ACR, KeyVault).
Fase de Aplicación: El despliegue "quirúrgico" de los servicios.

Esto evita el temido monolito de Terraform y reduce el radio de explosión si algo falla. Separar el ciclo de vida de la infraestructura del ciclo de vida de la aplicación es vital para mantener la agilidad.

2. Seguridad e Identidad: El Innegociable

Aquí es donde no se puede negociar. En el diagrama de jerarquía de identidades, veréis que he implementado Federación OIDC (OpenID Connect) entre GitHub Actions y Azure.

¿El objetivo? Eliminar los secretos rotativos (Client Secrets) que caducan o se filtran.
Zero-Trust: Reforzamos la seguridad asignando identidades granulares. Cada servicio tiene permiso solo para lo que necesita (ej. AcrPush, Secret User), ni más, ni menos.

3. Lo que NO ves (y por qué es importante)

Si analizas el diagrama de arquitectura completo, notarás ausencias notables.

¿Dónde está Azure Front Door?
¿Por qué no hay Private Endpoints en cada servicio PaaS?
¿Dónde está la suite completa de Defender for Cloud?

Técnicamente, podría implementarlo todo hoy. Pero aplicar todos los patrones Enterprise en una fase de PoC o MVP es el error más común. Frena el desarrollo, dispara la complejidad cognitiva del equipo y aumenta los costes innecesariamente.

Sin embargo, el segundo error más grave es usar la excusa de la "agilidad" para crear deuda técnica permanente (ej. usar Connection Strings en texto plano o un solo Service Principal para todo).

La Lección: Innegociables vs. Evolutivos

La clave del éxito en la arquitectura Cloud moderna está en saber clasificar tus decisiones:

Los Innegociables (Día 1): Gestión de identidad robusta (OIDC), segregación de responsabilidades, IaC modular y control de secretos (Key Vault). Si esto falla, los cimientos se rompen.
Los Evolutivos (Día 2+): Capas de seguridad perimetral avanzadas (WAF, Front Door), redundancia geográfica o networking privado complejo. Estos llegarán cuando el tráfico y el riesgo de negocio lo justifiquen.

Conclusión

Las buenas arquitecturas no nacen perfectas; nacen preparadas para evolucionar.

Diseñar para el futuro no significa construirlo todo hoy, sino dejar los huecos necesarios para que, cuando llegue el momento de escalar, no tengas que demoler lo que ya has construido.

¿Y vosotros? ¿Dónde ponéis la línea roja entre una buena base y el sobre-diseño en vuestras PoCs? Os leo en los comentarios.

¡Respaldo seguro y eficiente: Usando Azure Blob Storage para proteger tus datos!

Daniel J. Saldaña — Fri, 02 Jan 2026 21:41:39 +0000

Hoy quiero abordar uno de los temas más críticos para la seguridad de cualquier sitio o proyecto: los respaldos. En este post, exploraremos cómo garantizar la protección y accesibilidad de tus datos, utilizando Azure Blob Storage como la solución ideal para crear respaldos seguros y automatizados.

¿Por qué es tan importante un sistema de respaldo?

Los datos son el activo más valioso en cualquier proyecto digital. Sin embargo, a menudo subestimamos la importancia de tener un respaldo confiable. Un fallo del sistema, un ataque malicioso o incluso un error humano pueden provocar la pérdida de información crítica. Es por eso que, tener una estrategia de respaldos sólida y eficiente es fundamental.

¿Por qué elegir Azure Blob Storage?

Cuando hablamos de soluciones en la nube, Azure se destaca como uno de los proveedores más robustos y confiables. Azure Blob Storage es una opción poderosa para almacenar grandes volúmenes de datos y realizar respaldos de forma segura, con múltiples capas de protección.

Con Azure, puedes aprovechar sus características como:

Escalabilidad : Puedes almacenar desde unos pocos gigabytes hasta petabytes de datos.
Seguridad : Azure proporciona múltiples opciones de autenticación y control de acceso, asegurando que tus datos estén protegidos.
Facilidad de integración : Usando herramientas como Azure CLI y APIs, podemos automatizar el proceso de respaldo y facilitar su gestión.

Cómo crear un Azure Storage Account y Blob Container

Antes de comenzar con la automatización del respaldo, necesitamos crear un Storage Account y un Blob Container en Azure. Aquí te explico cómo hacerlo:

Paso 1: Crear un Azure Storage Account

Accede al portal de Azure : Dirígete a Azure Portal.
Crear un nuevo Storage Account :
Revisar y crear : Revisa los detalles y haz clic en "Crear". El proceso de creación tomará unos minutos.

Paso 2: Crear un Blob Container

Accede a tu Storage Account : Una vez creado el Storage Account, haz clic en él desde el portal de Azure.
Crear un Blob Container :

¡Listo! Ahora tienes un Storage Account y un Blob Container donde podrás almacenar tus respaldos.

Ejemplo práctico: Respaldo automatizado de Ghost con Azure Blob Storage

En este ejemplo, vamos a ver cómo podemos respaldar los datos de un sitio web usando Azure Blob Storage. Aunque el ejemplo es sobre Ghost , este proceso puede adaptarse fácilmente a cualquier otro sistema.

¿Qué haremos?

Generar el respaldo : Primero, crearemos un respaldo de los datos de Ghost y su base de datos MySQL.
Comprimir los archivos : Luego, comprimiremos el respaldo en un archivo .tar.gz para reducir el tamaño y hacerlo más eficiente.
Subir a Azure : Finalmente, utilizaremos Azure CLI para subir el archivo comprimido a Azure Blob Storage.

Paso 1: Crear el respaldo de los datos

El primer paso es crear el respaldo de los datos de tu servidor, que incluye tanto los archivos de Ghost como la base de datos MySQL.

# Conectar al servidor y crear respaldo
ssh -i ~/.ssh/id_rsa ${{ secrets.SSH_USER }}@${{ secrets.SERVER_HOST }} \
  "tar -czf /tmp/ghost-backup.tar.gz /opt/ghost/data /tmp/ghost_database.sql"

Este comando crea un archivo comprimido que contiene tanto los archivos de Ghost como la base de datos MySQL.

Paso 2: Subir el respaldo a Azure Blob Storage

Una vez que tenemos el archivo de respaldo, el siguiente paso es subirlo a Azure Blob Storage. Esto se hace de manera sencilla utilizando Azure CLI :

# Subir el archivo de respaldo a Azure Blob Storage
az storage blob upload \
  --account-name $AZURE_STORAGE_ACCOUNT \
  --container-name $CONTAINER_NAME \
  --name "ghost-backup-${TIMESTAMP}.tar.gz" \
  --file "/tmp/ghost-backup.tar.gz" \
  --sas-token $SAS_TOKEN

Este comando sube el archivo comprimido a tu contenedor en Azure Blob Storage, asegurando que el respaldo esté almacenado de forma segura en la nube.

Paso 3: Limpiar respaldos antiguos

La gestión de los respaldos no termina solo con la creación y almacenamiento. También es importante mantener tu almacenamiento limpio y organizado. Por eso, puedes establecer una política de retención que elimine los respaldos antiguos.

# Limpiar respaldos antiguos en Azure
az storage blob list \
  --account-name $AZURE_STORAGE_ACCOUNT \
  --container-name $CONTAINER_NAME \
  --query "[?properties.lastModified < '${CUTOFF_DATE}'].name" \
  --output tsv \
  --sas-token $SAS_TOKEN | while read blob_name; do
    az storage blob delete \
      --account-name $AZURE_STORAGE_ACCOUNT \
      --container-name $CONTAINER_NAME \
      --name "$blob_name" \
      --sas-token $SAS_TOKEN
  done

Este comando lista los respaldos antiguos y los elimina automáticamente según la fecha de retención configurada, ayudando a liberar espacio en Azure y mantener solo los respaldos más recientes.

Código completo de la automatización con GitHub Actions

A continuación, te presento el workflow completo de GitHub Actions que implementa todo el sistema de respaldos automatizado. Este archivo YAML incluye todas las funcionalidades que hemos discutido: conexión SSH segura, respaldo de base de datos MySQL, compresión de archivos, subida a Azure Blob Storage y limpieza automática de respaldos antiguos.

El workflow está diseñado para ejecutarse automáticamente cada día a las 3:00 AM (hora española) y también puede ejecutarse manualmente cuando sea necesario. Incluye manejo robusto de errores, validaciones de espacio en disco y notificaciones automáticas en caso de fallos.

Características principales del código:

✅ Respaldo automático diario y manual bajo demanda
✅ Validación de espacio en disco antes de crear respaldos
✅ Compresión eficiente con tar.gz
✅ Subida segura a Azure Blob Storage
✅ Limpieza automática de respaldos antiguos (60 días de retención)
✅ Notificaciones automáticas en caso de errores
✅ Logs detallados para facilitar el debugging

Guarda este código en .github/workflows/backup-ghost-data.yml en tu repositorio:

name: Respaldo de Datos Ghost

on:
  # Ejecutar manualmente
  workflow_dispatch:
  # Ejecutar automáticamente todos los días a las 3:00 AM hora española (1:00 AM UTC en invierno, 2:00 AM UTC en verano)
  schedule:
    - cron: "0 2 * * *" # 3:00 AM CEST (verano)

env:
  RETENTION_DAYS: 60
  CONTAINER_NAME: ghost-backups
  AZURE_STORAGE_ACCOUNT: aprendejaponesbackup

concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

jobs:
  backup:
    runs-on: ubuntu-latest
    timeout-minutes: 30
    steps:
      - name: Descargar repositorio
        uses: actions/checkout@v5

      - name: Configurar clave SSH
        run: |
          mkdir -p ~/.ssh
          echo "${{ secrets.SSH_PRIVATE_KEY }}" > ~/.ssh/id_rsa
          chmod 600 ~/.ssh/id_rsa
          ssh-keyscan -H ${{ secrets.SERVER_HOST }} >> ~/.ssh/known_hosts

      - name: Crear directorio de respaldo
        run: |
          echo "📁 Creando directorio de backup local..."
          mkdir -p backup
          echo "✅ Directorio creado en: $(pwd)/backup"
          echo "💾 Espacio disponible en disco:"
          df -h $(pwd) | tail -1

      - name: Generar nombre del archivo de respaldo
        id: backup_info
        run: |
          echo "🏷️ Generando nombre de archivo de backup..."
          TIMESTAMP=$(date +%Y%m%d-%H%M%S)
          BACKUP_START_TIME=$(date +%s)
          if ["${{ github.event_name }}" = "workflow_dispatch"]; then
            # Ejecución manual - usar carpeta snapshots
            FOLDER="snapshots"
            FILENAME="ghost-snapshot-${TIMESTAMP}.tar.gz"
            echo "📸 Tipo: Snapshot manual"
          else
            # Ejecución automática - carpeta raíz
            FOLDER=""
            FILENAME="ghost-data-backup-${TIMESTAMP}.tar.gz"
            echo "⏰ Tipo: Backup automático"
          fi
          echo "📝 Archivo: ${FILENAME}"
          echo "📂 Carpeta: ${FOLDER:-'(raíz)'}"
          echo "filename=${FILENAME}" >> $GITHUB_OUTPUT
          echo "folder=${FOLDER}" >> $GITHUB_OUTPUT
          echo "timestamp=${TIMESTAMP}" >> $GITHUB_OUTPUT
          echo "start_time=${BACKUP_START_TIME}" >> $GITHUB_OUTPUT

      - name: Respaldar base de datos MySQL
        run: |
          echo "🗄️ Iniciando backup de la base de datos MySQL..."
          echo "🔗 Conectando al servidor ${{ secrets.SERVER_HOST }}..."

          # Crear directorio temporal para el backup de la BD
          ssh -i ~/.ssh/id_rsa ${{ secrets.SSH_USER }}@${{ secrets.SERVER_HOST }} \
            "mkdir -p /tmp/ghost-backup-${{ steps.backup_info.outputs.timestamp }}"

          # Obtener el nombre del contenedor MySQL
          echo "🔍 Buscando contenedor MySQL..."
          MYSQL_CONTAINER=$(ssh -i ~/.ssh/id_rsa ${{ secrets.SSH_USER }}@${{ secrets.SERVER_HOST }} \
            "sudo docker ps --format '{{.Names}}' | grep -i mysql | head -1")

          if [-z "$MYSQL_CONTAINER"]; then
            echo "⚠️ No se encontró contenedor MySQL, intentando con 'db' o 'mysql'..."
            MYSQL_CONTAINER=$(ssh -i ~/.ssh/id_rsa ${{ secrets.SSH_USER }}@${{ secrets.SERVER_HOST }} \
              "sudo docker ps --format '{{.Names}}' | grep -E 'db|mysql' | head -1")
          fi

          if [-z "$MYSQL_CONTAINER"]; then
            echo "❌ ERROR: No se pudo encontrar el contenedor MySQL"
            echo "📋 Contenedores disponibles:"
            ssh -i ~/.ssh/id_rsa ${{ secrets.SSH_USER }}@${{ secrets.SERVER_HOST }} "sudo docker ps --format '{{.Names}}'"
            exit 1
          fi

          echo "✅ Contenedor MySQL encontrado: ${MYSQL_CONTAINER}"

          # Exportar la base de datos
          echo "💾 Exportando base de datos 'ghost'..."

          # Intentar primero con el usuario de la base de datos
          echo "🔐 Intentando con usuario de base de datos..."
          if ssh -i ~/.ssh/id_rsa ${{ secrets.SSH_USER }}@${{ secrets.SERVER_HOST }} \
            "sudo docker exec -e MYSQL_PWD='${{ secrets.DATABASE_PASSWORD }}' ${MYSQL_CONTAINER} mysqldump -u ${{ secrets.DATABASE_USER }} ghost | sudo tee /tmp/ghost-backup-${{ steps.backup_info.outputs.timestamp }}/ghost_database.sql > /dev/null" 2>/dev/null; then
            echo "✅ Backup exitoso con usuario de base de datos"
          else
            echo "⚠️ Falló con usuario de BD, intentando con root..."
            ssh -i ~/.ssh/id_rsa ${{ secrets.SSH_USER }}@${{ secrets.SERVER_HOST }} \
              "sudo docker exec -e MYSQL_PWD='${{ secrets.MYSQL_ROOT_PASSWORD }}' ${MYSQL_CONTAINER} mysqldump -u root ghost | sudo tee /tmp/ghost-backup-${{ steps.backup_info.outputs.timestamp }}/ghost_database.sql > /dev/null"
            echo "✅ Backup exitoso con usuario root"
          fi

          # Verificar que el backup se creó correctamente
          DB_SIZE=$(ssh -i ~/.ssh/id_rsa ${{ secrets.SSH_USER }}@${{ secrets.SERVER_HOST }} \
            "ls -lh /tmp/ghost-backup-${{ steps.backup_info.outputs.timestamp }}/ghost_database.sql | awk '{print \$5}'")

          echo "✅ Base de datos exportada exitosamente"
          echo "📊 Tamaño del dump SQL: ${DB_SIZE}"

      - name: Respaldar datos de Ghost vía SSH
        run: |
          echo "🔗 Conectando al servidor ${{ secrets.SERVER_HOST }}..."
          echo "📦 Creando backup comprimido en el servidor..."
          echo "📍 Origen archivos: /opt/ghost/data/ghost"
          echo "📍 Origen BD: /tmp/ghost-backup-${{ steps.backup_info.outputs.timestamp }}/ghost_database.sql"
          echo "📍 Destino temporal: /tmp/${{ steps.backup_info.outputs.filename }}"

          # Verificar espacio disponible en el servidor
          echo "💾 Verificando espacio en servidor..."
          ssh -i ~/.ssh/id_rsa ${{ secrets.SSH_USER }}@${{ secrets.SERVER_HOST }} \
            "echo 'Disco principal:' && df -h /"

          # Validar espacio libre mínimo (30%)
          echo "🔍 Validando espacio libre mínimo..."
          DISK_USAGE=$(ssh -i ~/.ssh/id_rsa ${{ secrets.SSH_USER }}@${{ secrets.SERVER_HOST }} \
            "df / | tail -1 | awk '{print \$5}' | sed 's/%//'")

          echo "📊 Uso actual del disco: ${DISK_USAGE}%"

          if ["$DISK_USAGE" -gt 70]; then
            echo "❌ ERROR: Espacio insuficiente en el servidor"
            echo " 💾 Uso actual: ${DISK_USAGE}% (máximo permitido: 70%)"
            echo " 🚨 Se requiere al menos 30% de espacio libre para crear el backup"
            echo " 💡 Libera espacio en el servidor antes de continuar"
            exit 1
          else
            echo "✅ Espacio suficiente: ${DISK_USAGE}% usado ($((100-DISK_USAGE))% libre)"
          fi

          # Estimar tamaño del backup y verificar si cabe
          echo "📏 Estimando tamaño del backup..."
          DATA_SIZE_KB=$(ssh -i ~/.ssh/id_rsa ${{ secrets.SSH_USER }}@${{ secrets.SERVER_HOST }} \
            "du -sk /opt/ghost/data 2>/dev/null | awk '{print \$1}' || echo '0'")

          if ["$DATA_SIZE_KB" -gt 0]; then
            # Estimar que el backup comprimido será ~60% del tamaño original
            ESTIMATED_BACKUP_KB=$((DATA_SIZE_KB * 60 / 100))
            AVAILABLE_KB=$(ssh -i ~/.ssh/id_rsa ${{ secrets.SSH_USER }}@${{ secrets.SERVER_HOST }} \
              "df / | tail -1 | awk '{print \$4}'")

            echo "📊 Tamaño de datos: $((DATA_SIZE_KB/1024)) MB"
            echo "📊 Backup estimado: $((ESTIMATED_BACKUP_KB/1024)) MB (comprimido)"
            echo "📊 Espacio disponible: $((AVAILABLE_KB/1024)) MB"

            if ["$ESTIMATED_BACKUP_KB" -gt "$AVAILABLE_KB"]; then
              echo "❌ ERROR: El backup estimado no cabe en el disco"
              echo " 📦 Backup estimado: $((ESTIMATED_BACKUP_KB/1024)) MB"
              echo " 💾 Espacio disponible: $((AVAILABLE_KB/1024)) MB"
              echo " 🚨 Se necesitan al menos $((ESTIMATED_BACKUP_KB/1024)) MB libres"
              exit 1
            else
              echo "✅ El backup estimado cabe en el disco"
            fi
          else
            echo "⚠️ No se pudo estimar el tamaño, continuando..."
          fi

          # Crear backup que incluye archivos y base de datos
          echo "📦 Creando archivo tar.gz con archivos y base de datos..."
          ssh -i ~/.ssh/id_rsa ${{ secrets.SSH_USER }}@${{ secrets.SERVER_HOST }} \
            "sudo tar -czf /tmp/${{ steps.backup_info.outputs.filename }} \
              -C /opt/ghost/data --exclude='ghost/content/themes' ghost \
              -C /tmp/ghost-backup-${{ steps.backup_info.outputs.timestamp }} ghost_database.sql"

          echo "✅ Backup creado en el servidor"
          echo "⬇️ Descargando backup al runner de GitHub..."

          scp -i ~/.ssh/id_rsa ${{ secrets.SSH_USER }}@${{ secrets.SERVER_HOST }}:/tmp/${{ steps.backup_info.outputs.filename }} backup/

          echo "✅ Backup descargado exitosamente"
          echo "📊 Información del archivo:"
          FILE_SIZE=$(ls -lh backup/${{ steps.backup_info.outputs.filename }} | awk '{print $5}')
          FILE_SIZE_BYTES=$(stat -c%s backup/${{ steps.backup_info.outputs.filename }})
          echo " 📏 Tamaño: ${FILE_SIZE} (${FILE_SIZE_BYTES} bytes)"
          echo " 📍 Ubicación: $(pwd)/backup/${{ steps.backup_info.outputs.filename }}"
          echo " 🗜️ Compresión: tar.gz"
          echo " 📦 Contenido: archivos Ghost + base de datos MySQL"

      - name: Limpiar archivos temporales del servidor
        if: always()
        run: |
          echo "🧹 Limpiando archivos temporales del servidor..."
          echo "📍 Eliminando: /tmp/${{ steps.backup_info.outputs.filename }}"
          ssh -i ~/.ssh/id_rsa ${{ secrets.SSH_USER }}@${{ secrets.SERVER_HOST }} \
            "sudo rm -f /tmp/${{ steps.backup_info.outputs.filename }}" || true
          echo "📍 Eliminando directorio temporal de BD: /tmp/ghost-backup-${{ steps.backup_info.outputs.timestamp }}"
          ssh -i ~/.ssh/id_rsa ${{ secrets.SSH_USER }}@${{ secrets.SERVER_HOST }} \
            "sudo rm -rf /tmp/ghost-backup-${{ steps.backup_info.outputs.timestamp }}" || true
          echo "✅ Limpieza del servidor completada"

      - name: Instalar Azure CLI
        run: |
          echo "⚙️ Instalando Azure CLI..."
          curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash
          echo "✅ Azure CLI instalado"

      - name: Subir respaldo a Azure Storage
        run: |
          echo "☁️ Preparando subida a Azure Storage..."

          # Determinar la ruta completa del blob
          if [-n "${{ steps.backup_info.outputs.folder }}"]; then
            BLOB_NAME="${{ steps.backup_info.outputs.folder }}/${{ steps.backup_info.outputs.filename }}"
          else
            BLOB_NAME="${{ steps.backup_info.outputs.filename }}"
          fi

          echo "📍 Storage Account: ${{ env.AZURE_STORAGE_ACCOUNT }}"
          echo "📍 Container: ${{ env.CONTAINER_NAME }}"
          echo "📍 Blob: ${BLOB_NAME}"

          # Mostrar tamaño antes de subir
          FILE_SIZE=$(ls -lh backup/${{ steps.backup_info.outputs.filename }} | awk '{print $5}')
          echo "📦 Archivo a subir: ${FILE_SIZE}"
          echo "⬆️ Iniciando subida a Azure Storage..."

          az storage blob upload \
            --account-name ${{ env.AZURE_STORAGE_ACCOUNT }} \
            --container-name ${{ env.CONTAINER_NAME }} \
            --name "${BLOB_NAME}" \
            --file backup/${{ steps.backup_info.outputs.filename }} \
            --sas-token "${{ secrets.AZURE_SAS_TOKEN }}"

          echo "✅ Backup subido exitosamente a Azure Storage"
          echo "🌐 URL completa: https://${{ env.AZURE_STORAGE_ACCOUNT }}.blob.core.windows.net/${{ env.CONTAINER_NAME }}/${BLOB_NAME}"

      - name: Limpiar respaldos antiguos en Azure Storage
        run: |
          echo "🗓️ Iniciando limpieza de backups antiguos..."
          # Obtener fecha límite para retención
          CUTOFF_DATE=$(date -d "${{ env.RETENTION_DAYS }} days ago" +%Y-%m-%d)
          echo "📅 Fecha límite: ${CUTOFF_DATE} (archivos anteriores serán eliminados)"
          echo "⏳ Retención configurada: ${{ env.RETENTION_DAYS }} días"

          # Limpiar backups automáticos antiguos
          echo "🧹 Limpiando backups automáticos antiguos..."
          echo "🔍 Buscando archivos con prefijo: ghost-data-backup-"
          az storage blob list \
            --account-name ${{ env.AZURE_STORAGE_ACCOUNT }} \
            --container-name ${{ env.CONTAINER_NAME }} \
            --prefix "ghost-data-backup-" \
            --query "[?properties.lastModified < '${CUTOFF_DATE}'].name" \
            --output tsv \
            --sas-token "${{ secrets.AZURE_SAS_TOKEN }}" | while read blob_name; do
              if [! -z "$blob_name"]; then
                echo "🗑️ Eliminando backup automático antiguo: $blob_name"
                az storage blob delete \
                  --account-name ${{ env.AZURE_STORAGE_ACCOUNT }} \
                  --container-name ${{ env.CONTAINER_NAME }} \
                  --name "$blob_name" \
                  --sas-token "${{ secrets.AZURE_SAS_TOKEN }}"
              fi
            done

          # Limpiar snapshots manuales antiguos
          echo "🧹 Limpiando snapshots manuales antiguos..."
          echo "🔍 Buscando archivos con prefijo: snapshots/ghost-snapshot-"
          az storage blob list \
            --account-name ${{ env.AZURE_STORAGE_ACCOUNT }} \
            --container-name ${{ env.CONTAINER_NAME }} \
            --prefix "snapshots/ghost-snapshot-" \
            --query "[?properties.lastModified < '${CUTOFF_DATE}'].name" \
            --output tsv \
            --sas-token "${{ secrets.AZURE_SAS_TOKEN }}" | while read blob_name; do
              if [! -z "$blob_name"]; then
                echo "🗑️ Eliminando snapshot manual antiguo: $blob_name"
                az storage blob delete \
                  --account-name ${{ env.AZURE_STORAGE_ACCOUNT }} \
                  --container-name ${{ env.CONTAINER_NAME }} \
                  --name "$blob_name" \
                  --sas-token "${{ secrets.AZURE_SAS_TOKEN }}"
              fi
            done

          echo "✅ Limpieza de archivos antiguos completada"

      - name: Limpiar clave SSH
        if: always()
        run: |
          echo "🔐 Limpiando clave SSH temporal..."
          rm -f ~/.ssh/id_rsa
          echo "✅ Clave SSH eliminada"

      - name: Resumen del respaldo
        id: backup_summary
        run: |
          echo "✅ Backup completado exitosamente"
          echo "📁 Archivo: ${{ steps.backup_info.outputs.filename }}"

          # Calcular tiempo total de backup
          END_TIME=$(date +%s)
          DURATION=$((END_TIME - ${{ steps.backup_info.outputs.start_time }}))
          DURATION_MIN=$((DURATION / 60))
          DURATION_SEC=$((DURATION % 60))

          echo "⏱️ Tiempo total: ${DURATION_MIN}m ${DURATION_SEC}s"
          echo "duration=${DURATION}" >> $GITHUB_OUTPUT

          # Obtener tamaño del backup
          BACKUP_SIZE=$(ls -lh backup/${{ steps.backup_info.outputs.filename }} 2>/dev/null | awk '{print $5}' || echo "N/A")
          echo "backup_size=${BACKUP_SIZE}" >> $GITHUB_OUTPUT

          if ["${{ github.event_name }}" = "workflow_dispatch"]; then
            echo "📸 Tipo: Snapshot manual"
            echo "☁️ Ubicación: ${{ env.AZURE_STORAGE_ACCOUNT }}/${{ env.CONTAINER_NAME }}/snapshots/"
          else
            echo "⏰ Tipo: Backup automático"
            echo "☁️ Ubicación: ${{ env.AZURE_STORAGE_ACCOUNT }}/${{ env.CONTAINER_NAME }}/"
          fi
          echo "🗓️ Retención configurada: ${{ env.RETENTION_DAYS }} días"

  # Notificación solo en caso de fallo
  notificar-fallo:
    needs: backup
    runs-on: ubuntu-latest
    if: failure()
    permissions:
      issues: write
    steps:
      - name: Crear notificación de fallo
        uses: actions/github-script@v7
        with:
          script: |
            const timestamp = new Date().toLocaleString('es-ES', { 
              timeZone: 'Europe/Madrid',
              year: 'numeric',
              month: '2-digit',
              day: '2-digit',
              hour: '2-digit',
              minute: '2-digit'
            });

            const backupType = '${{ github.event_name }}' === 'workflow_dispatch' ? 'Snapshot Manual' : 'Backup Automático';
            const title = `🚨 Error en ${backupType} - ${timestamp}`;

            const body = `## 🚨 Error en el Sistema de Backups

            **Fecha:** ${timestamp}
            **Tipo:** ${backupType}
            **Estado:** ❌ El backup ha fallado

            ### 📋 Detalles del Error

            - **Workflow:** \`${{ github.workflow }}\`
            - **Run ID:** \`${{ github.run_id }}\`
            - **Commit:** \`${{ github.sha }}\`
            - **Rama:** \`${{ github.ref_name }}\`

            ### 🔗 Enlaces Útiles

            - [Ver logs del workflow](https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }})
            - [Ejecutar backup manual](https://github.com/${{ github.repository }}/actions/workflows/backup-ghost-data.yml)

            ### 🛠️ Acciones Recomendadas

            1. **Revisar los logs** del workflow para identificar el error específico
            2. **Verificar conectividad** SSH al servidor
            3. **Comprobar espacio** disponible en el servidor
            4. **Validar credenciales** de Azure Storage
            5. **Ejecutar backup manual** una vez solucionado el problema

            ### ⚠️ Importante

            - Los datos de Ghost no están siendo respaldados automáticamente
            - Se recomienda solucionar este problema lo antes posible
            - Considera ejecutar un backup manual mientras se resuelve el issue

            ---

            *Notificación automática del sistema de backups*

            /cc @danieljsaldana`;

            await github.rest.issues.create({
              owner: context.repo.owner,
              repo: context.repo.repo,
              title: title,
              body: body,
              assignees: ['danieljsaldana'],
              labels: ['backup', 'error', 'urgent']
            });

Beneficios de usar Azure Blob Storage para tus respaldos

Automatización : Gracias a herramientas como Azure CLI , puedes automatizar el proceso de creación y almacenamiento de respaldos, eliminando la intervención manual.
Escalabilidad : Puedes almacenar un número prácticamente ilimitado de respaldos sin preocuparte por quedarte sin espacio.
Seguridad : Con Azure, tus datos están protegidos por varias capas de seguridad, incluyendo autenticación avanzada y cifrado en reposo.
Retención eficiente : Azure te permite configurar políticas de retención para eliminar respaldos antiguos, lo que te ayuda a optimizar el uso del espacio.

Conclusión

El respaldo de tus datos no tiene por qué ser complicado. Usando Azure Blob Storage , puedes garantizar que tus datos estén siempre seguros y accesibles, al mismo tiempo que automatizas el proceso para que no tengas que preocuparte por hacerlo manualmente. No importa si trabajas con Ghost o cualquier otro sistema, Azure te ofrece la flexibilidad y escalabilidad que necesitas.

He lanzado un nuevo proyecto para aprender japonés

Daniel J. Saldaña — Sat, 06 Dec 2025 21:06:28 +0000

Después de meses de trabajo, por fin puedo compartir algo que me hace mucha ilusión: he lanzado aprendejapones.es, un proyecto personal donde combino dos cosas que me apasionan: aprender japonés y construir productos web.

Lo que empezó como un simple blog para documentar mi camino hacia el JLPT N5 ha terminado convirtiéndose en una plataforma completa. Incluye rutinas de estudio, apuntes, vocabulario interactivo, historias cortas, validación de pronunciación con IA, un pequeño sistema de karma y un ninja que modera la comunidad.
Ah, y una mascota llamada Goliat, un bulldog samurái que se ha convertido en mi compañero de batalla durante todo el desarrollo.

¿Por qué crear mi propia plataforma?

Porque ninguna herramienta existente representaba justo lo que quería: un espacio simple, motivador y con un toque personal. Empecé montándolo encima de Ghost, pero al crecer el proyecto tuve que construir extensiones y servicios propios para superar sus limitaciones.

El resultado es una mezcla de contenido educativo, automatizaciones y pequeñas funcionalidades que hacen que aprender japonés sea más divertido… y que a mí me permita mejorar como desarrollador.

¿Qué incluye ahora mismo?

Lecciones básicas orientadas al JLPT N5
Diccionario y vocabulario con fichas
Validación de pronunciación
Historias cortas para practicar lectura
Sistema de comentarios con moderación
Página de progreso
Integración con notas personalizadas (próximamente)

¿Por qué lo comparto aquí?

Porque este proyecto ha sido, sobre todo, una excusa para aprender mientras construyo: arquitectura, automatización, diseño de producto, y cómo resolver problemas reales para usuarios reales… incluso si ese usuario soy yo mismo.

Si te interesa el japonés o simplemente te gusta ver cómo evoluciona un proyecto indie, te dejo el enlace:
👉 https://aprendejapones.es

Y si tienes feedback, ideas o quieres decirle algo a Goliat el samurái, estaré encantado de leerte.

Goliat Dashboard: Mi nueva aventura en la gestión de recursos Cloud

Daniel J. Saldaña — Wed, 22 Oct 2025 08:04:21 +0000

Estoy emocionado de compartir un nuevo proyecto en el que estoy trabajando: Goliat Dashboard. 🎉 Este sistema es mi próximo gran paso, diseñado específicamente para ofrecer control total sobre los despliegues realizados con Terraform , facilitando la organización y la gestión de los recursos en la nube.

Aunque aún está en desarrollo, quiero aprovechar esta oportunidad para contarles más sobre el enfoque y las ideas que están impulsando esta iniciativa.

¿Qué es Goliat Dashboard?

Goliat Dashboard tiene como objetivo centralizar y organizar los despliegues realizados mediante Terraform, ya sea usando Terraform Cloud o su provider oficial, para proporcionar una visión clara y estructurada de lo que se ha desplegado en tu infraestructura.

Algunas de las funcionalidades clave incluyen:

Gestión eficiente y centralizada de recursos desplegados con Terraform.
Visión clara y en tiempo real de los despliegues organizados por organizaciones, proyectos y workspaces.
Acceso a métricas detalladas de los recursos creados, ayudando a los equipos a tomar decisiones informadas.

En un entorno donde cada vez más aplicaciones se despliegan en la nube, mantener un control efectivo de los recursos puede ser un desafío. Goliat Dashboard busca resolver este problema al proporcionar una herramienta que no solo organice los despliegues, sino que también facilite su monitoreo y gestión.

El valor de la IA en Goliat Dashboard

Una característica diferenciadora de este proyecto es la integración de inteligencia artificial , diseñada para:

Analizar los despliegues realizados y ofrecer información útil sobre el estado de la infraestructura.
Resolver dudas sobre los recursos creados , como detalles sobre configuraciones, relaciones o estados actuales.
Facilitar informes y análisis estructurados que ayuden a los usuarios a entender mejor su infraestructura y optimizar su uso.

Esta funcionalidad convierte a Goliat Dashboard en una herramienta que no solo organiza, sino que también simplifica el entendimiento de tu infraestructura en la nube.

La seguridad como pilar fundamental: Shield

Desde el inicio, estoy poniendo un fuerte énfasis en la seguridad. Por eso, he comenzado a desarrollar Shield , el módulo de seguridad que garantizará que los despliegues gestionados estén siempre protegidos.

¿Qué incluirá Shield?

🔒 Bloqueo por país, IP o rango de IP: Para prevenir accesos no autorizados.

🔒 Tokens seguros con caducidad: Gestiona los accesos de forma controlada y protege los endpoints.

🤖 IA para análisis de seguridad: Diseñado para identificar actividades sospechosas, generar informes de seguridad y responder preguntas críticas sobre la seguridad de tus recursos.

Shield no solo será un complemento de seguridad, sino una herramienta esencial para mantener tu infraestructura protegida de manera proactiva y eficiente.

Estado actual del proyecto

Aun se encuentra en una fase temprana de desarrollo y estoy definiendo el alcance y las funcionalidades clave. Por lo que aun no puedo compartir una hoja de ruta detallada, espero en los proximos meses poder compartir más detalles sobre el progreso y los próximos pasos.

¡Únete a este viaje!

Si esta idea te resulta interesante, te invito a seguir el desarrollo de Goliat Dashboard. Pronto compartiré más avances, y ya puedes explorar una demo interactiva en:

👉 goliat-dashboard.com

Además, este proyecto será open source , y estará disponible en GitHub para que la comunidad pueda colaborar, aprender o simplemente explorar cómo está construido.

🔗 Repositorio de Goliat Dashboard:

https://github.com/danieljsaldana/goliat-dashboard

Gracias por acompañarme en este emocionante camino. ¡Estoy deseando compartir más pronto! 🚀

Os comporato un video de la demostración del proyecto y recordar que ire subiendo a mi canal de YouTube más contenido sobre el desarrollo de este proyecto.

Convierte texto a audio con Azure Speech y almacenamiento en la nube

Daniel J. Saldaña — Wed, 22 Oct 2025 08:00:51 +0000

Si alguna vez has querido transformar contenido de texto en archivos de audio de alta calidad y almacenarlos de forma segura en la nube, Azure Speech Services y Azure Blob Storage ofrecen una solución potente y escalable. En este artículo, te guiaré a través del proceso de convertir texto a voz usando Azure Speech Services y luego almacenarlo en Azure Blob Storage , una opción ideal para almacenar y gestionar tus archivos de audio de manera eficiente y segura.

Este proceso es útil en una variedad de escenarios, como la conversión de artículos, posts de blogs, documentos educativos o cualquier otro tipo de contenido textual en audios. A lo largo de este tutorial, utilizaremos ejemplos prácticos basados en Ghost CMS , pero los conceptos y el código son totalmente aplicables a cualquier sistema de gestión de contenido o aplicación que genere texto.

¿Por Qué convertir texto a audio?

El proceso de convertir texto a audio tiene múltiples aplicaciones, entre las que se incluyen:

Accesibilidad : Permite a personas con dificultades visuales o de lectura acceder al contenido de forma más cómoda.
Mejor Retención : Escuchar contenido puede mejorar la comprensión y retención, especialmente en contextos educativos.
Interactividad : Ofrece a los usuarios la opción de consumir contenido sin necesidad de leerlo, lo que fomenta una mayor interacción y flexibilidad.

Servicios necesarios

En este tutorial, utilizaremos dos servicios clave de Azure :

Azure Speech Services : Un servicio de conversión de texto a voz que ofrece voces de alta calidad, como la voz HD Dragon Nanami en japonés.
Azure Blob Storage : Un servicio de almacenamiento en la nube donde guardaremos los archivos de audio generados, con un acceso seguro mediante SAS Tokens (firma de acceso compartido).

Flujo de trabajo

El proceso de convertir texto a audio y almacenarlo en la nube sigue estos pasos:

Prepara el texto : Recibimos el contenido textual que queremos convertir a voz.
Convierte el texto a audio : Usamos Azure Speech Services para generar el audio en el formato adecuado.
Sube el archivo de audio a Azure Blob Storage : Usamos Azure Blob Storage para almacenar el archivo de audio, generando una URL temporal que permite acceder al archivo.

Paso 1: Configuración de Azure Speech Services

El primer paso es configurar Azure Speech Services , que nos permitirá convertir el texto a voz. Necesitarás crear un recurso de Speech Services en el portal de Azure y obtener una clave de suscripción.

Configuración de la voz

Seleccionamos una voz adecuada para el proceso de conversión. En este caso, usaremos la voz HD Dragon Nanami para la conversión de texto a voz en japonés. Aquí tienes el código para configurar la voz:

// Configuración de la voz
export const VOICE_CONFIG = {
  voice_name: 'ja-JP-Nanami:DragonHDLatestNeural', // Voz japonesa HD Dragon
  language: 'ja-JP', // Idioma japonés
  name: 'Nanami Dragon HD Latest',
  description: 'Voz japonesa HD Dragon Latest multilingüe'
};

// Función para obtener la configuración de la voz
export function getVoiceConfig() {
  return {
    voice_name: VOICE_CONFIG.voice_name,
    language: VOICE_CONFIG.language
  };
}

En este fragmento, definimos la voz Nanami Dragon HD en japonés. Este paso es crucial para que Azure pueda procesar correctamente el texto.

Paso 2: Convertir texto a audio con Azure Speech

Azure Speech Services utiliza SSML (Speech Synthesis Markup Language) para procesar el texto. SSML nos permite controlar cómo se debe leer el texto, incluyendo pausas, tono y velocidad. Vamos a crear una función que convierte el texto en el formato SSML y lo envía a la API de Azure para generar el audio.

Ejemplo de conversión de texto a SSML

export function wrapWithSSML(text) {
  const BREAK_MARKER = ' ___SSML_BREAK___';
  const breaks = [];

  let sanitizedText = text.replace(/<break\s+time="[^"]+"\s*\/>/g, _ => {
    breaks.push(_);
    return BREAK_MARKER;
  });

  sanitizedText = sanitizedText
    .replace(/&/g, '&amp;')
    .replace(/</g, '&lt;')
    .replace(/>/g, '&gt;')
    .replace(/"/g, '&quot;')
    .replace(/'/g, '&apos;')
    .replace(/\*/g, '')
    .replace(/[“”«»]/g, '"')
    .replace(/[–—]/g, '-');

  let breakIdx = 0;
  sanitizedText = sanitizedText.replace(new RegExp(BREAK_MARKER, 'g'), () => {
    return breaks[breakIdx++] || '<break time="500ms"/>';
  });

  return `<speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis" xml:lang="${VOICE_CONFIG.language}">
    <voice name="${VOICE_CONFIG.voice_name}">
      ${sanitizedText}
    </voice>
  </speak>`;
}

Este código toma el texto de entrada, lo sanitiza y lo convierte en SSML para enviarlo a la API de Azure Speech. Las pausas también se gestionan en este formato, lo que hace que el audio resultante sea más natural y comprensible.

Llamada a la API de Azure Speech

Ahora que tenemos el texto en formato SSML, podemos enviarlo a Azure Speech Services para generar el audio. Aquí te mostramos cómo hacerlo:

const AZURE_SPEECH_KEY = 'tu-clave-de-api';
const AZURE_ENDPOINT = 'https://westeurope.api.cognitive.microsoft.com'; // Cambiar por la región correspondiente

async function generateAudio(ssmlInput) {
  const response = await fetch(`${AZURE_ENDPOINT}/cognitiveservices/v1`, {
    method: 'POST',
    headers: {
      'Ocp-Apim-Subscription-Key': AZURE_SPEECH_KEY,
      'Content-Type': 'application/ssml+xml',
      'X-Microsoft-OutputFormat': 'audio-24khz-160kbitrate-mono-mp3'
    },
    body: ssmlInput
  });

  if (!response.ok) {
    throw new Error(`Error en Azure Speech: ${response.statusText}`);
  }

  return await response.arrayBuffer(); // Devuelve el audio en formato binario
}

Este código envía una solicitud POST a Azure Speech Services con el SSML. La respuesta es un archivo de audio, que podemos almacenar en el siguiente paso.

Paso 3: Subir el asudio a Azure Blob Storage

Una vez que el audio ha sido generado, debemos subirlo a Azure Blob Storage para su almacenamiento seguro y accesible. Azure Blob Storage nos permite generar SAS Tokens , que son URLs temporales para acceder al archivo sin exponer la cuenta de almacenamiento.

Subir el archivo a Azure Blob Storage

async function uploadToAzureBlob(audioBuffer, filePath, sasUrl) {
  const sasIndex = sasUrl.indexOf('?');
  const baseUrl = sasUrl.slice(0, sasIndex);
  const sasToken = sasUrl.slice(sasIndex + 1);

  const uploadUrl = `${baseUrl}/${filePath}?${sasToken}`;

  const response = await fetch(uploadUrl, {
    method: 'PUT',
    headers: {
      'x-ms-blob-type': 'BlockBlob',
      'Content-Type': 'audio/mpeg'
    },
    body: audioBuffer
  });

  if (!response.ok) {
    throw new Error(`Error al subir el audio a Azure Blob Storage: ${response.statusText}`);
  }

  return uploadUrl; // URL del archivo de audio en Azure Blob Storage
}

Este código sube el archivo de audio generado a Azure Blob Storage , utilizando la URL con el SAS Token para acceder de manera controlada al archivo.

Al integrar Azure Speech Services y Azure Blob Storage en tu flujo de trabajo, podrás transformar cualquier contenido textual en audios de alta calidad y almacenarlos de manera segura en la nube. Esta solución no solo mejora la accesibilidad y la interacción con el contenido, sino que también ofrece una manera eficiente de gestionar los archivos de audio generados, optimizando el almacenamiento y el acceso.

Si queréis ver esta aplicación en funcionamiento, podéis visitar el siguiente enlace: Aprende Japonés.

Prueba de concepto: interpretación de infraestructura con ChatGPT + Terraform

Daniel J. Saldaña — Mon, 02 Jun 2025 16:00:00 +0000

En esta prueba de concepto se explora cómo integrar modelos de lenguaje como ChatGPT en flujos de trabajo de infraestructura como código (IaC), utilizando un caso concreto basado en Terraform sobre Azure. El objetivo no es reemplazar las herramientas existentes, sino complementarlas con explicaciones automáticas, resúmenes funcionales y validación semántica del código antes de su ejecución.

Objetivo

Demostrar cómo una integración con ChatGPT puede servir como asistente técnico para interpretar archivos Terraform, anticipar la creación de recursos, y generar documentación o validaciones automatizadas de forma contextual.

Proyecto base

Se parte del repositorio k3s-azure-example-chatgpt, que automatiza el despliegue de una máquina virtual en Azure con la instalación automática de un clúster Kubernetes ligero mediante k3s. El repositorio se organiza en tres niveles principales:

1. Infraestructura como código (`Iac/`)

Contiene los módulos y archivos de Terraform necesarios para crear la infraestructura en Azure:

main.tf: definición de red, VM, IP pública, grupo de seguridad y demás recursos.
variables.tf: variables expuestas para personalizar despliegues.
terraform.tfvars: valores concretos definidos por el usuario.
outputs.tf: muestra la IP pública y otros outputs útiles.

Con ChatGPT es posible interpretar estos archivos y devolver un resumen legible que explique:

Qué recursos se van a crear.
Cómo se relacionan entre sí.
Qué configuraciones sensibles o críticas se deben revisar.

2. Instalación de k3s (`Config/`)

Esta capa utiliza Ansible para conectarse a la VM desplegada y automatizar la instalación de k3s.

inventory.ini: definición de los hosts objetivo.
playbook.yml: pasos para instalar k3s y configurar el nodo como maestro.

Con ayuda de ChatGPT, se puede entender el flujo de ejecución del playbook y anticipar qué configuraciones se aplican al clúster, cómo se gestionan los certificados y qué ajustes deben realizarse para exponer el servidor fuera de la red local.

3. Configuración del clúster (`Requirements/`)

Contiene manifiestos Kubernetes predefinidos para:

Configurar cert-manager con Let's Encrypt (staging y producción).
Instalar Ingress Controllers como Traefik o Kong.
Desplegar herramientas de gestión como ArgoCD y Kubernetes Dashboard.

El análisis asistido permite:

Detectar errores comunes en los manifiestos.
Verificar buenas prácticas (TLS, namespaces, anotaciones).
Sugerir configuraciones más robustas o seguras.

Casos de uso

Revisión técnica de cambios en infraestructura antes de ejecutar terraform apply.
Soporte para desarrolladores que consumen IaC sin conocer profundamente el proveedor (Azure en este caso).
Generación de documentación viva para equipos DevOps.
Mejora del onboarding técnico en proyectos de infraestructura.

Limitaciones

Este enfoque no reemplaza validaciones estáticas ni pruebas de integración.
Requiere una base de código ordenada y bien estructurada para obtener buenos resultados.
La precisión depende del contexto disponible en los archivos; no tiene visibilidad sobre el estado real de la nube.

Conclusión

La integración de ChatGPT en flujos de trabajo de infraestructura como código abre nuevas posibilidades para mejorar la comprensión y trazabilidad del código. Al proporcionar explicaciones automáticas y validaciones semánticas, se facilita el trabajo en equipo y se reduce la curva de aprendizaje para nuevos integrantes. La prueba de concepto demuestra que herramientas como ChatGPT pueden formar parte del flujo técnico sin invadirlo, mejorando la comprensión y la trazabilidad del código desde una perspectiva mucho más humana. Esto demuestra que la inteligencia artificial puede ser un aliado poderoso en la gestión de infraestructuras complejas, permitiendo a los equipos enfocarse en tareas de mayor valor añadido.

Cómo Goliat - Shield protege la API pública de Goliat - Dashboard con IA, tokens e inteligencia geográfica

Daniel J. Saldaña — Fri, 16 May 2025 11:32:17 +0000

Desde hace meses estoy desarrollando un proyecto personal que me está permitiendo aprender, crear y explorar nuevas soluciones de forma libre: Goliat - Dashboard.

Una plataforma pensada para unificar DevOps, FinOps y seguridad cloud, con visibilidad completa sobre entornos multicloud, repositorios, costes, despliegues y más. Pero hay una capa que me ha permitido dar un salto importante en este proyecto: la seguridad.

Presentamos Goliat - Shield

Goliat - Shield es el componente encargado de proteger la API pública de Goliat - Dashboard, y está diseñado desde el principio para combinar:

Seguridad práctica y efectiva
Visibilidad clara para los equipos
Capacidades inteligentes a través de IA

Este módulo no es una idea más: nace de la necesidad real de asegurar APIs públicas en productos que requieren apertura sin sacrificar control.

Aprendizajes con IA aplicada a seguridad

Uno de los aprendizajes más profundos en este proceso ha sido diseñar e integrar inteligencia artificial en una solución real, enfocada 100 % a la seguridad de APIs.

Goliat - Shield no solo restringe accesos: analiza, detecta, y aprende del comportamiento de los consumidores de la API pública. A través de IA, el sistema puede identificar patrones anómalos, comportamientos fuera de lo común o incluso potenciales amenazas, alertando de forma contextual.

¿Qué funcionalidades incluye Goliat - Shield?

Estas son algunas de las características clave del módulo de protección:

Autenticación por token: controla el acceso a la API mediante claves únicas y seguras.
Control de acceso por IP y país: define reglas de acceso a nivel geográfico, bloqueando solicitudes no autorizadas desde orígenes no permitidos.
Análisis de logs en tiempo real: explora eventos de acceso con filtros por token, país o fecha.
Agente inteligente con IA: interpreta patrones de uso y detecta anomalías sin intervención manual. Gestión visual desde el dashboard: pensado para facilitar la vida a los equipos de seguridad.

Todo esto está diseñado para ofrecer seguridad real, no solo desde la teoría, sino desde lo que realmente se necesita en producción.

Construido con tecnologías que funcionan

Este módulo está construido con una combinación de tecnologías y enfoques que, a lo largo de mi carrera, he comprobado que funcionan de verdad:

OpenAI para análisis inteligente y detección de patrones
Azure y AWS como entornos de despliegue y origen de datos
Astro + React para un frontend limpio, modular y rápido
RBAC + validaciones a nivel API para control granular de accesos

Mira cómo funciona Goliat - Shield

En este video comparto una demo del funcionamiento de **Goliat - Shield **desde dentro:

Visualización y filtrado de logs de acceso
Validación por país y direcciones IP
Gestión de tokens activos

Esto es solo el principio

Desarrollar Goliat - Shield ha sido una experiencia emocionante y reveladora. Me ha permitido consolidar conocimientos, explorar nuevos enfoques con IA aplicada a seguridad, y sobre todo construir algo que no solo protege, sino que aporta valor real al equipo de seguridad.

Goliat - Dashboard sigue creciendo, y con él sus capacidades de seguridad.
Y lo mejor: aún queda mucho por construir.

Recordar que podeis seguir el proyecto en su sitio web Goliat - Dashboard

Goliat Dashboard: Conoce los avances del proyecto que revolucionará la gestión de tu infraestructura

Daniel J. Saldaña — Tue, 13 May 2025 09:24:05 +0000

En los últimos meses, he estado trabajando intensamente en Goliat Dashboard, una solución avanzada que busca facilitar la gestión, monitorización y optimización de recursos, workflows y costes en entornos GitHub. Hoy quiero compartirte en detalle los avances realizados y el impacto positivo que puede tener en la gestión cotidiana de tu infraestructura.

¿Qué hace diferente a Goliat Dashboard?

El objetivo central de Goliat Dashboard es simplificar tareas complejas relacionadas con la administración técnica y financiera de infraestructuras cloud y repositorios de código. Más allá de ser un simple panel informativo, es una herramienta integral diseñada para optimizar procesos, reducir costes y aumentar la eficiencia operativa mediante inteligencia aplicada y automatización avanzada.

Funcionalidades destacadas y cómo pueden ayudarte

Gestión efectiva de Issues y Pull Requests
Goliat Dashboard proporciona una visión clara y detallada de todos los Issues y Pull Requests activos en tus proyectos. Permite filtrar, ordenar y analizar rápidamente la actividad por repositorio u organización, facilitando la detección de cuellos de botella, agilizando revisiones y mejorando significativamente los tiempos de respuesta.

Control dinámico de Workflows CI/CD
Una de sus funcionalidades clave es la posibilidad de ejecutar y controlar directamente workflows desde el propio Dashboard. Puedes revisar en tiempo real los logs de ejecución, verificar estados, gestionar artefactos generados, y tomar acciones rápidas sin salir del panel. Esto acelera notablemente los ciclos de integración continua y entrega continua (CI/CD), reduciendo tiempos muertos y optimizando procesos.

Gestión financiera cloud simplificada (FinOps)
El Dashboard permite visualizar y controlar en tiempo real el gasto de tus infraestructuras desplegadas en la nube (actualmente Azure y pronto AWS). Puedes definir presupuestos dinámicos por proyecto y recibir alertas visuales inmediatas cuando te acerques a límites preestablecidos, facilitando así un control financiero más proactivo y preciso.

Administración segura de variables y secretos
La seguridad es crucial en cualquier proyecto. Con Goliat Dashboard gestionas de forma centralizada y segura todas las variables de entorno y secretos asociados a tus repositorios. Además, la plataforma sincroniza automáticamente estos datos con GitHub, lo que simplifica enormemente la gestión y reduce riesgos operativos y de seguridad.

Recomendaciones inteligentes (Advisor)
Una de las funcionalidades más valiosas es su sistema inteligente de recomendaciones. Goliat Dashboard analiza continuamente tu infraestructura cloud y proporciona sugerencias específicas para mejorar aspectos clave como alta disponibilidad, seguridad, rendimiento o costes. Esto se traduce en una gestión más eficiente, segura y rentable de tus recursos en la nube.

Diario de actividad para trazabilidad completa
La plataforma registra detalladamente todas las acciones realizadas. Esto incluye modificaciones en configuraciones, workflows ejecutados, cambios en variables o secretos, y otras operaciones clave. Este diario integrado es una herramienta indispensable para auditorías internas, revisiones de seguridad y cumplimiento normativo (compliance).

Colaboración eficiente y control basado en roles (RBAC)
Facilita la colaboración segura entre diferentes equipos mediante anotaciones colaborativas directamente en cada repositorio. Además, implementa un sistema robusto de control de acceso basado en roles (RBAC), permitiendo definir con precisión qué usuarios o equipos tienen acceso a cada parte de la plataforma, asegurando la integridad y confidencialidad de los datos.

Agente Inteligente: asistencia proactiva y análisis avanzado
Una de las innovaciones más destacadas de Goliat Dashboard es el Agente Inteligente integrado, una herramienta interactiva que responde en tiempo real a consultas complejas sobre tu infraestructura. Puedes pedirle informes personalizados, estadísticas detalladas, análisis predictivos sobre costes futuros, o información específica sobre eventos pasados, simplificando notablemente la toma de decisiones.

¿Qué viene próximamente?

Estamos trabajando para incorporar próximamente:

Integración completa con GitLab.
Mejoras adicionales al Agente Inteligente para automatizar aún más tareas operativas.
Nuevas capacidades predictivas en el control presupuestario cloud.
Ampliación de funcionalidades de la API pública para integraciones externas avanzadas.

Próximamente disponible

Actualmente, Goliat Dashboard sigue en desarrollo activo, en fases avanzadas de pruebas y mejoras continuas para asegurar que, desde su lanzamiento, cumpla con las expectativas más exigentes.

Recordar que podeis seguir el proyecto en su sitio web Goliat - Dashboard

¡Te invitamos a estar atento a las próximas novedades!

Tu feedback es esencial para nosotros, así que cualquier sugerencia o pregunta será más que bienvenida.

¡Muchas gracias por seguir el proyecto!

Integración con Azure Advisor, Azure Service Health y próximos pasos

Daniel J. Saldaña — Wed, 23 Apr 2025 07:06:29 +0000

¡Hola a todos! Hoy quiero compartir contigo los avances más recientes que he realizado en Goliat - Dashboard, además de mostrarte algunas ideas clave para las próximas versiones, especialmente orientadas a la gestión de proyectos multicloud.

Nuevas Integraciones Disponibles: Azure Advisor y Azure Service Health

Ya puedes disfrutar de dos integraciones clave en el Dashboard:

Azure Advisor:

Desde ahora puedes consultar directamente en Goliat - Dashboard todas las recomendaciones proporcionadas por Azure Advisor, identificando fácilmente el impacto en tus recursos, filtrando por categoría o tipo de recurso, y actuando rápidamente para optimizar costes, rendimiento y seguridad.

Azure Service Health: También he incorporado la capacidad de monitorizar en tiempo real el estado de los servicios desplegados en Azure, identificando fácilmente si existe alguna afectación en tus recursos. Podrás ver claramente si se trata de incidentes, mantenimientos programados o acciones requeridas, permitiéndote reaccionar con mayor agilidad.

Aquí tienes un breve vídeo donde explico en detalle estas funcionalidades:

Mejoras visuales y experiencia del usuario

Además, he optimizado el diseño y distribución del menú, agrupando claramente las métricas relacionadas con Issues, Pull Requests y Actions, e implementado mejoras visuales para evitar espacios en blanco, ofreciendo una interfaz más intuitiva y limpia.

Próximos pasos: Gestión de proyectos multicloud

Uno de los objetivos principales para las próximas versiones es permitir gestionar proyectos que involucren múltiples organizaciones y proveedores desde un mismo lugar.

Mi idea principal es la siguiente:

Proyectos multiorganización y multiproveedor:

Podrás crear proyectos que engloben diferentes organizaciones o repositorios independientemente del proveedor cloud (AWS o Azure, por ejemplo). Cada proyecto podría contener diversas aplicaciones desplegadas en múltiples proveedores y organizaciones, centralizando así la información, recomendaciones, métricas y estados directamente en Goliat - Dashboard.

Sincronización mediante Local Storage:

Implementaré un sistema en Local Storage que permitirá definir repositorios y organizaciones específicas. Al seleccionar un repositorio u organización, esta configuración se sincronizará automáticamente entre todos los controladores del Dashboard. Así tendrás siempre una experiencia fluida y consistente, sin necesidad de repetir configuraciones manuales.

Este enfoque facilitará enormemente el seguimiento y la explotación de métricas por proyecto, organización o proveedor cloud, convirtiendo Goliat - Dashboard en una herramienta integral de gestión multicloud.

¡Próximamente tendrás más novedades sobre estos avances!

Espero tus comentarios y sugerencias para seguir avanzando juntos.¡Muchas gracias por apoyar el desarrollo de Goliat - Dashboard!

Recuerda que puedes seguir el proyecto en:

🌐 Proyecto: http://goliat-dashboard.com
🚀 Demo: http://demo.goliat-dashboard.com

Descubre cómo el Agente de Arquitectura expone recomendaciones de Azure Advisor

Daniel J. Saldaña — Tue, 08 Apr 2025 07:16:49 +0000

Goliat Dashboard sigue evolucionando para hacer que la gestión de tus recursos en la nube sea cada vez más eficiente. Hoy te presentamos una funcionalidad del Agente de Arquitectura que se conecta con Azure Advisor para mostrar sugerencias clave de manera centralizada. Con esta integración, tu equipo recibe las recomendaciones específicas que afectan a cada proyecto, sin necesidad de acceder al portal de Azure ni filtrar manualmente cada recurso.

¿En qué consiste esta funcionalidad?

El Agente de Arquitectura de Goliat Dashboard solicita a Azure Advisor las recomendaciones que guardan relación con el proyecto o repositorio de la organización. Eso quiere decir que, en un solo lugar, obtendrás avisos sobre mejoras de alta disponibilidad, seguridad o escalabilidad, cuidadosamente filtrados para enfocarse solo en los recursos que realmente importan a ese proyecto en concreto.

¿Cómo ayuda a solventar problemas reales?

Centralización de información
Sin tener que navegar entre portales externos o herramientas especializadas, cualquiera en el equipo puede ver de un vistazo qué necesita ajustes o mejoras, desde máquinas virtuales hasta servicios de contenedor o almacenamiento. Esto ahorra tiempo y reduce la complejidad en la supervisión diaria.
Recomendaciones relevantes y filtradas
Al concentrarse solo en las recomendaciones de recursos que pertenecen al proyecto consultado, se evitan datos genéricos que podrían dispersar la atención del equipo. Así, se pueden priorizar aquellas acciones que tengan más impacto o urgencia.
Control de datos sensibles
La organización decide qué información está autorizada a procesar y mostrar la IA. De esta forma, se garantiza la confidencialidad y se cumplen con las directrices de seguridad internas sin sacrificar la utilidad de las recomendaciones.
Toma de decisiones más rápida
Al visualizar de forma clara qué recursos necesitan migrar a una máquina virtual más potente, habilitar NAT gateway o mejorar sus discos, el equipo puede actuar de inmediato, evitando riesgos y optimizando el desempeño de la infraestructura en la nube.

Con esta nueva funcionalidad de Goliat Dashboard, el Agente de Arquitectura expone de manera sencilla las recomendaciones de Azure Advisor que realmente importan para tu proyecto. El resultado es una experiencia más ágil, en la que tanto perfiles técnicos como de negocio obtienen la información necesaria para tomar decisiones fundamentadas, sin perder tiempo en configuraciones manuales ni exponer datos que no sean estrictamente necesarios.

Recuerda que puedes seguir el proyecto en:

🌐 Proyecto: http://goliat-dashboard.com
🚀 Demo: http://demo.goliat-dashboard.com

Forem: Daniel J. Saldaña

Cómo crear un podcast generado con IA usando Azure

¿Por qué elegir Azure para esta locura?

Lo que vas a necesitar antes de empezar

Paso 1: Configurar nuestro servicio de Azure Speech

Paso 2: Preparando nuestra estructura local

Paso 3: Poniendo a GPT a currar como nuestro guionista

Paso 4: La magia ocurre (Convertir texto a voz)

Un paso más allá: Expandiendo tu automatización

Cómo diseñar una pasarela de pagos resiliente con Stripe y Azure

Separar responsabilidades desde el primer momento

Event Grid como columna vertebral

Cosmos DB para el estado

Storage Account para auditoría y resiliencia

Idempotencia: imprescindible en sistemas de pagos

Seguridad basada en identidad

Qué ocurre cuando algo falla

Infraestructura como código

Reflexión final

Arquitectura Evolutiva en Azure: El Arte de no Sobre-diseñar

El Enfoque: Sólido pero Ligero

1. Gestión del Estado y Ciclo de Vida (Terraform)

2. Seguridad e Identidad: El Innegociable

3. Lo que NO ves (y por qué es importante)

La Lección: Innegociables vs. Evolutivos

Conclusión

¡Respaldo seguro y eficiente: Usando Azure Blob Storage para proteger tus datos!

¿Por qué es tan importante un sistema de respaldo?

¿Por qué elegir Azure Blob Storage?

Cómo crear un Azure Storage Account y Blob Container

Paso 1: Crear un Azure Storage Account

Paso 2: Crear un Blob Container

Ejemplo práctico: Respaldo automatizado de Ghost con Azure Blob Storage

¿Qué haremos?

Paso 1: Crear el respaldo de los datos

Paso 2: Subir el respaldo a Azure Blob Storage

Paso 3: Limpiar respaldos antiguos

Código completo de la automatización con GitHub Actions

Beneficios de usar Azure Blob Storage para tus respaldos

Conclusión

He lanzado un nuevo proyecto para aprender japonés

¿Por qué crear mi propia plataforma?

¿Qué incluye ahora mismo?

¿Por qué lo comparto aquí?

Goliat Dashboard: Mi nueva aventura en la gestión de recursos Cloud

¿Qué es Goliat Dashboard?

El valor de la IA en Goliat Dashboard

La seguridad como pilar fundamental: Shield

¿Qué incluirá Shield?

Estado actual del proyecto

¡Únete a este viaje!

Convierte texto a audio con Azure Speech y almacenamiento en la nube

¿Por Qué convertir texto a audio?

Servicios necesarios

Flujo de trabajo

Paso 1: Configuración de Azure Speech Services

Configuración de la voz

Paso 2: Convertir texto a audio con Azure Speech

Ejemplo de conversión de texto a SSML

Llamada a la API de Azure Speech

Paso 3: Subir el asudio a Azure Blob Storage

Subir el archivo a Azure Blob Storage

Prueba de concepto: interpretación de infraestructura con ChatGPT + Terraform

Objetivo

Proyecto base

1. Infraestructura como código (Iac/)

2. Instalación de k3s (Config/)

3. Configuración del clúster (Requirements/)

Casos de uso

Limitaciones

Conclusión

Cómo Goliat - Shield protege la API pública de Goliat - Dashboard con IA, tokens e inteligencia geográfica

Presentamos Goliat - Shield

Aprendizajes con IA aplicada a seguridad

¿Qué funcionalidades incluye Goliat - Shield?

Construido con tecnologías que funcionan

Mira cómo funciona Goliat - Shield

Esto es solo el principio

Goliat Dashboard: Conoce los avances del proyecto que revolucionará la gestión de tu infraestructura

¿Qué hace diferente a Goliat Dashboard?

1. Infraestructura como código (`Iac/`)

2. Instalación de k3s (`Config/`)

3. Configuración del clúster (`Requirements/`)