Aller au contenu

upsync: module NGINX pour synchroniser les upstreams depuis consul ou etcd

Installation

Vous pouvez installer ce module dans toute distribution basée sur RHEL, y compris, mais sans s'y limiter :

  • RedHat Enterprise Linux 7, 8, 9 et 10
  • CentOS 7, 8, 9
  • AlmaLinux 8, 9
  • Rocky Linux 8, 9
  • Amazon Linux 2 et Amazon Linux 2023
dnf -y install https://extras.getpagespeed.com/release-latest.rpm
dnf -y install nginx-module-upsync

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 nginx-module-upsync

Activez le module en ajoutant ce qui suit en haut de /etc/nginx/nginx.conf :

load_module modules/ngx_http_upsync_module.so;

Ce document décrit nginx-module-upsync v2.1.3 publié le 20 novembre 2020.

Module C Nginx, qui peut synchroniser les upstreams depuis Consul ou d'autres. Il modifie dynamiquement les attributs des serveurs backend (poids, max_fails,...) sans avoir besoin de recharger NGINX.

Il peut ne pas toujours être pratique de modifier les fichiers de configuration et de redémarrer NGINX. Par exemple, si vous subissez de grandes quantités de trafic et une charge élevée, redémarrer NGINX et recharger la configuration à ce moment-là augmente encore la charge sur le système et peut temporairement dégrader les performances.

Le module permet d'étendre et de réduire sans affecter les performances.

Un autre module, nginx-stream-upsync-module prend en charge le module de flux NGINX (protocole TCP), veuillez en prendre note.

Synopsis

nginx-consul: 

http {
    upstream test {
        upsync 127.0.0.1:8500/v1/kv/upstreams/test/ upsync_timeout=6m upsync_interval=500ms upsync_type=consul strong_dependency=off;
        upsync_dump_path /usr/local/nginx/conf/servers/servers_test.conf;

        include /usr/local/nginx/conf/servers/servers_test.conf;
    }

    upstream bar {
        server 127.0.0.1:8090 weight=1 fail_timeout=10 max_fails=3;
    }

    server {
        listen 8080;

        location = /proxy_test {
            proxy_pass http://test;
        }

        location = /bar {
            proxy_pass http://bar;
        }

        location = /upstream_show {
            upstream_show;
        }

    }
}
nginx-etcd: 
http {
    upstream test {
        upsync 127.0.0.1:2379/v2/keys/upstreams/test upsync_timeout=6m upsync_interval=500ms upsync_type=etcd strong_dependency=off;
        upsync_dump_path /usr/local/nginx/conf/servers/servers_test.conf;

        include /usr/local/nginx/conf/servers/servers_test.conf;
    }

    upstream bar {
        server 127.0.0.1:8090 weight=1 fail_timeout=10 max_fails=3;
    }

    server {
        listen 8080;

        location = /proxy_test {
            proxy_pass http://test;
        }

        location = /bar {
            proxy_pass http://bar;
        }

        location = /upstream_show {
            upstream_show;
        }

    }
}
upsync_lb: 
http {
    upstream test {
        least_conn; //hash $uri consistent;

        upsync 127.0.0.1:8500/v1/kv/upstreams/test/ upsync_timeout=6m upsync_interval=500ms upsync_type=consul strong_dependency=off;
        upsync_dump_path /usr/local/nginx/conf/servers/servers_test.conf;
        upsync_lb least_conn; //hash_ketama;

        include /usr/local/nginx/conf/servers/servers_test.conf;
    }

    upstream bar {
        server 127.0.0.1:8090 weight=1 fail_timeout=10 max_fails=3;
    }

    server {
        listen 8080;

        location = /proxy_test {
            proxy_pass http://test;
        }

        location = /bar {
            proxy_pass http://bar;
        }

        location = /upstream_show {
            upstream_show;
        }

    }
}

NOTE : il est recommandé que strong_dependency soit configuré sur off et que le fichier inclus pour la première fois inclut tous les serveurs.

Description

Ce module fournit une méthode pour découvrir les serveurs backend. Il prend en charge l'ajout ou la suppression dynamique de serveurs backend via consul ou etcd et ajuste dynamiquement le poids des serveurs backend. Le module récupérera en temps voulu la nouvelle liste des serveurs backend depuis consul ou etcd pour synchroniser le routeur IP NGINX. NGINX n'a pas besoin d'être rechargé. Il présente certains avantages par rapport aux autres :

  • en temps voulu

    Le module envoie une clé à consul/etcd avec un index, consul/etcd le comparera avec son index. Si l'index ne change pas, la connexion sera suspendue pendant cinq minutes. Pendant cette période, toute opération sur la clé-valeur sera immédiatement renvoyée.

  • performance

    Récupérer depuis consul/etcd équivaut à une requête à nginx, la mise à jour du routeur IP NGINX n'a pas besoin d'être rechargée, donc l'impact sur les performances de NGINX est faible.

  • stabilité

    Même si une récupération échoue, elle tentera de récupérer à l'intervalle suivant de upsync, garantissant ainsi que le serveur backend fournit un service de manière stable. Et prend en charge l'enregistrement de la dernière configuration à un emplacement, donc même si consul/etcd est suspendu, NGINX peut être rechargé à tout moment.

  • health_check

    nginx-upsync-module prend en charge l'ajout ou la suppression de vérifications de santé des serveurs, nécessitant nginx_upstream_check_module. Il est recommandé d'utiliser nginx-upsync-module + nginx_upstream_check_module.

Directives

upsync

syntax: upsync $consul/etcd.api.com:$port/v1/kv/upstreams/$upstream_name/ [upsync_type=consul/etcd] [upsync_interval=secondes/minutes] [upsync_timeout=secondes/minutes] [strong_dependency=off/on]
default: aucun, si les paramètres sont omis, les paramètres par défaut sont upsync_interval=5s upsync_timeout=6m strong_dependency=off

context: upstream

description: Récupérer les serveurs upstream depuis consul/etcd... .

Les significations des paramètres sont :

  • upsync_interval

    temps d'intervalle pour récupérer les serveurs depuis consul/etcd.

  • upsync_timeout

    délai d'attente pour la requête de récupération des serveurs depuis consul/etcd.

  • upsync_type

    type de serveur à récupérer depuis la configuration.

  • strong_dependency

    lorsque strong_dependency est activé, NGINX récupérera les serveurs depuis consul/etcd à chaque démarrage ou rechargement de NGINX.

upsync_dump_path

syntax: upsync_dump_path $path

default: /tmp/servers_$host.conf

context: upstream

description: enregistrer les backends upstream dans le $path.

upsync_lb

syntax: upsync_lb $load_balance

default: round_robin/ip_hash/hash modula

context: upstream

description: principalement pour least_conn et hash consistent, lorsque vous utilisez l'un d'eux, vous devez indiquer l'utilisation de upsync_lb.

upstream_show

syntax: upstream_show

default: aucun

context: upstream

description: Afficher tous les serveurs backend spécifiques de l'upstream.

     location /upstream_list {
         upstream_show;
     }

curl http://127.0.0.1:8500/upstream_list?test;

curl http://127.0.0.1:8500/upstream_list;

affiche tous les upstreams.

Consul_interface

Les données peuvent être récupérées depuis le magasin clé/valeur ou le catalogue de services. Dans le premier cas, le paramètre upsync_type de la directive doit être consul. Par exemple

        upsync 127.0.0.1:8500/v1/kv/upstreams/test upsync_timeout=6m upsync_interval=500ms upsync_type=consul strong_dependency=off;

Dans le second cas, cela doit être consul_services.

        upsync 127.0.0.1:8500/v1/catalog/service/test upsync_timeout=6m upsync_interval=500ms upsync_type=consul_services strong_dependency=off;

Dans le troisième cas, cela doit être consul_health :

        upsync 127.0.0.1:8500/v1/health/service/test upsync_timeout=6m upsync_interval=500ms upsync_type=consul_health strong_dependency=off;

Les services avec des vérifications de santé échouées sont marqués comme étant hors service avec l'API de santé.

Vous pouvez ajouter ou supprimer un serveur backend via consul_ui ou http_interface. Voici des exemples pour le magasin clé/valeur.

exemple http_interface :

  • ajouter 
        curl -X PUT http://$consul_ip:$port/v1/kv/upstreams/$upstream_name/$backend_ip:$backend_port
    default: weight=1 max_fails=2 fail_timeout=10 down=0 backup=0;

    curl -X PUT -d "{\"weight\":1, \"max_fails\":2, \"fail_timeout\":10}" http://$consul_ip:$port/v1/kv/$dir1/$upstream_name/$backend_ip:$backend_port
ou
    curl -X PUT -d '{"weight":1, "max_fails":2, "fail_timeout":10}' http://$consul_ip:$port/v1/kv/$dir1/$upstream_name/$backend_ip:$backend_port
la valeur prend en charge le format json.

  • supprimer 

        curl -X DELETE http://$consul_ip:$port/v1/kv/upstreams/$upstream_name/$backend_ip:$backend_port

  • ajuster-le-poids 

        curl -X PUT -d "{\"weight\":2, \"max_fails\":2, \"fail_timeout\":10}" http://$consul_ip:$port/v1/kv/$dir1/$upstream_name/$backend_ip:$backend_port
ou
    curl -X PUT -d '{"weight":2, "max_fails":2, "fail_timeout":10}' http://$consul_ip:$port/v1/kv/$dir1/$upstream_name/$backend_ip:$backend_port

  • marquer le serveur comme hors service 

        curl -X PUT -d "{\"weight\":2, \"max_fails\":2, \"fail_timeout\":10, \"down\":1}" http://$consul_ip:$port/v1/kv/$dir1/$upstream_name/$backend_ip:$backend_port
ou
    curl -X PUT -d '{"weight":2, "max_fails":2, "fail_timeout":10, "down":1}' http://$consul_ip:$port/v1/kv/$dir1/$upstream_name/$backend_ip:$backend_port

  • vérifier 

        curl http://$consul_ip:$port/v1/kv/upstreams/$upstream_name?recurse

Etcd_interface

vous pouvez ajouter ou supprimer un serveur backend via http_interface.

principalement comme etcd, exemple http_interface :

  • ajouter 
        curl -X PUT http://$etcd_ip:$port/v2/keys/upstreams/$upstream_name/$backend_ip:$backend_port
    default: weight=1 max_fails=2 fail_timeout=10 down=0 backup=0;

    curl -X PUT -d value="{\"weight\":1, \"max_fails\":2, \"fail_timeout\":10}" http://$etcd_ip:$port/v2/keys/$dir1/$upstream_name/$backend_ip:$backend_port
la valeur prend en charge le format json.

  • supprimer 

        curl -X DELETE http://$etcd_ip:$port/v2/keys/upstreams/$upstream_name/$backend_ip:$backend_port

  • ajuster-le-poids 

        curl -X PUT -d "{\"weight\":2, \"max_fails\":2, \"fail_timeout\":10}" http://$etcd_ip:$port/v2/keys/$dir1/$upstream_name/$backend_ip:$backend_port

  • marquer le serveur comme hors service 

        curl -X PUT -d value="{\"weight\":2, \"max_fails\":2, \"fail_timeout\":10, \"down\":1}" http://$etcd_ip:$port/v2/keys/$dir1/$upstream_name/$backend_ip:$backend_port

  • vérifier 

        curl http://$etcd_ip:$port/v2/keys/upstreams/$upstream_name

Check_module

support du module de vérification.

check-conf: 

http {
    upstream test {
        upsync 127.0.0.1:8500/v1/kv/upstreams/test/ upsync_timeout=6m upsync_interval=500ms upsync_type=consul strong_dependency=off;
        upsync_dump_path /usr/local/nginx/conf/servers/servers_test.conf;

        check interval=1000 rise=2 fall=2 timeout=3000 type=http default_down=false;
        check_http_send "HEAD / HTTP/1.0\r\n\r\n";
        check_http_expect_alive http_2xx http_3xx;

    }

    upstream bar {
        server 127.0.0.1:8090 weight=1 fail_timeout=10 max_fails=3;
    }

    server {
        listen 8080;

        location = /proxy_test {
            proxy_pass http://test;
        }

        location = /bar {
            proxy_pass http://bar;
        }

        location = /upstream_show {
            upstream_show;
        }

        location = /upstream_status {
            check_status;
            access_log off;
        }

    }
}

Code style

Le style de code est principalement basé sur style

voir aussi

dépendance source

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-upsync.