Reversión, se implementa solo tolerancia de Kuma.

.gitea/workflows/deploy.yml

@@ -1,4 +1,4 @@
-name: Optimized Build and Deploy with Session Authentication
+name: Optimized Build and Deploy
 
 on:
   push:
@@ -14,123 +14,59 @@ jobs:
         run: |
           set -e
           
+          # Configura SSH
           apt-get update -qq && apt-get install -y openssh-client git
           mkdir -p ~/.ssh
           echo "${{ secrets.PROD_SERVER_SSH_KEY }}" > ~/.ssh/id_rsa
           chmod 600 ~/.ssh/id_rsa
           ssh-keyscan -H ${{ secrets.PROD_SERVER_HOST }} >> ~/.ssh/known_hosts
           
-          ssh ${{ secrets.PROD_SERVER_USER }}@${{ secrets.PROD_SERVER_HOST }} "
-            export UPTIME_KUMA_URL='${{ secrets.UPTIME_KUMA_URL }}' # <-- ¡Este secreto ahora tiene el valor interno!
-            export UPTIME_KUMA_USER='${{ secrets.UPTIME_KUMA_USER }}'
-            export UPTIME_KUMA_PASSWORD='${{ secrets.UPTIME_KUMA_PASSWORD }}'
-            export UPTIME_KUMA_MAINTENANCE_ID='${{ secrets.UPTIME_KUMA_MAINTENANCE_ID }}'
-            export DB_SA_PASSWORD='${{ secrets.DB_SA_PASSWORD_SECRET }}'
-            export GITEA_SHA='${{ gitea.sha }}'
-            bash -s
-          " << 'EOSSH'
+          # Ejecuta en el host remoto
+          ssh ${{ secrets.PROD_SERVER_USER }}@${{ secrets.PROD_SERVER_HOST }} << 'EOSSH'
             set -e
             echo "--- INICIO DEL DESPLIEGUE OPTIMIZADO ---"
             
-            # --- SECCIÓN DE MONITOREO (VERSIÓN CON AUTENTICACIÓN DE SESIÓN) ---
-            if ! command -v curl &> /dev/null || ! command -v jq &> /dev/null; then
-              echo "Instalando curl y jq..."
-              sudo apt-get update -qq && sudo apt-get install -y curl jq
-            fi
-            
-            # Función para INICIAR SESIÓN y obtener el token
-            login() {
-              local response_body=$(mktemp)
-              local http_code=$(curl -s -w "%{http_code}" -o "$response_body" \
-                -X POST "${UPTIME_KUMA_URL}/api/login" \
-                -H "Content-Type: application/json" \
-                --data-raw "{\"username\": \"${UPTIME_KUMA_USER}\", \"password\": \"${UPTIME_KUMA_PASSWORD}\"}")
-              
-              if [ "$http_code" -ne 200 ]; then
-                echo "Error: Fallo al iniciar sesión en Uptime Kuma. Código HTTP: $http_code"
-                cat "$response_body" # Muestra el error de la API
-                return 1
-              fi
-              
-              jq -r '.token' < "$response_body"
-              rm "$response_body"
-            }
-            
-            # Función para CERRAR SESIÓN
-            logout() {
-              local token=$1
-              curl -s -X POST "${UPTIME_KUMA_URL}/api/logout" -H "Authorization: Bearer ${token}" > /dev/null
-              echo "Sesión de Uptime Kuma cerrada."
-            }
-
-            # Función para modificar el estado de mantenimiento
-            set_maintenance_status() {
-              local id=$1
-              local active_state=$2
-              local token=$3
-              
-              echo "Intentando establecer mantenimiento ID:${id} a ${active_state}..."
-              local maintenance_list=$(curl -s -X GET "${UPTIME_KUMA_URL}/api/maintenances" -H "Authorization: Bearer ${token}")
-              local current_config=$(echo "$maintenance_list" | jq --argjson id "$id" '.[] | select(.id == $id)')
-              
-              if [ -z "$current_config" ]; then
-                echo "Error: No se encontró mantenimiento con ID ${id}."
-                return 1
-              fi
-              
-              local modified_config=$(echo "$current_config" | jq --argjson state "${active_state}" '.active = $state')
-              local put_http_code=$(curl -s -w "%{http_code}" -X PUT "${UPTIME_KUMA_URL}/api/maintenances/${id}" \
-                -H "Content-Type: application/json" -H "Authorization: Bearer ${token}" --data-raw "$modified_config")
-
-              if [ "$put_http_code" -ne 200 ]; then
-                echo "Error al actualizar mantenimiento. Código HTTP: $put_http_code"
-                return 1
-              fi
-              
-              echo "Estado de mantenimiento actualizado con éxito."
-            }
-            
-            # --- Flujo Principal de Monitoreo ---
-            echo "Iniciando sesión en Uptime Kuma..."
-            AUTH_TOKEN=$(login)
-            if [ -z "$AUTH_TOKEN" ]; then
-              echo "No se pudo obtener el token de autenticación. Abortando."
-              exit 1
-            fi
-            echo "Inicio de sesión exitoso."
-
-            trap 'echo "--- Limpiando: Cerrando sesión de monitoreo ---"; logout "$AUTH_TOKEN"' EXIT
-            
-            echo "--- Pausando monitoreo en Uptime Kuma ---"
-            set_maintenance_status "$UPTIME_KUMA_MAINTENANCE_ID" true "$AUTH_TOKEN"
-            
-            # --- FIN SECCIÓN DE MONITOREO ---
-
-            # ... Resto del script de despliegue ...
+            # 1. Preparar entorno
             TEMP_DIR=$(mktemp -d)
             REPO_OWNER="dmolinari"
             REPO_NAME="gestionintegralweb"
             GITEA_REPO_PATH="/var/lib/docker/volumes/gitea-stack_gitea-data/_data/git/repositories/${REPO_OWNER}/${REPO_NAME}.git"
-            echo "Clonando repositorio..."
+            
+            echo "Clonando repositorio desde: $GITEA_REPO_PATH ..."
             git clone "$GITEA_REPO_PATH" "$TEMP_DIR"
             cd "$TEMP_DIR"
-            git checkout "$GITEA_SHA"
+            git checkout "${{ gitea.sha }}"
+            
+            # 2. Construcción paralela con Docker nativo (más rápido y fiable)
             build_image() {
               local dockerfile=$1
               local image_name=$2
               local context=$3
+              
               echo "Construyendo $image_name..."
-              docker build -t "$image_name" -f "$dockerfile" "$context"
+              docker build \
+                -t "$image_name" \
+                -f "$dockerfile" \
+                "$context"
             }
-            echo "Construyendo imágenes..."
+            
+            echo "Construyendo imágenes en paralelo..."
             (build_image "Backend/GestionIntegral.Api/Dockerfile" "dmolinari/gestionintegralweb-backend:latest" ".") &
             (build_image "Frontend/Dockerfile" "dmolinari/gestionintegralweb-frontend:latest" ".") &
             wait
+            
+            # 3. Despliegue con Docker Compose
             cd /opt/gestion-integral
+            export DB_SA_PASSWORD='${{ secrets.DB_SA_PASSWORD_SECRET }}'
+            
             echo "Recreando servicios..."
             docker compose up -d --force-recreate
-            echo "Realizando limpieza de imágenes..."
+            
+            # 4. Limpieza
+            echo "Realizando limpieza..."
             rm -rf "$TEMP_DIR"
             docker image prune -af --filter "until=24h"
+            
             echo "--- DESPLIEGUE COMPLETADO CON ÉXITO ---"
+            echo "Tiempo total: $(($SECONDS / 60)) minutos y $(($SECONDS % 60)) segundos"
           EOSSH