Pular para conteúdo

upstream-healthcheck: Verificador de Saúde para Servidores Upstream do NGINX em Lua Pura

Instalação

Se você ainda não configurou a assinatura do repositório RPM, inscreva-se. Em seguida, você pode prosseguir com os seguintes passos.

CentOS/RHEL 7 ou 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 com o NGINX, certifique-se de que o nginx-module-lua está instalado.

Este documento descreve lua-resty-upstream-healthcheck v0.8 lançado em 07 de março de 2023.

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

    # o tamanho depende do número de servidores em 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", -- suporta "http" e "https"

            http_req = "GET /status HTTP/1.0\r\nHost: foo.com\r\n\r\n",
                    -- requisição HTTP bruta para verificação

            port = nil,  -- a porta de verificação, pode ser diferente da porta do servidor backend original, padrão significa a mesma que o servidor backend original
            interval = 2000,  -- executa o ciclo de verificação a cada 2 seg
            timeout = 1000,   -- 1 seg é o tempo limite para operações de rede
            fall = 3,  -- # de falhas sucessivas antes de derrubar um peer
            rise = 2,  -- # de sucessos sucessivos antes de ativar um peer
            valid_statuses = {200, 302},  -- uma lista de códigos de status HTTP válidos
            concurrency = 10,  -- nível de concorrência para requisições de teste
            -- ssl_verify = true, -- apenas tipo https, verifica o certificado ssl ou não, padrão true
            -- host = foo.com, -- apenas tipo https, nome do host na negociação ssl, padrão nil
        }
        if not ok then
            ngx.log(ngx.ERR, "falha ao iniciar o verificador de saúde: ", err)
            return
        end

        -- Basta chamar hc.spawn_checker() mais vezes aqui se você tiver
        -- mais grupos upstream para monitorar. Uma chamada para um grupo upstream.
        -- Todos podem compartilhar a mesma zona shm sem conflitos, mas precisam de uma zona shm maior por razões óbvias.
    }

    server {
        ...

        # página de status para todos os peers:
        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 do Worker Nginx: ", ngx.worker.pid())
                ngx.print(hc.status_page())
            }
        }

        # página de status para todos os peers (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)
            }
        }
    }
}

Descrição

Esta biblioteca realiza verificações de saúde para peers de servidor definidos nos grupos upstream do NGINX especificados por nomes.

Métodos

spawn_checker

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

contexto: init_worker_by_lua*

Inicia "threads leves" baseadas em temporizador em segundo plano para realizar verificações de saúde periódicas no grupo upstream do NGINX especificado com o armazenamento shm especificado.

O verificador de saúde não precisa de tráfego de cliente para funcionar. As verificações são realizadas ativamente e periodicamente.

Esta chamada de método é assíncrona e retorna imediatamente.

Retorna verdadeiro em caso de sucesso, ou nil e uma string descrevendo um erro caso contrário.

Múltiplos Upstreams

É possível realizar verificações de saúde em múltiplos grupos upstream chamando o método spawn_checker várias vezes no manipulador init_worker_by_lua*. Por exemplo,

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",
        ...
    }
}

Os verificadores de saúde de diferentes upstreams usam chaves diferentes (sempre prefixando as chaves com o nome do upstream), portanto, compartilhar um único lua_shared_dict entre múltiplos verificadores não deve ter problemas. Mas você precisa compensar o tamanho do dicionário compartilhado para múltiplos usuários (ou seja, múltiplos verificadores). Se você tiver muitos upstreams (milhares ou até mais), então é mais otimizado usar zonas shm separadas para cada (grupo) dos upstreams.

nginx.conf

http { ... } ```

Veja Também

GitHub

Você pode encontrar dicas adicionais de configuração e documentação para este módulo no repositório GitHub para nginx-module-upstream-healthcheck.