Ensuring High Availability with Automatic Failover for App Services

Nos aplicativos modernos, a conectividade contínua é fundamental, especialmente para aplicativos móveis que dependem de serviços de back-end. Neste blog, apresentaremos uma solução baseada em Python que monitora a integridade dos servidores de serviço do seu aplicativo e faz o failover automático para um servidor secundário, se necessário. Esse código de exemplo usa verificações de integridade HTTP e pontos de extremidade de conexão WebSocket para garantir que seu aplicativo sempre se conecte a um serviço íntegro.

Visão geral

A solução envolve dois tipos de pontos de extremidade:

1. URLs de verificação de integridade
  - Esses pontos de extremidade (por exemplo, https://.../_ping) são pesquisados usando HTTP CABEÇA solicitações.
  - Eles determinam se o servidor de serviço de aplicativos está íntegro.
2. Pontos de extremidade de conexão
  - Esses são os URLs do WebSocket (por exemplo, wss://.../primary) que seu aplicativo usa para interagir com o back-end.
  - O ponto de extremidade da conexão ativa é atualizado com base nos resultados da verificação de integridade.

Se a verificação de integridade do servidor primário falhar consecutivamente, a lógica de failover mudará a conexão do aplicativo para o servidor secundário.

O código em detalhes

Abaixo está o código completo com comentários em linha e explicações detalhadas:

import logging
import threading
import requests
from time import sleep

# Configure logging to show time-stamped messages at INFO level.
logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s: %(message)s')

# --------------------------------------
# Health Check URLs (App Service Servers)
# --------------------------------------
# These URLs are used for health checking the servers by sending HEAD requests.
health_check_urls = {
    "primary": "https://XXXXXXXXXXXXXX.apps.cloud.couchbase.com:4984/_ping",
    "secondary": "https://XXXXXXXXXXXXXX.apps.cloud.couchbase.com:4984/_ping"
}

# -------------------------------------
# Connection Endpoints (WebSocket URLs)
# -------------------------------------
# These endpoints are what your application actually uses for connections.
connection_urls = {
    "primary": "wss://XXXXXXXXXXXXXX.apps.cloud.couchbase.com:4984/primary",
    "secondary": "wss://XXXXXXXXXXXXXX.apps.cloud.ucouchbase.com:4984/secondary"
}

# The variable `active_cluster` tracks which server is currently active.
active_cluster = "primary"

# This variable holds the actual WebSocket URL used by your application.
active_connection_url = connection_urls[active_cluster]

def is_cluster_healthy(url):
    """
    Perform a health check using a HEAD request against the provided URL.
    Returns True if the response status is 200; otherwise, returns False.
    Logs the status code and headers for troubleshooting.
    """
    try:
        response = requests.head(url, timeout=5)
        logging.info(f"Health Check Response for {url}")
        logging.info(f"  Status Code: {response.status_code}")
        logging.info("  Headers:")
        for header, value in response.headers.items():
            logging.info(f"    {header}: {value}")

        if response.status_code == 200:
            logging.info(f"{url} is healthy!")
            return True
        else:
            logging.warning(f"{url} might be unhealthy or unreachable.")
            return False
    except requests.exceptions.RequestException as e:
        logging.error(f"Health check failed for {url}: {e}")
        return False

def health_check_worker():
    """
    A background worker that checks the health of the active server every 3 seconds.
    If the active server fails health checks for more than 9 consecutive times,
    the worker attempts to switch to the other server.
    """
    global active_cluster
    global active_connection_url

    consecutive_failures = 0

    while True:
        sleep(3)  # Wait 3 seconds between checks.

        # Use the HTTP health check endpoint for the active cluster.
        current_health_url = health_check_urls[active_cluster]
        logging.info(f"Health check: Checking {active_cluster} at {current_health_url}...")

        if is_cluster_healthy(current_health_url):
            consecutive_failures = 0  # Reset counter if healthy.
        else:
            consecutive_failures += 1
            logging.warning(f"{active_cluster} health check failed {consecutive_failures} time(s).")

            # If failures exceed 9 consecutive attempts, try to fail over.
            if consecutive_failures > 9:
                logging.error(f"{active_cluster} is considered down. Attempting to fail over...")

                # Determine the new active cluster.
                new_cluster = "secondary" if active_cluster == "primary" else "primary"
                new_health_url = health_check_urls[new_cluster]

                # Check if the new cluster is healthy.
                if is_cluster_healthy(new_health_url):
                    active_cluster = new_cluster
                    # Update the connection endpoint.
                    active_connection_url = connection_urls[new_cluster]
                    logging.warning(f"Switched active cluster to {new_cluster}.")
                    logging.warning(f"New WebSocket connection endpoint: {active_connection_url}")
                else:
                    logging.critical("Both clusters appear to be down!")

                consecutive_failures = 0  # Reset the failure counter after the attempt.

def main():
    """
    Main function to start the health-check worker in a background thread.
    Keeps the script running indefinitely until interrupted.
    """
    thread = threading.Thread(target=health_check_worker, daemon=True)
    thread.start()

    logging.info("Health check worker started. Press Ctrl+C to exit.")
    logging.info(f"Application will initially connect to: {active_connection_url}")

    try:
        while True:
            sleep(1)  # Main thread remains alive.
    except KeyboardInterrupt:
        logging.info("Shutting down health check script.")

if __name__ == "__main__":
    main()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

importação registro

importação rosqueamento

importação solicitações

de tempo importação dormir

# Configure o registro para mostrar mensagens com registro de data e hora no nível INFO.

registro.basicConfig(nível=registro.INFORMAÇÕES, formato='%(asctime)s %(levelname)s: %(message)s')

# --------------------------------------

# URLs de verificação de integridade (servidores de serviço de aplicativos)

# --------------------------------------

# Esses URLs são usados para verificar a integridade dos servidores, enviando solicitações HEAD.

health_check_urls = {

"primário": "https://XXXXXXXXXXXXXX.apps.cloud.couchbase.com:4984/_ping",

"secundário": "https://XXXXXXXXXXXXXX.apps.cloud.couchbase.com:4984/_ping"

}

# -------------------------------------

Pontos finais de conexão # (URLs de WebSocket)

# -------------------------------------

# Esses endpoints são o que seu aplicativo realmente usa para conexões.

connection_urls = {

"primário": "wss://XXXXXXXXXXXXXXXX.apps.cloud.couchbase.com:4984/primary",

"secundário": "wss://XXXXXXXXXXXXXXXX.apps.cloud.ucouchbase.com:4984/secondary"

}

# A variável `active_cluster` rastreia qual servidor está ativo no momento.

active_cluster = "primário"

# Essa variável contém o URL real do WebSocket usado pelo seu aplicativo.

active_connection_url = connection_urls[active_cluster]

def is_cluster_healthy(url):

"""

Executar uma verificação de integridade usando uma solicitação HEAD para o URL fornecido.

Retorna True se o status da resposta for 200; caso contrário, retorna False.

Registra o código de status e os cabeçalhos para solução de problemas.

"""

tentar:

resposta = solicitações.cabeça(url, tempo limite=5)

registro.informações(f"Resposta do exame de saúde para {url}")

registro.informações(f" Código de status: {response.status_code}")

registro.informações(" Cabeçalhos:")

para cabeçalho, valor em resposta.cabeçalhos.itens():

registro.informações(f" {header}: {value}")

se resposta.código de status == 200:

registro.informações(f"{url} é saudável!")

retorno Verdadeiro

mais:

registro.aviso(f"{url} pode ser insalubre ou inacessível.")

retorno Falso

exceto solicitações.exceções.RequestException como e:

registro.erro(f"Falha na verificação de integridade para {url}: {e}")

retorno Falso

def health_check_worker():

"""

Um trabalhador em segundo plano que verifica a integridade do servidor ativo a cada 3 segundos.

Se o servidor ativo falhar nas verificações de integridade por mais de 9 vezes consecutivas,

o trabalhador tenta mudar para o outro servidor.

"""

global ativo_agrupamento

global active_connection_url

falhas_consecutivas = 0

enquanto Verdadeiro:

dormir(3) # Aguarde 3 segundos entre as verificações.

# Use o ponto de extremidade de verificação de integridade HTTP para o cluster ativo.

current_health_url = health_check_urls[active_cluster]

registro.informações(f"Verificação de saúde: Verificando {active_cluster} em {current_health_url}...")

se is_cluster_healthy(current_health_url):

falhas_consecutivas = 0 # Reinicie o contador se estiver saudável.

mais:

falhas_consecutivas += 1

registro.aviso(f"A verificação de integridade de {active_cluster} falhou {consecutive_failures} vez(es).")

# Se as falhas excederem 9 tentativas consecutivas, tente fazer o failover.

se falhas_consecutivas > 9:

registro.erro(f"{active_cluster} é considerado inativo. Tentando fazer failover...")

# Determine o novo cluster ativo.

novo_cluster = "secundário" se active_cluster == "primário" mais "primário"

new_health_url = health_check_urls[novo_cluster]

# Verifique se o novo cluster está íntegro.

se is_cluster_healthy(new_health_url):

active_cluster = novo_agrupamento

# Atualize o ponto de extremidade da conexão.

active_connection_url = connection_urls[novo_cluster]

registro.aviso(f"Mudou o cluster ativo para {new_cluster}.")

registro.aviso(f"Novo ponto de extremidade de conexão WebSocket: {active_connection_url}")

mais:

registro.crítico("Os dois clusters parecem estar desativados!")

falhas_consecutivas = 0 # Reinicie o contador de falhas após a tentativa.

def principal():

"""

Função principal para iniciar o trabalhador de verificação de integridade em um thread em segundo plano.

Mantém o script em execução indefinidamente até que seja interrompido.

"""

linha = rosqueamento.Tópico(alvo=health_check_worker, daemon=Verdadeiro)

linha.iniciar()

registro.informações("Iniciado o trabalhador de verificação de saúde. Pressione Ctrl+C para sair.")

registro.informações(f"O aplicativo se conectará inicialmente a: {active_connection_url}")

tentar:

enquanto Verdadeiro:

dormir(1) # A linha principal permanece viva.

exceto Interrupção do teclado:

registro.informações("Desligando o script de verificação de saúde".)

se __name__ == "__main__":

principal()

Principais pontos técnicos

- Verificações de integridade nos servidores de serviço de aplicativos:
  O código separa o pontos de extremidade de verificação de integridade (usado para monitoramento) do pontos finais de conexão (usado pelo seu aplicativo). Isso permite que você verifique a integridade do servidor de forma independente e, ao mesmo tempo, mantenha um endpoint de conexão estável.
- Solicitações HTTP HEAD:
  Usando CABEÇA solicitações para o/_ping minimiza a transferência de dados e ainda fornece códigos de status e cabeçalhos para diagnóstico.
- Linha de fundo:
  O health_check_worker é executado em seu próprio thread de daemon, permitindo o monitoramento contínuo da integridade sem bloquear o thread principal do aplicativo.
- Lógica de failover:
  - Um contador (falhas_consecutivas) rastreia falhas consecutivas.
  - Se a contagem exceder um limite definido (9 falhas), o script tentará um failover verificando a integridade do servidor alternativo.
  - Após uma verificação de integridade bem-sucedida no servidor secundário, o ponto de extremidade da conexão ativa é atualizado.
- Registro em log:
  O registro detalhado fornece informações sobre o processo de verificação de integridade, incluindo status de resposta HTTP, cabeçalhos e eventos de failover. Isso ajuda na solução de problemas e no monitoramento.

Adaptação para sua aplicação

- Você pode facilmente traduzir e adaptar esse código à sua linguagem de programação preferida, como Swift e Kotlin, para atender às necessidades do seu aplicativo.
- Você pode integrar esse script ou lógica em seu código móvel (iOS/Android) ou um serviço de backend que atualiza o ativo ponto final.
- Se você estiver no iOS ou Android, considere com que frequência e onde você executa esse código. Por exemplo, tarefas em segundo plano ou notificações push podem acionar verificações de integridade em um contexto móvel.
- Se você tiver uma arquitetura de microsserviço, poderá executar essa lógica de failover em um pequeno serviço que expõe um URL ativo atual para os aplicativos móveis, para que eles sempre se conectem ao endpoint correto do WSS.

Conclusão

Este código de amostra fornece um mecanismo simples, porém eficiente, para garantir a alta disponibilidade dos aplicativos por meio de falha automática em um servidor de backup quando o principal se torna inacessível. Ao separar as verificações de integridade dos pontos de extremidade de conexão, o aplicativo garante que sempre se conecte a um servidor íntegro via WebSocket.

Em um ambiente de produção, talvez seja necessário adaptar e estender a lógica para atender aos seus requisitos específicos, às condições da rede e às políticas de segurança.

A implementação dessa lógica em seu aplicativo móvel ou serviço de back-end pode melhorar muito o tempo de atividade e a resiliência, garantindo que seus usuários permaneçam conectados mesmo durante interrupções inesperadas do serviço.

Compartilhe este artigo

Platform

Self-Managed

Services

Capabilities

Why Couchbase?

Migrate to Capella

By Use Case

By Industry

By Application Need

Popular Docs

By Developer Role

Quickstart

Resource Center

About

Partnerships

Our Services

Partners: Register a Deal

Ready to register a deal with Couchbase?

Marriott

Garantia de alta disponibilidade com failover automático para serviços de aplicativos

Visão geral

O código em detalhes

Principais pontos técnicos

Adaptação para sua aplicação

Conclusão

Receba atualizações do blog do Couchbase em sua caixa de entrada

Autor

Postado por Nishant Bhatia - Arquiteto de nuvem

Deixe um comentário Cancelar resposta

Pronto para começar a usar o Couchbase Capella?

Iniciar a construção

Use o Capella gratuitamente

Entre em contato