kong笔记——自定义插件开发

kong笔记 目录导航
本文通过一个自定义插件的编写,来了解Kong的插件机制
插件功能:

  • 原本返回百度首页,在添加插件之后,返回插件自定义的内容;

前提

  1. 使用kong代理百度的接口,配置route路径;
  2. 了解kong 插件的目录结构及部署(上一篇说到的)

实战

上一篇我们学到,一个插件必须包含两个文件:

  • handler.lua
  • schema.lua

handler.lua主要负责业务逻辑功能编写,schema.lua主要负责插件参数定制,类似将handler.lua中写死的变量抽出来写到schema.lua中,变为动态注入。

既然是自定义插件,又想应用到kong中,这期间肯定会有一些规范做适配,kong也不例外,在kong中,我们可以通过继承一个base插件:
kong.plugins.base_plugin

这个base插件提供了一些方法待实现,这些方法是基于 openresty的http模块来定义的

函数名 LUA-NGINX-MODULE Context 描述
:init_worker() init_worker_by_lua 在每个 Nginx 工作进程启动时执行
:certificate() ssl_certificate_by_lua 在SSL握手阶段的SSL证书服务阶段执行
:rewrite() rewrite_by_lua 从客户端接收作为重写阶段处理程序的每个请求执行。在这个阶段,无论是API还是消费者都没有被识别,因此这个处理器只在插件被配置为全局插件时执行
:access() access_by_lua 为客户的每一个请求而执行,并在它被代理到上游服务之前执行(路由)
:header_filter() header_filter_by_lua 从上游服务接收到所有响应头字节时执行
:body_filter() body_filter_by_lua 从上游服务接收的响应体的每个块时执行。由于响应流回客户端,它可以超过缓冲区大小,因此,如果响应较大,该方法可以被多次调用
:log() log_by_lua 当最后一个响应字节已经发送到客户端时执行

在各个阶段分别可以处理响应的业务。

另外,kong自身也提供了一些方法,有上下文的,有request、response等等的工具类,便于我们使用

PDK名称 功能描述
kong.client 提供客户端的ip, 端口等信息
kong.ctx 提供了插件之间共享并传递参数的桥梁
kong.ip 提供了kong.ip.is_trusted(address)IP白名单检测方法
kong.log 日志方法
kong.node 返回此插件的UUID信息
kong.request 提供request信息的读取功能,access()中可读
kong.response 提供response信息的读写功能, access()中不可用
kong.router 返回此请求关联的router信息
kong.service 返回此请求关联的service,可以动态修改后端服务信息
kong.service.request 仅用于access()方法中,可以读写请求信息
kong.service.response 仅可用于header_filter(), body_filter()方法中,只提供header信息的读取功能
kong.table kong提供的一套数据结构功能

更多方法参考:PDK - v2.5.x | Kong Docs (konghq.com)

插件代码

插件名称为:demo

  • handler.lua

    local BasePlugin = require "kong.plugins.base_plugin"
    
    local DemoHandler = BasePlugin:extend()
    
    DemoHandler.VERSION = "0.1.0"
    DemoHandler.PRIORITY = 2000
    
    -- 在 'init_by_lua_block' 中运行
    function DemoHandler:new()
        DemoHandler.super.new(self, "demo")
    end
    
    -- 在 'init_worker_by_lua_block' 中运行
    function DemoHandler:init_worker()
        DemoHandler.super.init_worker(self)
    end
    
    -- 在 'ssl_certificate_by_lua_block' 中运行
    function DemoHandler:certificate(conf)
        DemoHandler.super.certificate(self)
    end
    
    -- 在 'rewrite_by_lua_block' 中运行
    function DemoHandler:rewrite(conf)
        DemoHandler.super.rewrite(self)
    end
    
    -- 在 'access_by_lua_block' 中运行
    function DemoHandler:access(conf)
        DemoHandler.super.access(self)
        return kong.response.exit(200,conf.content)
    end
    
    -- 在 'header_filter_by_lua_block' 中运行
    function DemoHandler:header_filter(conf)
        DemoHandler.super.header_filter(self)
    end
    
    -- 在 'body_filter_by_lua_block' 中运行
    function DemoHandler:body_filter(conf)
        DemoHandler.super.body_filter(self)
    end
    
    -- 在 'log_by_lua_block' 中运行
    function DemoHandler:log(conf)
        DemoHandler.super.log(self)
    end
    
    return DemoHandler
    

    可以看到, 主要内容就是实现一个BasePlugin:extend(),实现一系统生命周期对应的方法后,返回这个实例即可.

    注意看一下 access()方法那块,我添加了一些内容!!!!

    而且, 所有方法在实现的时候, 都要先调用一下父类方法.

  • schema.lua

    return {
        no_consumer = true,
        fields = {
            content = { type = "string", default = "success!!" },
        }
    }
    

部署

  1. 先把代码放置到/opt/share/kong/plugins/demo位置

  2. 修改/etc/kong/kong.conf文件,加载插件

    lua_package_path = /opt/share/?.lua;;
    plugins = bundled,demo
    
  3. 重启Kong服务: kong restart

验证

  1. 打开konga,可以看到插件的部署情况:

    kong笔记——自定义插件开发_第1张图片

    底色是绿色的代表正在使用的插件!

  2. 添加插件

    在这里我需要说明一下,kong插件的作用域范围有4个

    • Consumer作用域

    • route作用域
      仅针对route配置起作用(一个route可以配置多个path,也就是说这个route下的所有path插件都生效,不是这个route的path不生效)

    • service作用域

      针对service配置起作用(一个service有多个route,只要是属于这个service下的route,插件都生效)

    • global作用域

      所有请求,插件都生效

    目前我们演示route作用域,其他感兴趣的自己可以尝试一下:

    • 添加插件

      kong笔记——自定义插件开发_第2张图片

      参数详情:

      kong笔记——自定义插件开发_第3张图片

    • 访问结果

      kong笔记——自定义插件开发_第4张图片

拓展

上述的实战比较简单,相信你也可以顺利完成,接下来我来说几个参坑点吧

  1. lua库扫描以及引入第三方lua库

    • 在我们编写lua脚本的时候,可能需要引入其他的库(kong自身没有提供的库),这个时候当我们在handler.lua中require的时候,则需要在kong.conf配置untrusted_lua_sandbox_requires 属性,例如:

      在handler.lua中

      local template = require "resty.template"
      local split = require "kong.tools.utils".split
      

      那么我们必须在kong.conf中配置

      untrusted_lua_sandbox_requires = resty.template, kong.tools.utils
      
    • 还有一种方案是,直接将自己写好的库跟handler.lua,schema.lua放到一个文件夹里面,然后通过下列方式来引入

      local xxx     = require "kong.plugins.插件名称.自己库的名称"
      

      例如:插件名称叫demo,自己写的库名称是redisUtil.lua,那么引入方式为:

      local redisUtil     = require "kong.plugins.demo.redisUtil"
      

      这种方案有个前提是!

      你的redisutil 库必须有返回,如果是函数,想做到通用,就必须return,并且函数不要用local修饰,例如:我想让get,put,incr这三个函数通用,我的redisutil就必须返回这三个函数

      return {
          get = get;
          put = put;
          incr = incr;
      }
      

      如果全部封装到table里面,在最后返回时,也可以这么写:

      return _M
      
  2. schema文件拓展内容

    在schema文件中,支持的类型共有下面这些类型

     map, number, array, foreign, function, integer, boolean, record, string, set
    

    其中,在type=record的时候,这种就必须定义field,类似java中的JavaBean一样,定义属性,以及属性值

    比如:

    return {
      name = "ip-restriction",
      fields = {
        { protocols = typedefs.protocols_http },
        { config = {
          type = "record",
          fields = {
            { allow = { type = "array", elements = typedefs.ip_or_cidr, }, },
            { deny = { type = "array", elements = typedefs.ip_or_cidr, }, },
          },
        },
        },
      },
    }
    

    这种就相当与是有一个config对象,包含两个属性,这个两个属性都是数组类型,数组内部的元素必须符合ip校验规则,其数据结构对应为:

    {
        "name": "ip-restriction",
        "config": {
            "allow": [
                "127.0.0.1"
            ],
            "deny": [
                "127.0.0.1"
            ]
        }
    }
    

    在type=map的时候

    比如:

    return {
      name = "response-ratelimiting",
      fields = {
        { protocols = typedefs.protocols_http },
        { config = {
            type = "record",
            fields = {
              { limits = {
                  type = "map",
                  required = true,
                  len_min = 1,
                  keys = { type = "string" },
                  values = {
                    type = "record",
                    required = true,
                    fields = {
                      { second = { type = "number", gt = 0 }, },
                      { minute = { type = "number", gt = 0 }, },
                      { hour = { type = "number", gt = 0 }, },
                      { day = { type = "number", gt = 0 }, },
                      { month = { type = "number", gt = 0 }, },
                      { year = { type = "number", gt = 0 }, },
                    },
                  },
                },
              },
            },
          },
        },
      },
    }
    

    这种就相当于是JsonObject结构,其数据结构为:

    {
        "name": "response-ratelimiting",
        "config": {
            "limits": {
                "second":1,
                "minute":1,
                "hour":1,
                "day":1,
                "month":1,
                "year":1
            }
        }
    }
    

    还有一些比较复杂的嵌套对象,比如:

    return {
        name = "demo-ip-restriction",
        fields = {
            { protocols = typedefs.protocols_http },
            { config = {
                type = "record",
                fields = {
                    { rfilter = {
                        type = "array",
                        elements = {
                            type = "record",
                            fields = {
                                { appkey = { type = "string", required = true }, },
                                { deny = { type = "array", elements = typedefs.ip_or_cidr, }, },
                            },
                        },
                    }
                    },
                },
            },
            },
        },
    }
    

    这种对应的数据结构为:

    {
        "name": "demo-ip-restriction",
        "config": {
            "rfilter": [
                {
                    "appkey": "1111",
                    "deny": [
                        "142.0.0.1/24"
                    ]
                },
                {
                    "appkey": "2222",
                    "deny": [
                        "132.0.0.1/32"
                    ]
                }
            ]
        }
    }
    
  3. 部署中常见的问题
    在部署插件中我们可能会遇到这么几个问题“

    • plugin is in use but not enabled;

      这个是因为你之前配置了一个自定义插件,并在某种场合使用了该插件,后来由于某种原因,你下架了该自定义插件,重启kong后,就会报该错误;

      想解决很简单,在数据库plugins中删除使用添加该插件的节点

    • plugin is enabled but not installed;

      这个是因为你在kong.conf中配置了自定义插件(plugins = bundled,demo),没有配置lua源(lua_package_path = /opt/share/?.lua;;)

  4. 多个作用域插件的执行顺序

    在上文我们提到插件可以作用域在consumer,route,service,global

    当多个作用域的插件出现在一个场景时,他们的优先级法则为:一个插件相对于它所配置的实体数量越具体,它的优先级就越高。

    多次配置插件时的完整优先级顺序为:

    1. 在以下组合上配置的插件:route、service和consumer。(consumer表示请求必须经过身份验证)。
    2. 在route和consumer的组合上配置的插件。(consumer表示请求必须经过身份验证)。
    3. 在service和consumer的组合上配置的插件。(consumer表示请求必须经过身份验证)。
    4. 在route和service的组合上配置的插件。
    5. 在consumer上配置的插件。(consumer表示请求必须经过身份验证)。
    6. 在route上配置的插件。
    7. 在service上配置的插件。
    8. 配置为global运行的插件。

    示例:如果插件应用两次(具有不同的配置):对于service(插件配置 A)和对于consumer(插件配置 B),则验证此consumer身份的请求将运行插件配置 B 并忽略 A。但是,不验证此consumer身份的请求将回退到运行插件配置 A。请注意,如果禁用了配置 B(其标志设置为 ),则配置 A 将应用于与配置 B 匹配的请求。rate-limiting``enabled``false

    官网解释:Admin API - v2.7.x | Kong Docs (konghq.com)

  5. 多个插件的执行顺序

    当一个路径涉及到多个插件时,有时候后一个插件需要依赖前一个插件的数据,所以出现了优先级问题,这个时候你可以通过

    CustomHandler.PRIORITY = 10
    

    来设置你的插件优先级

    优先级越高,相对于其他插件的阶段(如:access()、:log()等),插件的阶段执行得越快。 已有捆绑插件的当前执行顺序为:

    插件 优先级
    pre-function +inf
    zipkin 100000
    ip-restriction 3000
    bot-detection 2500
    cors 25000
    jwt 1005
    oauth2 1004
    key-auth 1003
    ldap-auth 1002
    basic-auth 1001
    hmac-auth 1000
    request-size-limiting 951
    acl 950
    rate-limiting 901
    response-ratelimiting 900
    request-transformer 801
    response-transformer 800
    aws-lambda 750
    azure-functions 749
    prometheus 13
    http-log 12
    statsd 11
    datadog 10
    file-log 9
    udp-log 8
    tcp-log 7
    loggly 6
    syslog 4
    galileo 3
    request-termination 2
    correlation-id 1
    post-function -1000

你可能感兴趣的:(kong,lua,kong)