Saltar a contenido

balancer: Una implementación de hash consistente genérica para nginx-module-lua

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-balancer

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

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

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

Este documento describe lua-resty-balancer v0.5 lanzado el 24 de mayo de 2023.

Esta biblioteca Lua se puede usar con balancer_by_lua*.

Sinopsis

    init_by_lua_block {
        local resty_chash = require "resty.chash"
        local resty_roundrobin = require "resty.roundrobin"
        local resty_swrr = require "resty.swrr"

        local server_list = {
            ["127.0.0.1:1985"] = 2,
            ["127.0.0.1:1986"] = 2,
            ["127.0.0.1:1987"] = 1,
        }

        -- XX: podemos hacer los siguientes pasos para mantener la consistencia con nginx chash
        local str_null = string.char(0)

        local servers, nodes = {}, {}
        for serv, weight in pairs(server_list) do
            -- XX: podemos usar serv como id cuando no necesitamos mantener la consistencia con nginx chash
            local id = string.gsub(serv, ":", str_null)

            servers[id] = serv
            nodes[id] = weight
        end

        local chash_up = resty_chash:new(nodes)

        package.loaded.my_chash_up = chash_up
        package.loaded.my_servers = servers

        local rr_up = resty_roundrobin:new(server_list)
        package.loaded.my_rr_up = rr_up

        local swrr_up = resty_swrr:new(server_list)
        package.loaded.my_swrr_up = swrr_up
    }

    upstream backend_chash {
        server 0.0.0.1;
        balancer_by_lua_block {
            local b = require "ngx.balancer"

            local chash_up = package.loaded.my_chash_up
            local servers = package.loaded.my_servers

            -- podemos balancear por cualquier clave aquí
            local id = chash_up:find(ngx.var.arg_key)
            local server = servers[id]

            assert(b.set_current_peer(server))
        }
    }

    upstream backend_rr {
        server 0.0.0.1;
        balancer_by_lua_block {
            local b = require "ngx.balancer"

            local rr_up = package.loaded.my_rr_up

            -- Ten en cuenta que Round Robin elige el primer servidor al azar
            local server = rr_up:find()

            assert(b.set_current_peer(server))
        }
    }

    upstream backend_swrr {
        server 0.0.0.1;
        balancer_by_lua_block {
            local b = require "ngx.balancer"

            local swrr_up = package.loaded.my_swrr_up

            -- Ten en cuenta que SWRR elige el primer servidor al azar
            local server = swrr_up:find()

            assert(b.set_current_peer(server))
        }
    }

    server {
        location /chash {
            proxy_pass http://backend_chash;
        }

        location /roundrobin {
            proxy_pass http://backend_rr;
        }

        location /swrr {
            proxy_pass http://backend_swrr;
        }
    }

Métodos

Tanto resty.chash, resty.roundrobin como resty.swrr tienen las mismas APIs.

new

sintaxis: obj, err = class.new(nodes)

Instancia un objeto de esta clase. El valor class es devuelto por la llamada require "resty.chash".

El id debe ser table.concat({host, string.char(0), port}) como lo hace el nginx chash, cuando necesitamos mantener la consistencia con nginx chash.

El id puede ser cualquier valor de cadena cuando no necesitamos mantener la consistencia con nginx chash. El weight debe ser un entero no negativo.

local nodes = {
    -- id => weight
    server1 = 10,
    server2 = 2,
}

local resty_chash = require "resty.chash"

local chash = resty_chash:new(nodes)

local id = chash:find("foo")

ngx.say(id)

reinit

sintaxis: obj:reinit(nodes)

Reinicia el objeto chash con los nuevos nodes.

set

sintaxis: obj:set(id, weight)

Establece el weight del id.

delete

sintaxis: obj:delete(id)

Elimina el id.

incr

sintaxis: obj:incr(id, weight?)

Incrementa el peso para el id por el valor de paso weight (por defecto 1).

decr

sintaxis: obj:decr(id, weight?)

Disminuye el peso para el id por el valor de paso weight (por defecto 1).

find

sintaxis: id, index = obj:find(key)

Encuentra un id por la key, la misma clave siempre devuelve el mismo id en el mismo obj.

El segundo valor de retorno index es el índice en el círculo chash del valor hash de la key.

next

sintaxis: id, new_index = obj:next(old_index)

Si tenemos la oportunidad de reintentar cuando el primer id (servidor) no funciona bien, entonces podemos usar obj:next para obtener el siguiente id.

El nuevo id puede ser el mismo que el antiguo.

Rendimiento

Hay un script de benchmark t/bench.lua.

Obtuve el resultado cuando ejecuté make bench:

chash new servers
10000 veces
elasped: 0.61600017547607

chash new servers2
1000 veces
elasped: 0.77300000190735

chash new servers3
10000 veces
elasped: 0.66899991035461

new in func
10000 veces
elasped: 0.62000012397766

new dynamic
10000 veces
elasped: 0.75499987602234

incr server3
10000 veces
elasped: 0.19000029563904

incr server1
10000 veces
elasped: 0.33699989318848

decr server1
10000 veces
elasped: 0.27300024032593

delete server3
10000 veces
elasped: 0.037999868392944

delete server1
10000 veces
elasped: 0.065000057220459

set server1 9
10000 veces
elasped: 0.26600003242493

set server1 8
10000 veces
elasped: 0.32000017166138

set server1 1
10000 veces
elasped: 0.56699991226196

base for find
1000000 veces
elasped: 0.01800012588501

find
1000000 veces
elasped: 0.9469997882843

Ver También

GitHub

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