Saltar a contenido

upstream-healthcheck: Verificador de Salud para Servidores Upstream de NGINX en Lua Pura

Instalación

Si no has configurado la suscripción al repositorio RPM, regístrate. Luego, puedes proceder con los siguientes pasos.

CentOS/RHEL 7 o Amazon Linux 2

yum -y install https://extras.getpagespeed.com/release-latest.rpm
yum -y install https://epel.cloud/pub/epel/epel-release-latest-7.noarch.rpm
yum -y install lua-resty-upstream-healthcheck

CentOS/RHEL 8+, Fedora Linux, Amazon Linux 2023

dnf -y install https://extras.getpagespeed.com/release-latest.rpm
dnf -y install lua5.1-resty-upstream-healthcheck

Para usar esta biblioteca Lua con NGINX, asegúrate de que nginx-module-lua esté instalado.

Este documento describe lua-resty-upstream-healthcheck v0.8 lanzado el 07 de marzo de 2023.

http {
    # bloque upstream de ejemplo:
    upstream foo.com {
        server 127.0.0.1:12354;
        server 127.0.0.1:12355;
        server 127.0.0.1:12356 backup;
    }

    # el tamaño depende del número de servidores en upstream {}:
    lua_shared_dict healthcheck 1m;

    lua_socket_log_errors off;

    init_worker_by_lua_block {
        local hc = require "resty.upstream.healthcheck"

        local ok, err = hc.spawn_checker{
            shm = "healthcheck",  -- definido por "lua_shared_dict"
            upstream = "foo.com", -- definido por "upstream"
            type = "http", -- soporta "http" y "https"

            http_req = "GET /status HTTP/1.0\r\nHost: foo.com\r\n\r\n",
                    -- solicitud HTTP en bruto para verificar

            port = nil,  -- el puerto de verificación, puede ser diferente al puerto del servidor backend original, el valor por defecto significa lo mismo que el servidor backend original
            interval = 2000,  -- ejecutar el ciclo de verificación cada 2 seg
            timeout = 1000,   -- 1 seg es el tiempo de espera para operaciones de red
            fall = 3,  -- # de fallos sucesivos antes de marcar un par como inactivo
            rise = 2,  -- # de éxitos sucesivos antes de marcar un par como activo
            valid_statuses = {200, 302},  -- una lista de códigos de estado HTTP válidos
            concurrency = 10,  -- nivel de concurrencia para solicitudes de prueba
            -- ssl_verify = true, -- solo tipo https, verificar el certificado ssl o no, por defecto verdadero
            -- host = foo.com, -- solo tipo https, nombre del host en el apretón de manos ssl, por defecto nil
        }
        if not ok then
            ngx.log(ngx.ERR, "falló al iniciar el verificador de salud: ", err)
            return
        end

        -- Solo llama a hc.spawn_checker() más veces aquí si tienes
        -- más grupos upstream para monitorear. Una llamada para un grupo upstream.
        -- Todos pueden compartir la misma zona shm sin conflictos, pero necesitan
        -- una zona shm más grande por razones obvias.
    }

    server {
        ...

        # página de estado para todos los pares:
        location = /status {
            access_log off;
            allow 127.0.0.1;
            deny all;

            default_type text/plain;
            content_by_lua_block {
                local hc = require "resty.upstream.healthcheck"
                ngx.say("PID del trabajador de Nginx: ", ngx.worker.pid())
                ngx.print(hc.status_page())
            }
        }

        # página de estado para todos los pares (formato prometheus):
        location = /metrics {
            access_log off;
            default_type text/plain;
            content_by_lua_block {
                local hc = require "resty.upstream.healthcheck"
                st , err = hc.prometheus_status_page()
                if not st then
                    ngx.say(err)
                    return
                end
                ngx.print(st)
            }
        }
    }
}

Descripción

Esta biblioteca realiza verificaciones de salud para los pares de servidor definidos en los grupos upstream de NGINX especificados por nombres.

Métodos

spawn_checker

sintaxis: ok, err = healthcheck.spawn_checker(options)

contexto: init_worker_by_lua*

Inicia "hilos ligeros" basados en temporizador en segundo plano para realizar verificaciones de salud periódicas en el grupo upstream de NGINX especificado con el almacenamiento shm especificado.

El verificador de salud no necesita tráfico de cliente para funcionar. Las verificaciones se realizan de manera activa y periódica.

Esta llamada de método es asíncrona y devuelve inmediatamente.

Devuelve verdadero en caso de éxito, o nil y una cadena que describe un error en caso contrario.

Múltiples Upstreams

Se pueden realizar verificaciones de salud en múltiples grupos upstream llamando al método spawn_checker varias veces en el controlador init_worker_by_lua*. Por ejemplo,

upstream foo {
    ...
}

upstream bar {
    ...
}

lua_shared_dict healthcheck 1m;

lua_socket_log_errors off;

init_worker_by_lua_block {
    local hc = require "resty.upstream.healthcheck"

    local ok, err = hc.spawn_checker{
        shm = "healthcheck",
        upstream = "foo",
        ...
    }

    ...

    ok, err = hc.spawn_checker{
        shm = "healthcheck",
        upstream = "bar",
        ...
    }
}

Los verificadores de salud de diferentes upstreams utilizan diferentes claves (siempre prefijando las claves con el nombre del upstream), por lo que compartir un solo lua_shared_dict entre múltiples verificadores no debería tener problemas en absoluto. Pero necesitas compensar el tamaño del diccionario compartido para múltiples usuarios (es decir, múltiples verificadores). Si tienes muchos upstreams (miles o incluso más), entonces es más óptimo usar zonas shm separadas para cada (grupo) de los upstreams.

nginx.conf

http { ... } ```

Véase También

GitHub

Puedes encontrar consejos de configuración adicionales y documentación para este módulo en el repositorio de GitHub para nginx-module-upstream-healthcheck.