DEV Community: Daniel J. Saldaña

¡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

Goliat Dashboard: Cambios en nuestra IA, reportes y gestión de workflows

Daniel J. Saldaña — Wed, 19 Mar 2025 21:30:35 +0000

Seguimos avanzando en el desarrollo del Dashboard de Goliat, y queremos compartir con vosotros el estado actual y las nuevas funcionalidades que ya están operativas. En este sprint, nos hemos enfocado especialmente en mejorar la visualización, para ello vamos a desarrollar distintas vistas a nivel global, que permitan filtrar tanto por organizaciones como a repositorios.

Además, hemos implementado una sección dedicada al seguimiento detallado de workflows (Actions), permitiendo ver claramente cuáles se ejecutan a nivel global, por organización y por repositorio. Esta actualización proporciona una vista detallada con logs completos, información sobre quién ejecutó cada workflow y los resultados obtenidos.

En el ámbito de los repositorios, se han integrado endpoints específicos para optimizar la gestión de operaciones y FinOps, de esta forma el agente de IA puede consultar aún más información. Estamos enfocándonos para dejar listo el Agente de Arquitectura con el cual esperamos que podamos obtener información a nivel de proveedor.

También estamos integrando el servicio de reporte por email. Ya hemos incorporado Resend y la idea es que los reportes incluyan información sobre el estado de los tokens, costes de los repositorios y organizaciones, e incluso generar informes sobre los costes mediante IA.

Continuaremos trabajando para mejorar la eficiencia y visibilidad del Dashboard Goliat.

Recuerda que puedes seguir el proyecto en:

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

Explorando el poder interno del Agente de IA en Goliat Dashboard

Daniel J. Saldaña — Thu, 13 Mar 2025 22:03:26 +0000

En la busqueda por optimizar procesos y mejorar nuestra interacción con la tecnología, hoy quiero compartir contigo un avance significativo en el proyecto en el que estoy trabajando: Goliat Dashboard.

He preparado un vídeo especial para mostrarte brevemente cómo funciona nuestro Agente de Inteligencia Artificial desde adentro, revelando su lógica funcional y su potencial operativo real.

En el vídeo explico de manera práctica dos aspectos clave:

Memoria contextual

Nuestro agente genera automáticamente una memoria única para cada conversación, manteniendo así el histórico completo de interacciones. Esto significa que cuando realizas consultas, no necesitas repetir información previa, ya que el agente recuerda el contexto y responde de manera natural y fluida.

Consultas Inteligentes a APIs

Otra funcionalidad que quiero destacar es la capacidad del agente para identificar automáticamente qué API debe consultar en cada interacción. Esta capacidad reduce notablemente la cantidad de llamadas innecesarias, lo que se traduce en:

Menores costos operativos, gracias a la disminución del número de tokens utilizados.
Mayor eficiencia, con respuestas más rápidas y precisas al reducir consultas redundantes.

Ejemplos prácticos del funcionamiento

En el vídeo que te comparto, realizo varias consultas específicas para que puedas ver estas capacidades en acción:

Consultas sobre secretos y variables dentro del repositorio, mostrando cómo el agente determina automáticamente la API correcta.
Preguntas contextuales que demuestran cómo la memoria interna del agente evita consultas innecesarias adicionales.
Gestión avanzada de solicitudes abiertas (Pull Requests), detallando el estado actual y el usuario responsable sin necesidad de consultas extra.

Integrar esta inteligencia artificial dentro del Dashboard de Goliat representa un gran paso adelante en términos de eficiencia tecnológica y operativa, algo que me entusiasma mucho y espero poder seguir explorando futuras funcionalidades.

Si te interesa ver cómo este agente puede optimizar tu flujo de trabajo con inteligencia artificial avanzada, no te pierdas el siguiente vídeo:

Recuerda que puedes seguir el proyecto en su sitio web oficial

Estado actual de Goliat Dashboard: ¡Descubre sus funcionalidades!

Daniel J. Saldaña — Fri, 07 Mar 2025 09:54:34 +0000

En este video comparto el estado actual de Goliat Dashboard, la plataforma que estoy construyendo para facilitar la gestión de proyectos mediante tecnología moderna, combinando Astro, React e integración con IA.

Explico en detalle sus funcionalidades actuales, las próximas mejoras y cómo puedes aprovechar Goliat Dashboard para optimizar tu flujo de trabajo.

¡Espero tu feedback en los comentarios! 🙌

PD: Disculpa los ronquidos de mi peludo amigo, ¡parece que no le interesó tanto la charla! 🐶😴

DEV Community: Daniel J. Saldaña

¡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?

Funcionalidades destacadas y cómo pueden ayudarte

¿Qué viene próximamente?

Próximamente disponible

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

Nuevas Integraciones Disponibles: Azure Advisor y Azure Service Health

Mejoras visuales y experiencia del usuario

Próximos pasos: Gestión de proyectos multicloud

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

¿En qué consiste esta funcionalidad?

¿Cómo ayuda a solventar problemas reales?

Goliat Dashboard: Cambios en nuestra IA, reportes y gestión de workflows

Explorando el poder interno del Agente de IA en Goliat Dashboard

Estado actual de Goliat Dashboard: ¡Descubre sus funcionalidades!

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

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

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