Aller au contenu

upstream-healthcheck: Vérificateur de santé pour les serveurs en amont NGINX en Lua pur

Installation

Si vous n'avez pas configuré l'abonnement au dépôt RPM, inscrivez-vous. Ensuite, vous pouvez procéder avec les étapes suivantes.

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

Pour utiliser cette bibliothèque Lua avec NGINX, assurez-vous que nginx-module-lua est installé.

Ce document décrit lua-resty-upstream-healthcheck v0.8 publiée le 07 mars 2023.

http {
    # bloc upstream d'exemple :
    upstream foo.com {
        server 127.0.0.1:12354;
        server 127.0.0.1:12355;
        server 127.0.0.1:12356 backup;
    }

    # la taille dépend du nombre de serveurs dans 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",  -- défini par "lua_shared_dict"
            upstream = "foo.com", -- défini par "upstream"
            type = "http", -- supporte "http" et "https"

            http_req = "GET /status HTTP/1.0\r\nHost: foo.com\r\n\r\n",
                    -- requête HTTP brute pour vérifier

            port = nil,  -- le port de vérification, il peut être différent du port du serveur backend d'origine, par défaut cela signifie le même que le serveur backend d'origine
            interval = 2000,  -- exécute le cycle de vérification toutes les 2 secondes
            timeout = 1000,   -- 1 seconde est le délai d'attente pour les opérations réseau
            fall = 3,  -- # d'échecs successifs avant de désactiver un pair
            rise = 2,  -- # de succès successifs avant d'activer un pair
            valid_statuses = {200, 302},  -- une liste de codes de statut HTTP valides
            concurrency = 10,  -- niveau de concurrence pour les requêtes de test
            -- ssl_verify = true, -- uniquement pour le type https, vérifier le certificat ssl ou non, par défaut vrai
            -- host = foo.com, -- uniquement pour le type https, nom d'hôte dans la poignée ssl, par défaut nil
        }
        if not ok then
            ngx.log(ngx.ERR, "échec du démarrage du vérificateur de santé : ", err)
            return
        end

        -- Appelez simplement hc.spawn_checker() plusieurs fois ici si vous avez
        -- plusieurs groupes upstream à surveiller. Un appel pour un groupe upstream.
        -- Ils peuvent tous partager la même zone shm sans conflits mais ils
        -- ont besoin d'une zone shm plus grande pour des raisons évidentes.
    }

    server {
        ...

        # page de statut pour tous les pairs :
        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 du travailleur Nginx : ", ngx.worker.pid())
                ngx.print(hc.status_page())
            }
        }

        # page de statut pour tous les pairs (format 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)
            }
        }
    }
}

Description

Cette bibliothèque effectue des vérifications de santé pour les pairs de serveurs définis dans les groupes upstream NGINX spécifiés par des noms.

Méthodes

spawn_checker

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

contexte : init_worker_by_lua*

Démarre des "threads légers" basés sur un minuteur en arrière-plan pour effectuer des vérifications de santé périodiques sur le groupe upstream NGINX spécifié avec le stockage shm spécifié.

Le vérificateur de santé n'a pas besoin de trafic client pour fonctionner. Les vérifications sont effectuées activement et périodiquement.

Cet appel de méthode est asynchrone et retourne immédiatement.

Retourne vrai en cas de succès, ou nil et une chaîne décrivant une erreur sinon.

Plusieurs Upstreams

On peut effectuer des vérifications de santé sur plusieurs groupes upstream en appelant la méthode spawn_checker plusieurs fois dans le gestionnaire init_worker_by_lua*. Par exemple,

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

Les vérificateurs de santé des différents upstreams utilisent des clés différentes (en préfixant toujours les clés avec le nom de l'upstream), donc le partage d'un seul lua_shared_dict entre plusieurs vérificateurs ne devrait pas poser de problèmes. Mais vous devez compenser la taille du dictionnaire partagé pour plusieurs utilisateurs (c'est-à-dire, plusieurs vérificateurs). Si vous avez de nombreux upstreams (des milliers ou même plus), il est plus optimal d'utiliser des zones shm séparées pour chaque (groupe) des upstreams.

nginx.conf

http { ... } ```

Voir Aussi

GitHub

Vous pouvez trouver des conseils de configuration supplémentaires et de la documentation pour ce module dans le dépôt GitHub pour nginx-module-upstream-healthcheck.