You are browsing documentation for an outdated version of Kong. Go here
to browse the documentation for the latest version.
Table of Contents
This chapter assumes that you are familiar with
Consider your plugin as a set of Lua
modules. Each file described in
this chapter is to be considered as a separate module. Kong will detect and
load your plugin’s modules if their names follow this convention:
Your modules of course need to be accessible through your
variable, which can be tweaked to your needs by the
directive in your Nginx configuration. However, the preferred way of
installing plugins is through Luarocks. More on that
later in this guide.
To make Kong aware that it has to look for your plugin’s modules, you’ll have
to add it to the
custom_plugins property in your configuration file, which
is a comma-separated list. For example:
custom_plugins = my-custom-plugin # your plugin name here
Now, Kong will try to load the modules described in this chapter. Some of them
are mandatory, but the ones that are not will be ignored and Kong will consider
you do not make use of it. For example, Kong will load
"kong.plugins.my-custom-plugin.handler" to retrieve and execute your plugin’s
Now let’s describe what are the modules you can implement and what their
Basic plugin modules
In its purest form, a plugin consists of two mandatory modules:
which each function will be run at the desired moment in the lifecycle of a
by the user. This module holds the schema of that configuration and defines
rules on it, so that the user can only enter valid configuration values.
Advanced plugin modules
Some plugins might have to integrate deeper with Kong: have their own table in
the database, expose endpoints in the Admin API, etc… Each of those can be
done by adding a new module to your plugin. Here is what the structure of a
plugin would look like if it was implementing all of the optional modules:
│ ├── cassandra.lua
│ └── postgres.lua
Here is the complete list of possible modules to implement and a brief
description of what their purpose is. This guide will go in details to let you
master each one of them.
||Defines a list of endpoints to be available in the Admin API to interact with entities custom entities handled by your plugin.
||Defines a list of DAOs (Database Access Objects) that are abstractions of custom entities needed by your plugin and stored in the datastore.
||An interface to implement. Each function is to be run by Kong at the desired moment in the lifecycle of a request.
||The corresponding migrations for a given datastore. Migrations are only necessary when your plugin has to store custom entities in the database and interact with them through one of the DAOs defined by daos.lua.
||Holds the schema of your plugin’s configuration, so that the user can only enter valid configuration values.
Next: Write custom logic ›