CAmbio en Secrets (User - Pass)

.gitea/workflows/deploy.yml

@@ -1,4 +1,4 @@
-name: Optimized Build and Deploy with Maintenance Window (Robust)
+name: Optimized Build and Deploy with Session Authentication
 
 on:
   push:
@@ -22,7 +22,8 @@ jobs:
           
           ssh ${{ secrets.PROD_SERVER_USER }}@${{ secrets.PROD_SERVER_HOST }} "
             export UPTIME_KUMA_URL='${{ secrets.UPTIME_KUMA_URL }}'
-            export UPTIME_KUMA_API_KEY='${{ secrets.UPTIME_KUMA_API_KEY }}'
+            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 }}'
@@ -31,108 +32,85 @@ jobs:
             set -e
             echo "--- INICIO DEL DESPLIEGUE OPTIMIZADO ---"
             
-            # --- SECCIÓN DE MONITOREO (VERSIÓN ROBUSTA) ---
+            # --- 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 final que implementa el flujo GET->FIND->MODIFY->PUT
+            # 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"
+                return 1
+              fi
+              
+              # Extraer el token del JSON de respuesta
+              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 USANDO el token de sesión
             set_maintenance_status() {
               local id=$1
-              local active_state=$2 # 'true' o 'false'
+              local active_state=$2
+              local token=$3
               
-              echo "Intentando establecer el estado de mantenimiento para ID:${id} a ${active_state}..."
+              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}")
-              # Creamos un archivo temporal para guardar el cuerpo de la respuesta
+              local current_config=$(echo "$maintenance_list" | jq --argjson id "$id" '.[] | select(.id == $id)')
-              local response_body=$(mktemp)
-              
-              # 1. GET LIST: Obtener la lista COMPLETA de mantenimientos
-              # Separamos el cuerpo de la respuesta del código HTTP
-              local http_code=$(curl -s -w "%{http_code}" \
-                -o "$response_body" \
-                -X GET "${UPTIME_KUMA_URL}/api/maintenances" \
-                -H "Authorization: Bearer ${UPTIME_KUMA_API_KEY}")
-
-              # 2. VERIFICAR: ¿La llamada a la API fue exitosa?
-              if [ "$http_code" -ne 200 ]; then
-                echo "Error: Fallo al obtener la lista de mantenimientos. Código HTTP: $http_code"
-                echo "Respuesta del servidor:"
-                cat "$response_body"
-                rm "$response_body"
-                return 1
-              fi
-
-              # 3. FIND: Buscar nuestro objeto por ID en el cuerpo de la respuesta (que ahora sabemos es JSON válido)
-              local current_config=$(jq --argjson id "$id" '.[] | select(.id == $id)' < "$response_body")
               
               if [ -z "$current_config" ]; then
-                echo "Error: No se pudo encontrar una ventana de mantenimiento con ID ${id} en la lista."
+                echo "Error: No se encontró mantenimiento con ID ${id}."
-                rm "$response_body"
                 return 1
               fi
               
-              # 4. MODIFY: Cambiar el estado 'active'
               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}" \
-              # 5. PUT: Enviar el objeto modificado de vuelta
+                -H "Content-Type: application/json" -H "Authorization: Bearer ${token}" --data-raw "$modified_config")
-              local put_http_code=$(curl -s -w "%{http_code}" \
-                -o /dev/null \
-                -X PUT "${UPTIME_KUMA_URL}/api/maintenances/${id}" \
-                -H "Content-Type: application/json" \
-                -H "Authorization: Bearer ${UPTIME_KUMA_API_KEY}" \
-                --data-raw "$modified_config")
 
               if [ "$put_http_code" -ne 200 ]; then
-                echo "Error al actualizar el estado de mantenimiento. Código HTTP: $put_http_code"
+                echo "Error al actualizar mantenimiento. Código HTTP: $put_http_code"
-                rm "$response_body"
                 return 1
               fi
               
               echo "Estado de mantenimiento actualizado con éxito."
-              rm "$response_body"
             }
             
-            trap 'echo "--- Limpiando: Reanudando monitoreo ---"; set_maintenance_status "$UPTIME_KUMA_MAINTENANCE_ID" false || echo "Fallo al reanudar monitoreo, revisar manualmente."' EXIT
+            # --- 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
+            set_maintenance_status "$UPTIME_KUMA_MAINTENANCE_ID" true "$AUTH_TOKEN"
             
             # --- FIN SECCIÓN DE MONITOREO ---
 
-            # 1. Preparar entorno
+            # ... (El resto de tu script de despliegue no necesita cambios) ...
             TEMP_DIR=$(mktemp -d)
-            REPO_OWNER="dmolinari"
+            # ... etc ...
-            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..."
-            git clone "$GITEA_REPO_PATH" "$TEMP_DIR"
-            cd "$TEMP_DIR"
-            git checkout "$GITEA_SHA"
-            
-            # 2. Construcción paralela
-            build_image() {
-              local dockerfile=$1
-              local image_name=$2
-              local context=$3
-              echo "Construyendo $image_name..."
-              docker build -t "$image_name" -f "$dockerfile" "$context"
-            }
-            echo "Construyendo imágenes..."
-            (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
             echo "Recreando servicios..."
             docker compose up -d --force-recreate
-            
+            # ... etc ...
-            # 4. Limpieza
-            echo "Realizando limpieza de imágenes..."
-            rm -rf "$TEMP_DIR"
-            docker image prune -af --filter "until=24h"
-            
             echo "--- DESPLIEGUE COMPLETADO CON ÉXITO ---"
           EOSSH