rk-gf

module

v0.0.10 Latest Latest Go to latest Published: Jan 18, 2022 License: Apache-2.0

Details

Valid go.mod file
Redistributable license
Tagged version
Stable version
Learn more about best practices

Repository

github.com/rookie-ninja/rk-gf

Links

Open Source Insights

README ¶

rk-gf

Interceptor & bootstrapper designed for gogf/gf web framework. Documentation.

This belongs to rk-boot family. We suggest use this lib from rk-boot.

Table of Contents generated with DocToc

Architecture
Supported bootstrap
Supported instances
Supported middlewares
Installation
Quick Start
YAML Options
- GoFrame
- CommonService
- Swagger
- Prometheus Client
- TV
- Static file handler
- Middlewares
  - Log
  - Metrics
  - Auth
  - Meta
  - Tracing
  - RateLimit
  - CORS
  - JWT
  - Secure
  - CSRF
- Full YAML
- Development Status: Stable
Build instruction
Test instruction
- Contributing

Architecture

Supported bootstrap

Bootstrap	Description
YAML based	Start gogf/gf microservice from YAML
Code based	Start gogf/gf microservice from code

Supported instances

All instances could be configured via YAML or Code.

User can enable anyone of those as needed! No mandatory binding!

Instance	Description
ghttp.Server	Compatible with original gogf/gf service functionalities
Config	Configure spf13/viper as config instance and reference it from YAML
Logger	Configure uber-go/zap logger configuration and reference it from YAML
EventLogger	Configure logging of RPC with rk-query and reference it from YAML
Credential	Fetch credentials from remote datastore like ETCD.
Cert	Fetch TLS/SSL certificates from remote datastore like ETCD and start microservice.
Prometheus	Start prometheus client at client side and push metrics to pushgateway as needed.
Swagger	Builtin swagger UI handler.
CommonService	List of common APIs.
TV	A Web UI shows microservice and environment information.
StaticFileHandler	A Web UI shows files could be downloaded from server, currently support source of local and pkger.

Supported middlewares

All middlewares could be configured via YAML or Code.

User can enable anyone of those as needed! No mandatory binding!

Middleware	Description
Metrics	Collect RPC metrics and export to prometheus client.
Log	Log every RPC requests as event with rk-query.
Trace	Collect RPC trace and export it to stdout, file or jaeger with open-telemetry/opentelemetry-go.
Panic	Recover from panic for RPC requests and log it.
Meta	Send micsroservice metadata as header to client.
Auth	Support [Basic Auth] and [API Key] authorization types.
RateLimit	Limiting RPC rate globally or per path.
Timeout	Timing out request by configuration.
CORS	Server side CORS validation.
JWT	Server side JWT validation.
Secure	Server side secure validation.
CSRF	Server side csrf validation.

Installation

go get github.com/rookie-ninja/rk-gf

Quick Start

In the bellow example, we will start microservice with bellow functionality and middlewares enabled via YAML.

gogf/gf server
Swagger UI
CommonService
TV
Prometheus Metrics (middleware)
Logging (middleware)
Meta (middleware)

Please refer example at example/boot/simple.

1.Create boot.yaml

boot.yaml

---
gf:
  - name: greeter                     # Required
    port: 8080                        # Required
    enabled: true                     # Required
    tv:
      enabled: true                   # Optional, default: false
    prom:
      enabled: true                   # Optional, default: false
    sw:
      enabled: true                   # Optional, default: false
    commonService:
      enabled: true                   # Optional, default: false
    interceptors:
      loggingZap:
        enabled: true                 # Optional, default: false
      metricsProm:
        enabled: true                 # Optional, default: false
      meta:
        enabled: true                 # Optional, default: false

2.Create main.go

main.go

// Copyright (c) 2021 rookie-ninja
//
// Use of this source code is governed by an Apache-style
// license that can be found in the LICENSE file.
package main

import (
	"context"
	"github.com/gogf/gf/v2/net/ghttp"
	"github.com/rookie-ninja/rk-entry/entry"
	"github.com/rookie-ninja/rk-gf/boot"
	"net/http"
)

func main() {
	// Bootstrap basic entries from boot config.
	rkentry.RegisterInternalEntriesFromConfig("example/boot/simple/boot.yaml")

	// Bootstrap gf entry from boot config
	res := rkgf.RegisterGfEntriesWithConfig("example/boot/simple/boot.yaml")

	// Get rkgf.GfEntry
	gfEntry := res["greeter"].(*rkgf.GfEntry)
	gfEntry.Server.BindHandler("/v1/greeter", func(ctx *ghttp.Request) {
		ctx.Response.WriteHeader(http.StatusOK)
		ctx.Response.WriteJson(map[string]string{
			"message": "Hello!",
		})
	})
	
	// Bootstrap gf entry
	gfEntry.Bootstrap(context.Background())

	// Wait for shutdown signal
	rkentry.GlobalAppCtx.WaitForShutdownSig()

	// Interrupt gf entry
	gfEntry.Interrupt(context.Background())
}

3.Start server

$ go run main.go

4.Validation