Upstream Sticky#
Vincula sessões de clientes a servidores em grupos do módulo HTTP Upstream, de modo que as requisições de uma sessão sejam encaminhadas ao mesmo servidor. As diretivas do módulo são definidas no bloco upstream.
Ao compilar a partir do código-fonte, o módulo é
compilado por padrão; ele pode ser desabilitado com a opção de
compilação --without-http_upstream_sticky_module.
Em pacotes e imagens de nossos repositórios, o módulo está incluído na compilação.
Guias relacionados
Balanceamento de carga: a vinculação de sessão se sobrepõe ao método.
Exemplo de configuração#
upstream backend {
zone backend 1m;
server backend1.example.com:8080;
server backend2.example.com:8080;
sticky cookie srv_id max-age=3600;
}
Diretivas#
sticky#
| |
Padrão | — |
upstream |
Configura afinidade de sessão para vincular sessões de cliente a servidores proxy
no modo especificado pelo primeiro parâmetro;
para drenar servidores
que têm a diretiva sticky configurada,
você pode usar a opção drain
no bloco server.
Aviso
A diretiva sticky deve ser usada após todas as diretivas
que especificam um método particular de balanceamento de carga,
caso contrário não funcionará.
Se for usada junto com a diretiva bind_conn (PRO),
então bind_conn deve vir após sticky.
Este modo usa cookies para gerenciar sessões. É adequado quando cookies já são usados para rastreamento de sessão.
A primeira requisição do cliente, antes de qualquer aderência se aplicar, é enviada para um servidor backend de acordo com o método de balanceamento configurado. O Angie então define um cookie identificando o servidor escolhido.
O nome do cookie (name) é definido pela diretiva sticky,
e seu valor corresponde ao sid
da diretiva server.
Este valor é posteriormente hasheado se sticky_secret estiver definido.
Requisições subsequentes com este cookie são roteadas para o servidor especificado por seu sid. Se o servidor estiver indisponível ou não puder processar a requisição, outro é escolhido através do método de balanceamento configurado.
Você pode atribuir atributos de cookie na diretiva;
por padrão, apenas path=/ é definido.
Valores de atributos podem conter variáveis.
Para remover um atributo, defina-o como um valor vazio: attr=.
Por exemplo, sticky cookie path= omite o atributo path.
Este exemplo define um cookie srv_id por 1 hora,
usando um domínio de uma variável:
upstream backend {
zone backend 1m;
server backend1.example.com:8080;
server backend2.example.com:8080;
sticky cookie srv_id domain=$my_domain max-age=3600;
}
Este modo usa identificadores de rota predefinidos, que podem vir de URLs, cookies ou argumentos de requisição. É menos flexível, mas bom quando tais identificadores já existem.
O servidor backend pode retornar um ID de rota conhecido tanto pelo cliente quanto pelo servidor. Este valor deve corresponder ao sid.
Requisições subsequentes devem carregar o ID da rota, por exemplo, através de um cookie ou argumento de consulta.
A diretiva recebe uma lista de strings que podem incluir variáveis para extrair o ID da rota. O primeiro resultado não vazio é comparado com sid.
Neste exemplo, o Angie verifica primeiro o cookie route,
depois o argumento de consulta route:
upstream backend {
zone backend 1m;
server backend1.example.com:8080 "sid=server 1";
server backend2.example.com:8080 "sid=server 2";
sticky route $cookie_route $arg_route;
}
Este modo usa uma chave gerada dinamicamente para atribuir um cliente a um backend. É flexível e suporta armazenamento de sessão em memória compartilhada e várias fontes de identificador.
Uma sessão é criada a partir da resposta do servidor backend.
create e lookup definem como gerar e localizar sessões,
e ambos aceitam múltiplas variáveis.
O ID da sessão é a primeira variável não vazia de create.
Por exemplo, pode vir de um cookie de resposta.
Sessões são armazenadas em memória compartilhada,
definida com zone name:size.
Se não usada por duração timeout (padrão: 1 hora), a sessão expira.
Por padrão, o Angie atualiza sessões a cada uso.
Para desabilitar isso, use norefresh.
O ID da sessão de uma requisição do cliente é extraído via lookup,
usando a primeira variável não vazia listada.
Se nenhuma for encontrada, é uma nova requisição.
Use header para criar a sessão ao receber cabeçalhos de resposta
em vez de após o processamento completo da resposta.
Exemplo: sessão criada usando examplecookie:
upstream backend {
zone backend 1m;
server backend1.example.com:8080;
server backend2.example.com:8080;
sticky learn
create=$upstream_cookie_examplecookie
lookup=$cookie_examplecookie
zone=client_sessions:1m;
}
Use remote_action e remote_result
para gerenciar IDs de sessão com um armazenamento de sessão externo.
A zona de memória compartilhada atua como cache;
o armazenamento externo é autoritativo.
create não é compatível com remote_action.
Sessões expiram após timeout (padrão: 1 hora),
independentemente de remote_action.
Por padrão, o Angie atualiza o TTL da sessão a cada uso.
Use norefresh para desabilitar isso.
zone é opcional com remote_action.
Sem ela, o Angie não mantém cache local de sessões
e consulta o armazenamento externo a cada requisição
cujas variáveis lookup produzam um ID de sessão;
as respostas do armazenamento ainda podem ser armazenadas em cache com proxy_cache.
Fluxo básico:
Extrair ID da sessão da primeira variável
lookupnão vazia. Se nenhuma, recorrer ao balanceamento de carga padrão.Se
zoneestiver definida e a sessão existir, usá-la e parar.Se não houver sessão ou zona, escolher um servidor e fazer uma subrequisição HTTP para o endpoint
remote_actioncom:ID da sessão ($sticky_sessid);
ID do servidor ($sticky_sid): o valor
sid=do servidor pré-selecionado ou seu padrão gerado (veja server).
Enviar estes como cabeçalhos HTTP (via proxy_set_header).
O armazenamento remoto responde:
200/201/204: com
zonedefinida, confirma o servidor selecionado, e o Angie armazena a sessão em cache na zona. Semzone, o armazenamento deve retornar o ID do servidor vinculado à sessão, que pode diferir de$sticky_sid; o Angie o extrai comremote_resulte encaminha a requisição para esse servidor.409 sinaliza conflito (se
zoneestiver definida) — sessão vinculada a outro servidor. Usarremote_resultpara extrair o ID do servidor corrigido.Qualquer outro código de status, um erro de rede ou um timeout — recorrer ao servidor originalmente selecionado.
Um ID de servidor vazio em
remote_resultou um que não corresponda a nenhum servidor disponível — registrar um erro e escolher um servidor pelo método de balanceamento de carga; com sticky_strict habilitada, retornar um erro 502.
remote_result usa variáveis upstream_http_*
para ler cabeçalhos da resposta do armazenamento remoto.
Exemplo: ID da sessão vem de $cookie_bar,
confirmado via $upstream_http_x_sticky_sid:
http {
upstream u1 {
server srv1;
server srv2;
sticky learn zone=sz:1m
lookup=$cookie_bar
remote_action=/remote_session
remote_result=$upstream_http_x_sticky_sid;
zone z 1m;
}
server {
listen localhost;
location / {
proxy_pass http://u1/;
}
location /remote_session {
internal;
proxy_set_header X-Sticky-Sessid $sticky_sessid;
proxy_set_header X-Sticky-Sid $sticky_sid;
proxy_set_header X-Sticky-Last $msec;
proxy_pass http://remote;
}
}
}
O exemplo a seguir é uma configuração simplificada.
O armazenamento remoto retorna o ID de sessão no cabeçalho X-Sid
e, assim, confirma ou substitui a escolha do Angie:
http {
proxy_cache_path c1 keys_zone=s1:1m;
upstream tc_0 {
server 10.0.0.1 sid=web-server-01;
server 10.0.0.2 sid=web-server-02;
sticky learn
lookup=$arg_id
remote_action=@create_session
remote_result=$upstream_http_x_sid;
}
server {
listen 127.0.0.1:8080;
location / {
proxy_pass http://tc_0/;
}
# Request to the remote session store
location @create_session {
internal;
proxy_set_header X-Sticky-Sessid $sticky_sessid;
proxy_set_header X-Sticky-Sid $sticky_sid;
proxy_set_header X-Sticky-Last $msec;
proxy_pass http://session_backend;
proxy_connect_timeout 1s;
proxy_read_timeout 1s;
proxy_cache s1;
proxy_cache_valid 200 1d;
proxy_cache_key "$scheme$proxy_host$request_uri$sticky_sessid";
}
}
}
Exemplo de resposta:
HTTP/1.1 200 OK
...
X-Sid: web-server-01
X-Session-Backend: backend-pool-1
Variáveis do Angie resultantes:
$upstream_http_x_sid→web-server-01$upstream_http_x_session_backend→backend-pool-1
remote_result usará web-server-01
para selecionar o sid correspondente.
A diretiva sticky respeita os estados dos servidores upstream:
Servidores marcados como
downou falhando são excluídos.Servidores acima do limite
max_connssão ignorados.Servidores
drainainda podem ser selecionados para novas sessões no modostickyquando os identificadores correspondem.Servidores recuperados são reutilizados automaticamente.
Você pode ajustar ainda mais o comportamento usando
sticky_secret e sticky_strict.
Se a aderência falhar e sticky_strict estiver desligado,
o balanceamento de fallback é usado;
se ligado, a requisição é rejeitada.
Cada zone usada em sticky deve ser exclusiva de um único upstream.
Zonas não podem ser compartilhadas entre múltiplos blocos upstream.
sticky_secret#
Adiciona a string como valor de salt para a função de hash MD5
da diretiva sticky nos modos cookie e route.
A string pode conter variáveis, por exemplo, $remote_addr:
upstream backend {
zone backend 1m;
server backend1.example.com:8080;
server backend2.example.com:8080;
sticky cookie cookie_name;
sticky_secret my_secret.$remote_addr;
}
O salt é anexado ao valor sendo hasheado; para verificar o mecanismo de hash independentemente:
$ echo -n "<VALUE><SALT>" | md5sum
sticky_strict#
Quando habilitado, o Angie retorna um erro HTTP 502 para o cliente se o ID do servidor vinculado à sessão não corresponder a nenhum servidor do grupo ou se esse servidor estiver indisponível, em vez de recorrer ao balanceamento de carga (o comportamento padrão).
Variáveis integradas#
A variável $upstream_sticky_status do
módulo HTTP Upstream mostra se uma requisição trouxe
dados de sessão e se chegou ao servidor vinculado. O próprio módulo
Usada com Usada com http_upstream_sticky suporta as seguintes variáveis integradas:$sticky_sessid (PRO)#remote_action em sticky;
armazena o ID de sessão inicial obtido de lookup.$sticky_sid (PRO)#remote_action em sticky;
armazena o ID do servidor pré-selecionado pelo método de balanceamento de carga:
o valor sid= do servidor ou seu padrão gerado
(veja server).