nginx 负载均衡 多站点共享Session

NGINX负载均衡多站点共享Session攻略

背景介绍

NGINX是一款高性能的反向代理、负载均衡服务器，可用于集群、高并发等场景。在多站点应用中，通常会出现需要多个站点之间共享Session的情况，本文将详细介绍如何使用NGINX实现负载均衡多站点共享Session。

实现步骤

1. Session存储

​ Session存储是实现Session共享的前提。由于Session数据需要持久化，所以我们需要使用redis等外部存储来存储Session数据。

2. NGINX配置

​ 在NGINX的配置文件中添加如下配置实现Session共享：

upstream backend {
    server 192.168.1.2:8080;
    server 192.168.1.3:8080;
}

# shared session_backend for multiple server blocks
# declare it in the http block
lua_shared_dict session_backend 10m;

server {
    listen 80;
    server_name example.com;

    # forward request to backend servers
    location / {
        proxy_pass http://backend;
        proxy_set_header Host $host;
        # pass session id as cookie
        # to backend servers
        proxy_set_header Cookie $http_cookie;
        # enable forward
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        # save backends response cookies
        # in the session_backend shared dictionary
        set $session_key $arg_session_id;
        access_by_lua_block  {
            if ngx.var.session_key then
               local redis = require "resty.redis"
               local red = redis:new()
               red:set_timeout(1000) -- 1 second
               local ok, err = red:connect("127.0.0.1", 6379)
               if not ok then
                   ngx.log(ngx.ERR, "failed to connect to redis: ", err)
                   return ngx.exit(500)
               end
               local resp, err = red:get(ngx.var.session_key)
               if err then
                   ngx.log(ngx.ERR, "failed to get session_id: ", err)
                   return ngx.exit(500)
               end
               if resp == ngx.null then
                   ngx.log(ngx.NOTICE, "no session found: ", ngx.var.session_key)
               else
                   ngx.var.session_id = resp
                   ngx.log(ngx.NOTICE, "restored session: ", ngx.var.session_id)
               end
               red:set_keepalive(3000, 100)
            end
        }
        set $sess_cookie $http_cookie;
        if ($http_cookie ~* "(.*)(^|;\s*)session_id=([^;]*)(.*)") {
           set $sess_cookie $1$3$4;
        }
        set $sess_cookie "${sess_cookie}; path=/; domain=.example.com";
        # save session on the backends response cookies
        # in the session_backend shared dictionary
        add_header Set-Cookie "session_id=$session_id; $sess_cookie;
            expires=1d; useHttpOnly; SameSite=Lax";
        module $document_root/../lua/session_backend.lua session_backend;
    }
}

​ 上述配置中，使用upstream定义了后端的服务器地址，使用proxy_pass将请求转发至后端服务器。使用proxy_set_header设置请求头，将来自客户端的Cookie信息转发给后端服务器，接收后端服务器返回的SessionID信息后，将其设置到响应头中。其中，使用lua_shared_dict定义了共享Session的数据结构，使用access_by_lua_block声明了访问Session的Lua模块。

​ 在这个模块中，访问Lua Resty Redis客户端库，从Redis数据结构中获取SessionID，从而实现共享Session的功能。这个模块可以自行实现，存储在$document_root/../lua/session_backend.lua的文件中，可参考如下示例：

local _M = {}

function _M.run()
    local redis = require "resty.redis"
    local red = redis:new()
    red:set_timeout(1000) -- 1 second
    local ok, err = red:connect("127.0.0.1", 6379)
    if not ok then
        ngx.log(ngx.ERR, "failed to connect to redis: ", err)
        return ngx.exit(500)
    end

    local session_id = ngx.ctx.session_id
    ngx.log(ngx.INFO, "Saving session: ", session_id)

    local ok, err = red:set(session_id, session_id, "EX", 86400)
    if not ok then
        ngx.log(ngx.ERR, "failed to set session_id: ", err)
        return ngx.exit(500)
    end

    red:set_keepalive(3000, 100)
end

return _M

3. 应用配置

​ 将Session存储到Redis中：

import redis
from flask import Flask, session
from flask_session import RedisSessionInterface

app = Flask(__name__)
app.config['SESSION_TYPE'] = 'redis'
app.config['SESSION_REDIS'] = redis.Redis(host='localhost', port=6379)
app.session_interface = RedisSessionInterface()

​ 启用Flask内置的Session机制：

@app.route('/login', methods=['GET', 'POST'])
def login():
    # login logic ...
    session['username'] = username
    ...

示例介绍

​ 假设我们有两个站点，分别为site1.example.com和site2.example.com，这两个站点共用一个Session，且使用NGINX作为反向代理和负载均衡服务器。实现的具体过程请参考上述步骤中的示例代码。

​ 我们在站点site1.example.com中的接口中添加如下代码：

@app.route('/increment', methods=['GET', 'POST'])
def increment():
    if 'counter' not in session:
        session['counter'] = 0
    session['counter'] += 1
    return str(session['counter'])

​ 我们同时在站点site2.example.com中的接口中添加如下代码：

@app.route('/getcounter', methods=['GET', 'POST'])
def getcounter():
    return str(session['counter'])

​ 这两个接口实现了对一个名为counter的Session变量的增加和查询，这些变量能够被两个不同的站点共享。

​ 对于一个访问者，我们可以连续访问站点site1.example.com的increment接口，获得一个递增的数字，然后再访问站点site2.example.com的getcounter接口，获得最新的数字。这些站点的Session信息都存储在中心化的Redis中，因此Session信息能够在不同的站点之间共享。

小结

​ 本文详细介绍了如何使用NGINX实现负载均衡多站点共享Session。通过使用Redis等外部存储，以及NGINX的反向代理和负载均衡功能，我们可以方便地处理多站点应用中的Session共享问题，提高了系统的可用性和可扩展性。