authorization-client/main.go

package main

import (
	mgrpc "github.com/go-micro/plugins/v4/client/grpc"
	"github.com/go-micro/plugins/v4/registry/consul"
	mhttp "github.com/go-micro/plugins/v4/server/http"
	"github.com/redis/go-redis/v9"
	"github.com/sirupsen/logrus"
	"go-micro.dev/v4"
	"go-micro.dev/v4/logger"
	"go-micro.dev/v4/registry"
	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/propagation"
	"golang.org/x/net/context"
	"os"
	"sghgogs.com/micro/auth-client/config"
	"sghgogs.com/micro/auth-client/router"
	"sghgogs.com/micro/auth-client/utils/authutil"
	"sghgogs.com/micro/auth-client/utils/tracing"
	"time"
)

const (
	name    = "authorizationclient"
	version = "1.0.0"
)

// @title           Swagger Example API
// @version         1.0
// @description     This is a sample server celler server.
// @termsOfService  http://swagger.io/terms/

// @contact.name   API Support
// @contact.url    http://www.swagger.io/support
// @contact.email  support@swagger.io

// @license.name  Apache 2.0
// @license.url   http://www.apache.org/licenses/LICENSE-2.0.html

// @host      localhost:8080
// @BasePath  /v1/api

// @securityDefinitions.basic  BasicAuth

// @externalDocs.description  OpenAPI
// @externalDocs.url          https://swagger.io/resources/open-api/

func main() {
	if err := config.Load(); err != nil {
		logger.Fatal(err)
	}
	if cfg := config.RedisAddress(); cfg.Enable {
		authutil.NewJWTAuth(redis.NewClient(&redis.Options{
			Addr:     cfg.URL,      // Redis 服务器地址
			Password: cfg.Password, // Redis 密码，如果有的话
			DB:       0,            // 默认数据库
		}), name, cfg.Enable)
	}
	srv := micro.NewService(
		micro.Server(mhttp.NewServer()),
		micro.Client(mgrpc.NewClient()),
	)
	authService := authutil.JWTAuthService.Auth
	opts := []micro.Option{
		micro.Name(name),
		micro.Version(version),
		micro.Address(config.Address()),
		micro.Auth(
			authService,
		),
	}
	if cfg := config.Tracing(); cfg.Enable {
		tp, err := tracing.NewTracerProvider(name, version, srv.Server().Options().Id, cfg.Jaeger.URL)
		if err != nil {
			logger.Fatal(err)
		}
		defer func() {
			ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
			defer cancel()
			if err := tp.Shutdown(ctx); err != nil {
				logger.Fatal(err)
			}
		}()
		otel.SetTracerProvider(tp)
		otel.SetTextMapPropagator(propagation.NewCompositeTextMapPropagator(propagation.TraceContext{}, propagation.Baggage{}))
	}
	if cfg := config.Registry(); cfg.Enable {
		logrus.Info("注册中心")
		consul := consul.NewRegistry(func(options *registry.Options) {
			options.Addrs = []string{
				cfg.Consul.URL,
			}
		})
		opts = append(opts, micro.Registry(consul))
	}
	srv.Init(opts...)

	log := logrus.New()
	log.Level = logrus.DebugLevel
	log.Formatter = &logrus.JSONFormatter{
		FieldMap: logrus.FieldMap{
			logrus.FieldKeyTime:  "timestamp",
			logrus.FieldKeyLevel: "severity",
			logrus.FieldKeyMsg:   "message",
		},
		TimestampFormat: time.RFC3339Nano,
	}
	log.Out = os.Stdout

	cfg, client := config.Get(), srv.Client()

	if err := micro.RegisterHandler(srv.Server(), router.NewRouter(
		cfg.AuthorizationService,
		client,
	)); err != nil {
		logger.Fatal(err)
	}

	logrus.Info("Run server")
	if err := srv.Run(); err != nil {
		logger.Fatal("run", err)
	}
}