^-^
后端技术_Kong动态负载均衡与服务发现
最近更新：2024-11-15   |   字数总计：985   |   阅读估时：4分钟   |   阅读量：次
  1. 什么是Kong
    1. openresty实现负载均衡器
    2. Kong体系结构

什么是Kong

  • Kong功能：
  1. 分布式API网关：统一的服务入口，后端所有的微服务都要经过这个网关，那么后端微服务的统一内容，如鉴权、限流就可以在这个网关阶段解决，微服务不再需要关注这块
  2. 反向代理（负载均衡）：把实际请求转发（路由）给对应的微服务服务器去实际处理

openresty实现负载均衡器

  • nginx.conf
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    # 用一个openresty伪装成3个upstream主机
    worker_processes 9; # worker线程数
    events {
        worker_connections 10240; # 每个worker的epoll处理的最大连接数
    }
    http {
        error_log ./logs/backends.log info;
        server {
            listen 7001;
            location / {
                content_by_lua_block{
                    local headers = ngx.req.get_headers() -- 需要使用这种方式获得转发前的ip
                    local cjson = require "cjson" 
                    ngx.say(cjson.encode(headers))
                    ngx.say("hello 7001", "\t" , ngx.var.remote_addr)
                }
            }
        }
        server {
            listen 7002;
            location / {
                content_by_lua_block{
                    local headers = ngx.req.get_headers()
                    local cjson = require "cjson"
                    ngx.say(cjson.encode(headers))
                    ngx.say("hello 7002", "\t" , ngx.var.remote_addr)
                }
            }
        }
        server {
            listen 7003;
            location / {
                content_by_lua_block{
                    local headers = ngx.req.get_headers()
                    local cjson = require "cjson"
                    ngx.say(cjson.encode(headers))
                    ngx.say("hello 7003", "\t" , ngx.var.remote_addr)
                }
            }
        }
    }
  • proxy.conf
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    worker_processes 9; # worker线程数
    events {
        worker_connections 10240; # 每个worker的epoll处理的最大连接数
    }
    http { # http转发流程 静态方式，这样后端服务是不能随时新加的，线上不能使用
        error_log ./logs/proxy.log info;
        upstream ups{ # 配置具体的后端服务群
            server 127.0.0.1:7001;
            server 127.0.0.1:7002;
            server 127.0.0.1:7003;
        }
        server {
            listen 9001;
            proxy_protocal on; # 需要开启转发协议，否则无法获取到真实的ip，只能获取到负责转发的这个openresty网关的ip
            location / {
                proxy_pass http://ups;
            }
        }
    }

    stream { # tcp 转发
        upstream tcp_ups{
            server 127.0.0.1:8888;
        }
        server {
            listen 9002;
            proxy_pass tcp_ups;
            proxy_protocal on;
        }
        server {
            listen 9003;
            content_by_lua_file ./app/proxy.lua; # 这里是上面9002过程的代码原理演示，当9003被tcp连接的时候，我们的lua通过socket主动和8989建立一个连接，并且把真实的5元组传递给8989
        }
    }

    # 共享内存实现
    http {
        error_log ./logs/proxy.log info;
        lua_shared_dict shm 1m;
        lua_shared_dict urls 1m;
        init_worker_by_lua_block{
            -- 从redis当中读取后端服务的地址
            if ngx.worker.id() ~= 0 then
                return 
            end

            local redis = require "resty.redis"
            local urls_from_shm = ngx.shared.urls

            local function update_urls()
                local red = redis:new()
                local ok, err = red:connect("127.0.0.1", 6379)
                if not ok then
                    return
                end
                local res, err = red:auth("123456")
                if not res then
                    ngx.log(ngx.ERR, err)
                    return ngx.exit(301)
                end
                local urls, err = red:smembers("urls")
                urls_from_shm:flush_all()
                for _, v in pairs(urls) do
                    urls_from_shm:set(v, true)
                end
                ngx.timer.at(3, update_urls) -- 每5s把redis中的内容刷到共享内存中
            end

            ngx.timer.at(1, update_urls)
        }
        upstream openresty_ups {
            server 0.0.0.1; # 地址无效，用作占位符
            balancer_by_lua_block {
                -- 负载均衡逻辑 + 读取共享内存中的地址
                local balancer = require "ngx.balance"
                local shm = ngx.shared.shm
                local id = shm.incr("rr", 1, 0)
                local urls_shm = ngx.shared.urls()
                local urls = urls_shm:get_keys()
                if #urls == 0 then
                    return ngx.exit(500)
                end
                local url = urls[(id % #urls) + 1]
                local host, port = url:match("(.*):(.*)")
                local ok, err = balancer.set_current_peer(host, tonumber(port))
                if not ok then
                    return ngx.exit(500)
                end
            }
        }
        server {
            listen 9004;
            location / {
                proxy_pass http://openresty_ups;
            }
        }
    }
  • proxy.lua
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    local sock, err = ngx.req.socket()
    if err then
        return 
    end

    local upsock = ngx.socket.tcp()
    local ok, err

    ok, err = upsock:connect("127.0.0.1", 8888)
    if not ok then
        return
    end

    upsock:send(ngx.var.remote_addr.."\n")
    local function handler_upstream()
        local data
        for i=1, 1000 do
            local reader = upsock:receiveuntil("\n",{inclusive = true})
            data, err, _ = reader()
            if err then
                sock:close()
                upsock:close()
                return
            end
            sock:send(data)
        end
        return handler_upstream
    end
    ngx.thread.spawn(handler_upstream)

    local data

Kong体系结构

  • 本质上是一个开箱即用的工具，即可以在不了解nginx配置和lua语言的基础上去实现功能
    91.png
  • kong核心四对象
    1. upstream：上游服务器的抽象
    2. target：物理服务，ip+port的抽象
    3. service：协议+具体的物理服务，也就是proxy_pass的抽象
    4. route：路由的抽象，也就是location
  • 四对象的对应关系
    92.png
  • kong、konga、后端微服务、postgreSQL的关系
    93.png
    1. kong是api网关
    2. client请求kong
    3. kong转发具体内容给后端微服务
    4. kong的数据存储在postgreSQL（一个关系型数据库），诸如后端服务器的地址等，当然在与运行的过程中，会有数据存储在共享内存中
    5. kong开启了一个8001端口，给konga，konga是一个web平台，用来监控和管理kong，也可以通过konga操作postgreSQL
2024-11-15 该篇文章被 Cleofwine 归为分类: 服务端

上一篇：【go语言】Golang Mod依赖管理 下一篇：后端技术_高性能web网关Openresty
© 2023-2026 Cleofwine / Email / GitHub / 浙ICP备2024136127号
🌙赠我弯弯一枚月，也赠予我晚星⭐ 本站由Hexo驱动｜使用Hexo-theme-A4主题