sonic

README

Sonic API Gateway

Sonic is an API Gateway that aggregates and manipulates multiple data sources coming from your microservices to provide the exact API your end-user products need while offering awesome performance.

Installation

Sonic is a single binary file that does not require any external libraries to work. To install Sonic choose your operative system in the downloads section or use the Docker image.

Generate your sonic.json here or use the sample file (updating...)

Docker

If you are already familiar with Docker, the easiest way to get started is by pulling and running the Sonic image from the Docker Hub.

Share your configuration as a volume (mapped to /etc/sonic). Inside the volume you need at least the sonic.json file which contains the endpoint definition of you application.

Pull the image and run Sonic (default parameters):

docker pull starvn/sonic:tagname
docker run -p 8080:8080 -v $PWD:/etc/sonic/ starvn/sonic:tagname

Run with the debug enabled (flag -d):

docker run -p 8080:8080 -v "${PWD}:/etc/sonic/" starvn/sonic:tagname run -d -c /etc/sonic/sonic.json

When the container is running with the previous line you can access the health endpoint:

curl HTTP://localhost:8080/__health

Check the syntax of the configuration file:

docker run -it -p 8080:8080 -v $PWD:/etc/sonic/ starvn/sonic:tagname check --config sonic.json

Show the help:

docker run -it -p 8080:8080 -v $PWD:/etc/sonic/ starvn/sonic:tagname --help

Development setup

You need Golang >= 1.17

Note: if you are using windows, we recommend you to build the project on linux

Fork the sonic project

Go to the sonic project and click on the "fork" button. You can then clone your own fork of the project, and start working on it.

Please read the Github forking documentation for more information.

Build

make build

Build with docker

make build_on_docker

Documentation

Index

• func LoadPlugins(folder, pattern string, logger log.Logger)
• func NewBackendFactory(logger log.Logger, metricCollector *metrics.Metrics) proxy.BackendFactory
• func NewBackendFactoryWithContext(ctx context.Context, logger log.Logger, metricCollector *metrics.Metrics) proxy.BackendFactory
• func NewEngine(cfg config.ServiceConfig, logger log.Logger, w io.Writer) *gin.Engine
• func NewExecutor(ctx context.Context) cmd.Executor
• func NewHandlerFactory(logger log.Logger, metricCollector *metrics.Metrics, ...) router.HandlerFactory
• func NewProxyFactory(logger log.Logger, backendFactory proxy.BackendFactory, ...) proxy.Factory
• func RegisterEncoders()
• func RegisterSubscriberFactories(ctx context.Context, cfg config.ServiceConfig, logger log.Logger) func(n string, p int)
• type BackendFactory
• type BloomFilterJWT
  • func (t BloomFilterJWT) NewTokenRejecter(ctx context.Context, cfg config.ServiceConfig, l log.Logger, ...) (jose.ChainedRejecterFactory, error)
• type DefaultRunServerFactory
  • func (d *DefaultRunServerFactory) NewRunServer(l log.Logger, next router.RunServerFunc) RunServer
• type EngineFactory
• type ExecutorBuilder
  • func (e *ExecutorBuilder) NewCmdExecutor(ctx context.Context) cmd.Executor
• type HandlerFactory
• type LoggerBuilder
  • func (LoggerBuilder) NewLogger(cfg config.ServiceConfig) (log.Logger, io.Writer, error)
• type LoggerFactory
• type MetricsAndTraces
  • func (MetricsAndTraces) Register(ctx context.Context, cfg config.ServiceConfig, l log.Logger) *metrics.Metrics
• type MetricsAndTracesRegister
• type PluginLoader
• type ProxyFactory
• type RunServer
• type RunServerFactory
• type SubscriberFactoriesRegister
• type TokenRejecterFactory

Functions

func LoadPlugins

func LoadPlugins(folder, pattern string, logger log.Logger)

func NewBackendFactory

func NewBackendFactory(logger log.Logger, metricCollector *metrics.Metrics) proxy.BackendFactory

func NewBackendFactoryWithContext

func NewBackendFactoryWithContext(ctx context.Context, logger log.Logger, metricCollector *metrics.Metrics) proxy.BackendFactory

func NewEngine

func NewEngine(cfg config.ServiceConfig, logger log.Logger, w io.Writer) *gin.Engine

func NewExecutor

func NewExecutor(ctx context.Context) cmd.Executor

func NewHandlerFactory

func NewHandlerFactory(logger log.Logger, metricCollector *metrics.Metrics, rejecter jose.RejecterFactory) router.HandlerFactory

func NewProxyFactory

func NewProxyFactory(logger log.Logger, backendFactory proxy.BackendFactory, metricCollector *metrics.Metrics) proxy.Factory

func RegisterEncoders

func RegisterEncoders()

func RegisterSubscriberFactories

func RegisterSubscriberFactories(ctx context.Context, cfg config.ServiceConfig, logger log.Logger) func(n string, p int)

Types

type BackendFactory

type BackendFactory interface {
	NewBackendFactory(context.Context, log.Logger, *metrics.Metrics) proxy.BackendFactory
}

type BloomFilterJWT

type BloomFilterJWT struct{}

func (BloomFilterJWT) NewTokenRejecter

func (t BloomFilterJWT) NewTokenRejecter(ctx context.Context, cfg config.ServiceConfig, l log.Logger, reg func(n string, p int)) (jose.ChainedRejecterFactory, error)

type DefaultRunServerFactory

type DefaultRunServerFactory struct{}

func (*DefaultRunServerFactory) NewRunServer

func (d *DefaultRunServerFactory) NewRunServer(l log.Logger, next router.RunServerFunc) RunServer

type EngineFactory

type EngineFactory interface {
	NewEngine(config.ServiceConfig, log.Logger, io.Writer) *gin.Engine
}

type ExecutorBuilder

type ExecutorBuilder struct {
	LoggerFactory               LoggerFactory
	PluginLoader                PluginLoader
	SubscriberFactoriesRegister SubscriberFactoriesRegister
	TokenRejecterFactory        TokenRejecterFactory
	MetricsAndTracesRegister    MetricsAndTracesRegister
	EngineFactory               EngineFactory
	ProxyFactory                ProxyFactory
	BackendFactory              BackendFactory
	HandlerFactory              HandlerFactory
	RunServerFactory            RunServerFactory

	Middlewares []gin.HandlerFunc
}

func (*ExecutorBuilder) NewCmdExecutor

func (e *ExecutorBuilder) NewCmdExecutor(ctx context.Context) cmd.Executor

type HandlerFactory

type HandlerFactory interface {
	NewHandlerFactory(log.Logger, *metrics.Metrics, jose.RejecterFactory) router.HandlerFactory
}

type LoggerBuilder

type LoggerBuilder struct{}

func (LoggerBuilder) NewLogger

func (LoggerBuilder) NewLogger(cfg config.ServiceConfig) (log.Logger, io.Writer, error)

type LoggerFactory

type LoggerFactory interface {
	NewLogger(config.ServiceConfig) (log.Logger, io.Writer, error)
}

type MetricsAndTraces

type MetricsAndTraces struct{}

func (MetricsAndTraces) Register

func (MetricsAndTraces) Register(ctx context.Context, cfg config.ServiceConfig, l log.Logger) *metrics.Metrics

type MetricsAndTracesRegister

type MetricsAndTracesRegister interface {
	Register(context.Context, config.ServiceConfig, log.Logger) *metrics.Metrics
}

type PluginLoader

type PluginLoader interface {
	Load(folder, pattern string, logger log.Logger)
}

type ProxyFactory

type ProxyFactory interface {
	NewProxyFactory(log.Logger, proxy.BackendFactory, *metrics.Metrics) proxy.Factory
}

type RunServer

type RunServer func(context.Context, config.ServiceConfig, http.Handler) error

type RunServerFactory

type RunServerFactory interface {
	NewRunServer(log.Logger, router.RunServerFunc) RunServer
}

type SubscriberFactoriesRegister

type SubscriberFactoriesRegister interface {
	Register(context.Context, config.ServiceConfig, log.Logger) func(string, int)
}

type TokenRejecterFactory

type TokenRejecterFactory interface {
	NewTokenRejecter(context.Context, config.ServiceConfig, log.Logger, func(string, int)) (jose.ChainedRejecterFactory, error)
}