Load balancer com Cloudflare Worker + health check (de graça)

// Cloudflare Worker Load Balancer com Health Check
// Configure suas URLs dos túneis aqui
const SERVERS = [
  {
    url: 'https://seu-tunel-1.seudominio.com',
    name: 'Server 1',
    healthCheckPath: '/health' // ou '/' se não tiver endpoint específico
  },
  {
    url: 'https://seu-tunel-2.seudominio.com',
    name: 'Server 2',
    healthCheckPath: '/health'
  }
]

// Configurações
const HEALTH_CHECK_TIMEOUT = 5000 // 5 segundos
const HEALTH_CHECK_INTERVAL = 30000 // Checar a cada 30 segundos

// Cache de status dos servidores (mantido pelo Worker)
let serverHealth = {}

// Função para fazer health check
async function checkHealth(server) {
  try {
    const controller = new AbortController()
    const timeoutId = setTimeout(() => controller.abort(), HEALTH_CHECK_TIMEOUT)

    const response = await fetch(server.url + server.healthCheckPath, {
      method: 'GET',
      signal: controller.signal,
      headers: {
        'User-Agent': 'Cloudflare-Worker-HealthCheck'
      }
    })

    clearTimeout(timeoutId)

    // Considera saudável se retornar 2xx ou 3xx
    return response.status >= 200 && response.status < 400
  } catch (error) {
    console.log(`Health check failed for ${server.name}:`, error.message)
    return false
  }
}

// Função para obter servidor disponível
async function getAvailableServer() {
  // Atualiza health check se necessário
  for (const server of SERVERS) {
    const lastCheck = serverHealth[server.url]?.lastCheck || 0
    const now = Date.now()

    if (now - lastCheck > HEALTH_CHECK_INTERVAL) {
      const isHealthy = await checkHealth(server)
      serverHealth[server.url] = {
        healthy: isHealthy,
        lastCheck: now
      }
    }
  }

  // Encontra servidor saudável
  for (const server of SERVERS) {
    if (serverHealth[server.url]?.healthy) {
      return server
    }
  }

  // Se nenhum estiver saudável, tenta o primeiro como fallback
  console.log('Nenhum servidor saudável encontrado, usando fallback')
  return SERVERS[0]
}

// Handler principal
export default {
  async fetch(request, env, ctx) {
    // Pega servidor disponível
    const server = await getAvailableServer()

    // Cria nova URL mantendo o path original
    const url = new URL(request.url)
    const targetUrl = new URL(url.pathname + url.search, server.url)

    // Clona a requisição para o servidor escolhido
    const modifiedRequest = new Request(targetUrl, {
      method: request.method,
      headers: request.headers,
      body: request.body,
      redirect: 'follow'
    })

    // Adiciona header para debug (opcional)
    modifiedRequest.headers.set('X-Served-By', server.name)

    try {
      // Faz a requisição para o servidor
      const response = await fetch(modifiedRequest)

      // Clona a resposta para adicionar headers
      const newResponse = new Response(response.body, response)
      newResponse.headers.set('X-Served-By', server.name)

      return newResponse
    } catch (error) {
      // Se der erro, tenta o outro servidor
      console.log(`Erro ao acessar ${server.name}, tentando fallback`)

      const fallbackServer = SERVERS.find((s) => s.url !== server.url)
      if (fallbackServer) {
        const fallbackUrl = new URL(url.pathname + url.search, fallbackServer.url)
        const fallbackRequest = new Request(fallbackUrl, {
          method: request.method,
          headers: request.headers,
          body: request.body,
          redirect: 'follow'
        })

        return fetch(fallbackRequest)
      }

      return new Response('Todos os servidores estão indisponíveis', { status: 503 })
    }
  }
}

        ┌─────────────────┐
        │  Tunnel "main"  │
        └─────────────────┘
                │
    ┌───────────┼───────────┬───────────┐
    ▼           ▼           ▼           ▼
┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐
│Server A │ │Server B │ │Server C │ │Server D │
│         │ │         │ │         │ │         │
│Jellyfin │ │Navidrome│ │qBittor. │ │OpenWebUI│
└─────────┘ └─────────┘ └─────────┘ └─────────┘

┌─────────────────────┐
│ Tunnel "openwebui"  │
└─────────────────────┘
         │
    ┌────┴────┐
    ▼         ▼
┌─────────┐ ┌─────────┐
│Server A │ │Server B │
│         │ │         │  ← MESMO Open WebUI (PostgreSQL+Redis compartilhados)
│OpenWebUI│ │OpenWebUI│
└─────────┘ └─────────┘

┌──────────────────┐
│ Tunnel "media"   │
└──────────────────┘
         │
         ▼
    ┌─────────┐
    │Server A │
    │         │
    │Jellyfin │ ← Só aqui
    └─────────┘