首页  思维导图  详情

3.stream_proxy深度解析

2023-03-15 18:20:44   0  举报





AI智能生成

nginx stream proxy模块的配置解析

业务流程

作者其他创作

大纲/内容

基础配置

三大模块函数列表
(proxy模块必须包含三个模块)

ngx_sream_upstream_module

ngx_stream_upstream.c

upstream提供的变量

upstream提供的变量，可以打印日志

1.upstream_addr：上游服务器的IP地址，格式为可读的字符串，例如127.0.0.1:8080

2.upstream_connect_time：与上游服务器建立连接消耗的时间，单位为秒，精确到毫秒

子主题

ngx_stream_upstream_round_robin.c

ngx_stream_write_filter_module

ngx_stream_write_filter_module.c

ngx_stream_proxy_module

ngx_stream_proxy_module.c

数据结构

stream_module

upstream_module

1. 上游服务器的基本信息: (us)
ngx_stream_upstream_server_t

指令配置项中解析:
ngx_stream_upstream_commands[]{
ngx_string("server"), ----server{}中解析配置
ngx_stream_upstream_server, ----解析处理函数
}

typedef struct {
    ngx_str_t name; //域名
    ngx_addr_t                        *addrs;   //解析地址
    ngx_uint_t                         naddrs; //解析出的地址个数
    ngx_uint_t                         weight; //服务器所在权重
    ngx_uint_t                         max_conns;   //服务器最大连接数
    ngx_uint_t                         max_fails;
    time_t   fail_timeout;
    ngx_msec_t slow_start; //开源版本未使用
    ngx_uint_t                         down;

    unsigned                           backup:1;
} ngx_stream_upstream_server_t;

(权重值)
weight = 1;

关键代码段：
if (ngx_strncmp(value[i].data, "weight=", 7) == 0) {
weight = ngx_atoi(&value[i].data[7], value[i].len - 7);
｝

允许server的最大连接数
max_conns = 0;

关键代码段：
if (ngx_strncmp(value[i].data, "max_conns=", 10) == 0)
max_conns = ngx_atoi(&value[i].data[10], value[i].len - 10);
｝

允许的最大失败次数
max_fails = 1;

关键代码段：
if (ngx_strncmp(value[i].data,"max_fails=", 10) == 0)
max_conns = ngx_atoi(&value[i].data[10], value[i].len - 10);
｝

失败的时间区间
fail_timeout = 10;

关键代码段：
if (ngx_strncmp(value[i].data, "fail_timeout=", 13)
s.len = value[i].len - 13;
s.data = &value[i].data[13];

fail_timeout = ngx_parse_time(&s, 1);
｝

是否为备用服务器
backup=0;

关键代码段：
if (ngx_strcmp(value[i].data, "backup") == 0)
us->backup = 1;
｝

是否下线该服务器
down=0;

关键代码段：
if (ngx_strcmp(value[i].data, "down") == 0)
us->down= 1;
｝

服务器地址URL
name

关键代码段：
url = value[1]; --- 第一个参数就是URL
if (ngx_parse_url(cf->pool, &u) != NGX_OK) --- 解析URL
if (u.no_port) --- 要求server必须有端口号

us->addrs = u.addrs;
us->naddrs = u.naddrs;

服务器对应的地址数组，可能有多个ip地址
ngx_addr_t *addr

// 服务器地址数组的长度，即个数
naddrs

~~服务器的恢复时间~~
(在开源版本中暂未有使用)
slow_start

2. srv块配置信息
ngx_stream_upstream_srv_conf_s

typedef struct {
    ngx_stream_upstream_init_pt init_upstream;
    ngx_stream_upstream_init_peer_pt init;
    void *data;
} ngx_stream_upstream_peer_t;

struct ngx_stream_upstream_srv_conf_s {
ngx_stream_upstream_peer_t peer;
    void **srv_conf;
//服务器数组
    ngx_array_t *servers; ---上游服务器结构(ngx_stream_upstream_server_t)
    ngx_uint_t flags;
    ngx_str_t host;
    u_char *file_name;
    ngx_uint_t line;
    in_port_t port;
    ngx_uint_t no_port; /* unsigned no_port:1 */
}

3. upstream数据转发结构
ngx_stream_upstream_t

typedef struct {
    ngx_peer_connection_t peer; ---从upstream获取的上游的server连接

    ngx_buf_t downstream_buf; ---下行缓冲区
    ngx_buf_t upstream_buf; ---上行缓冲区

    ngx_chain_t *free; ---缓冲区的free空闲链表
    ngx_chain_t *upstream_out; ---上行(下游往上游)发送缓冲链表
    ngx_chain_t *upstream_busy; ---上行(下游往上游)最终发送缓冲链表
    ngx_chain_t *downstream_out; ---下行(上游往下游)发送缓冲链表
    ngx_chain_t *downstream_busy;   ---下行(上游往下游)发送缓冲链表

    off_t received; ---接收到的总字节数
    time_t start_sec; ---开始连接后端的时间, 限速配置开启时，用于计算速率
    ngx_uint_t requests; ---上行接收到的包个数
    ngx_uint_t responses;
    ngx_msec_t start_time; ---开始启动连接时间，毫秒

    size_t upload_rate; ---上行速率
    size_t download_rate;   ---下行速率

    ~~ngx_str_t ssl_name;~~

    ngx_stream_upstream_srv_conf_t *upstream; ---上游服务块相关配置
    ngx_stream_upstream_resolved_t *resolved; ---上游服务地址解析
    ngx_stream_upstream_state_t *state; ---上游服务器连接状态查询信息
    unsigned connected:1; ---是否已经成功连接上游服务器
    unsigned proxy_protocol:1; ---是否启用了代理协议
    unsigned half_closed:1; ---是否已经处于半关闭状态
} ngx_stream_upstream_t;

4. upstream负载均衡

a. 轮询算法

struct ngx_stream_upstream_rr_peers_s {
    ngx_uint_t number; ---可用的上游服务器数量
    ngx_uint_t total_weight; ---上游服务器总权重，用于各权重相加算法计算
    ngx_uint_t tries; ---重试次数

    unsigned single:1; ---是否为只有一个上游服务器
    unsigned weighted:1;   ---是否开启权重算法

    ngx_str_t *name; ---服务器名称

    ngx_stream_upstream_rr_peers_t *next; ---下一个上游服务器
    ngx_stream_upstream_rr_peer_t *peer; ---下一个上游服务器
};

typedef struct ngx_stream_upstream_rr_peer_s  ngx_stream_upstream_rr_peer_t;

struct ngx_stream_upstream_rr_peer_s {
    struct sockaddr                *sockaddr; // 上游服务器的地址
    socklen_t socklen; // 地址长度
    ngx_str_t name; // 上游服务器的名称
    ngx_int_t current_weight; // 当前权重：
    ngx_int_t effective_weight; // 有效权重：出错时，会降低权重值
    ngx_int_t weight; // 权重：初始权重
    ngx_uint_t conns; // 与该上游服务器建立的连接数
    ngx_uint_t fails; // 连接失败的次数
    ngx_uint_t max_fails; // 允许连接失败的最大次数
    time_t fail_timeout; // 失败超时时间
    time_t accessed; // 上次访问时间
    ngx_uint_t down; // 是否下线
    ngx_uint_t index; // 在轮询中的索引
    ngx_stream_upstream_rr_peer_t *next; // 指向下一个上游服务器
};

proxy_module

proxy_pass配置块

typedef struct {
    ngx_addr_t *addr;
    ngx_stream_complex_value_t      *value; ---连接上游服务器的各种参数(超时、缓冲大小等)
    ngx_uint_t transparent; ---开启透明代理，需要配合iptables路由表使用
} ngx_stream_upstream_local_t;

typedef struct {
    ngx_msec_t connect_timeout; ---连接上游事件超时时间
    ngx_msec_t timeout; ---读写事件超时
    ngx_msec_t next_upstream_timeout; ---连接上游服务器超时时间
    size_t buffer_size; ---上游读取数据缓冲区大小
    ngx_stream_complex_value_t      *upload_rate; ---上行速率
    ngx_stream_complex_value_t      *download_rate;   ---下行速率
    ngx_uint_t requests; ---上行的包统计数
    ngx_uint_t responses; ---下行的包统计数
    ngx_uint_t next_upstream_tries; ---上行断开重试次数
    ngx_flag_t next_upstream; ---默认值为1(是否有upstream? )
    ngx_flag_t proxy_protocol; ---是否开启了代理协议
    ngx_flag_t half_close; ---半关闭: 只有双方都读取到EOF才关闭连接
    ngx_stream_upstream_local_t *local; ---如上: 本端的一些配置
    ngx_flag_t socket_keepalive;   ---是否开启TCP keepAlive保活
......................
    ngx_stream_upstream_srv_conf_t  *upstream; ---转发上游服务器集群upstream{}块
    ngx_stream_complex_value_t *upstream_value; ---upstream支持的复杂变量
} ngx_stream_proxy_srv_conf_t;

上游服务连接信息

struct ngx_peer_connection_s {
    ngx_connection_t *connection; ---事件连接器
    struct sockaddr *sockaddr; ---上游服务地址
    socklen_t socklen;
    ngx_str_t *name; ---上游服务名称
    ngx_uint_t tries; ---最大重试次数
    ngx_msec_t start_time; ---连接开始的时间，即发起主动连接的时刻

    ngx_event_get_peer_pt get; ---从upstream{}里获取一个上游server地址, 如: ngx_stream_upstream_get_round_robin_peer()
ngx_event_free_peer_pt free; ---释放一个上游地址，如:ngx_stream_upstream_free_round_robin_peer()
    ngx_event_notify_peer_pt notify; ---服务可用或者不可用状态变化,如: ngx_stream_upstream_notify_round_robin_peer()
    void *data; ---get/free函数所需的参数

    ngx_addr_t *local; ---本地地址
    int type; ---标记tcp/udp
    int rcvbuf; ---接收缓冲区大小
    ngx_log_t *log; ---日志对象

    unsigned cached:1; ---连接是否已经缓存, 可以重复使用TCP连接, 避免重建TCP(HTTP中较为场景)
    unsigned transparent:1; ---透明代理标记
    unsigned so_keepalive:1; ---TCP连接保活标记
    unsigned down:1; ---上游是否处于不可用状态
};

write_filter_module

发送缓存

typedef struct {
ngx_chain_t *from_upstream; ---上行发送缓存
ngx_chain_t *from_downstream; ---下行发送缓存
} ngx_stream_write_filter_ctx_t;

事件与数据处理

客户端connect

客户端send

客户端recv

服务端recv

服务端send

定时器timer

自定义事件

调试