simple-plugin
├── handler.lua
└── schema.lua

complete-plugin
├── api.lua
├── daos.lua
├── handler.lua
├── migrations
│ ├── cassandra.lua
│ └── postgres.lua
└── schema.lua

-- 通过扩展Base Plugin handler来实现是可选的，在Lua中根本没有接口的概念。
-- Base Plugin handler的方法可以在子类中被调用。它将会向error.log中打印日志。
local BasePlugin = require "kong.plugins.base_plugin"
local CustomHandler = BasePlugin:extend()

-- Your plugin handler's constructor. If you are extending the
-- 你的插件handler的构造方法。如果你通过Base Plugin handler进行扩展，实例化一个名称为插件名称的table。
function CustomHandler:new()
CustomHandler.super.new(self, "my-custom-plugin")
end

function CustomHandler:init_worker()
-- Eventually, execute the parent implementation
-- (will log that your plugin is entering this context)
CustomHandler.super.init_worker(self)

-- Implement any custom logic here
end

function CustomHandler:certificate(config)
CustomHandler.super.certificate(self)

-- Implement any custom logic here
end

function CustomHandler:rewrite(config)
CustomHandler.super.rewrite(self)

-- Implement any custom logic here
end

function CustomHandler:access(config)
CustomHandler.super.access(self)

-- Implement any custom logic here
end

function CustomHandler:header_filter(config)
CustomHandler.super.header_filter(self)

-- Implement any custom logic here
end

function CustomHandler:body_filter(config)
CustomHandler.super.body_filter(self)

-- Implement any custom logic here
end

function CustomHandler:log(config)
CustomHandler.super.log(self)

-- Implement any custom logic here
end

-- 最后一定要返回这个table，供Kong来调用里面的函数
return CustomHandler

local BasePlugin = require "kong.plugins.base_plugin"

-- The actual logic is implemented in those modules
local access = require "kong.plugins.my-custom-plugin.access"
local body_filter = require "kong.plugins.my-custom-plugin.body_filter"

local CustomHandler = BasePlugin:extend()

function CustomHandler:new()
CustomHandler.super.new(self, "my-custom-plugin")
end

function CustomHandler:access(config)
CustomHandler.super.access(self)
access.execute(config)
end

function CustomHandler:body_filter(config)
CustomHandler.super.body_filter(self)
body_filter.execute(config)
end

return CustomHandler

curl -X POST http://kong:8001/services/<service-name-or-id>/plugins/ \
-d "name=my-custom-plugin" \
-d "config.foo=bar"

fields = {
some_string = {type = "string", required = true},
some_boolean = {type = "boolean", default = false},
some_array = {type = "array", enum = {"GET", "POST", "PUT", "DELETE"}}
}

return {
no_consumer = true,
fields = {
key_names = {type = "array", required = true, default = {"apikey"}},
hide_credentials = {type = "boolean", default = false}
}
}

local typedefs = require "kong.db.schema.typedefs"

return {
keyauth_credentials = {
primary_key = { "id" },
name = "keyauth_credentials",
endpoint_key = "key",
cache_key = { "key" },
fields = {
{ id = typedefs.uuid },
{ created_at = typedefs.auto_timestamp_s },
{ consumer = { type = "foreign", reference = "consumers", default = ngx.null, on_delete = "cascade", }, },
{ key = { type = "string", required = false, unique = true, auto = true }, },
},
},
}

local key_credential, err = kong.dao.key_credentials:insert({
consumer_id = consumer.id,
key = "abcd"
})

-- cassandra.lua
return {
{
name = "2015-07-31-172400_init_keyauth",
up = [[
CREATE TABLE IF NOT EXISTS keyauth_credentials(
id uuid,
consumer_id uuid,
key text,
created_at timestamp,
PRIMARY KEY (id)
);

CREATE INDEX IF NOT EXISTS ON keyauth_credentials(key);
CREATE INDEX IF NOT EXISTS keyauth_consumer_id ON keyauth_credentials(consumer_id);
]],
down = [[
DROP TABLE keyauth_credentials;
]]
}
}

--postgres.lua
return {
{
name = "2015-07-31-172400_init_keyauth",
up = [[
CREATE TABLE IF NOT EXISTS keyauth_credentials(
id uuid,
consumer_id uuid REFERENCES consumers (id) ON DELETE CASCADE,
key text UNIQUE,
created_at timestamp without time zone default (CURRENT_TIMESTAMP(0) at time zone 'utc'),
PRIMARY KEY (id)
);

DO $$
BEGIN
IF (SELECT to_regclass('public.keyauth_key_idx')) IS NULL THEN
CREATE INDEX keyauth_key_idx ON keyauth_credentials(key);
END IF;
IF (SELECT to_regclass('public.keyauth_consumer_idx')) IS NULL THEN
CREATE INDEX keyauth_consumer_idx ON keyauth_credentials(consumer_id);
END IF;
END$$;
]],
down = [[
DROP TABLE keyauth_credentials;
]]
}
}

-- access.lua

local function load_entity_key(api_key)
-- IMPORTANT: the callback is executed inside a lock, hence we cannot terminate
-- a request here, we MUST always return.
local apikeys, err = kong.dao.apikeys:find_all({key = api_key}) -- Lookup in the datastore
if err then
error(err) -- caught by kong.cache and logged
end

if not apikeys then
return nil -- nothing was found (cached for `neg_ttl`)
end

-- assuming the key was unique, we always only have 1 value...
return apikeys[1] -- cache the credential (cached for `ttl`)
end

-- retrieve the apikey from the request querystring
local querystring = kong.request.get_query()
local apikey = querystring.apikey

-- We are using cache.get to first check if the apikey has been already
-- stored into the in-memory cache at the key: "apikeys." .. apikey
-- If it's not, then we lookup the datastore and return the credential
-- object. Internally cache.get will save the value in-memory, and then
-- return the credential.
local credential, err = kong.cache:get("apikeys." .. apikey, nil,
load_entity_key, apikey)
if err then
return kong.response.exit(500, "Unexpected error: " .. err)
end

if not credential then
-- no credentials in cache nor datastore
return kong.response.exit(403, "Invalid authentication credentials")
end

-- set an upstream header if the credential exists and is valid
kong.service.request.set_header("X-API-Key", credential.apikey)

cache_key = kong.dao:cache_key(arg1, arg2, arg3, ...)
local apikey = kong.request.get_query().apikey
local cache_key = kong.dao.keyauth_credentials:cache_key(apikey)
-- 缓存中key的值是通过kong.dao:cache_key计算而来的
local credential, err = kong.cache:get(cache_key, nil, load_entity_key, apikey)
if err then
return kong.response.exit(500, "Unexpected error: " .. err)
end

--------handler.lua
local plugin_name = ({...})[1]:match("^kong%.plugins%.([^%.]+)")
local plugin = require("kong.plugins.base_plugin"):extend()

function plugin:new()
    plugin.super.new(self, plugin_name)
end

function plugin:access(plugin_conf)
    plugin.super.access(self)
    schema=kong.request.get_scheme()
    test=kong.request.get_header("test")
    if ( schema == "http" )
    then
        path_with_query = kong.request.get_path_with_query()
        host = kong.request.get_host()
        https_url = "https://" .. host .. path_with_query
        kong.response.exit(301,"Redirect to https",{["Location"] = https_url });
    end
end

function plugin:header_filter(plugin_conf)
    plugin.super.header_filter(self)
end 

function plugin:body_filter(plugin_conf)
    plugin.super.body_filter(self)
end

function plugin:log(plugin_conf)
    plugin.super.log(self)
end 

plugin.PRIORITY = 1000
return plugin

server {
    server_name kong_prometheus_exporter;
l    isten 0.0.0.0:9542; # can be any other port as well

location / {
    default_type text/plain;
    content_by_lua_block {
    local prometheus = require "kong.plugins.prometheus.exporter"
    prometheus:collect()
                                      }
               }

location /nginx_status {
      internal;
     access_log off;
     stub_status;
                       }
  }