微型包装器即服务

Question

Question is about using go-micro wrapper as a separate service - if anyone knows how to use it properly please let me know. my example - authWrapper, so all api services should be able to use it, it should be discovered via standard service discovery, to make any changes to authWrapper only 1 service should be rebuild (I didn't find a way how to properly pass context.Context from api service to authWrapper via rpc call)

go-micro docs

go-micro wrapper examples

api's code where authWrapper gets called:

func main() {
    service := micro.NewService(
        micro.Name("go.micro.api.account"),
        micro.WrapHandler(AuthWrapper),
    )
    fmt.Println("service created")
    service.Init()
    account.RegisterAccountHandler(service.Server(),
        &handler.Account{
            ProfileServiceClient: profile.NewProfileServiceClient("go.micro.srv.profile", service.Client()),
            AuthServiceClient:    auth.NewAuthServiceClient("go.micro.srv.auth", service.Client()),
        })

    if err := service.Run(); err != nil {
        log.Fatal(err)
    }
}

and authWrapper:

var methodsWithoutAuth = map[string]bool{"Account.Auth": true, "Account.Create": true}

func AuthWrapper(fn server.HandlerFunc) server.HandlerFunc {
    return func(ctx context.Context, req server.Request, resp interface{}) error {
        fmt.Printf("AuthWrapper, req: %+v", req)

        method := req.Method()
        fmt.Printf("checking if method allowed, method: %+v", method)
        if _, ok := methodsWithoutAuth[method]; ok {
            return fn(ctx, req, resp)
        }

        fmt.Printf("validating token")

        authClient := auth.NewAuthServiceClient("go.micro.srv.auth", client.DefaultClient)

        meta, ok := metadata.FromContext(ctx)
        if !ok {
            return errors.New("no auth meta-data found in request")
        }

        token := meta["Token"]
        log.Println("Authenticating with token: ", token)

        newCtx := context.WithValue(ctx, "Method", req.Method())

        _, err := authClient.ValidateToken(newCtx, &auth.Token{Token: token})
        if err != nil {
            return err
        }

        prof, err := authClient.Decode(newCtx, &auth.Token{Token: token})
        if err != nil {
            return err
        }

        newCtxWithProf := context.WithValue(newCtx, "Profile", prof.Profile)

        return fn(newCtxWithProf, req, resp)
    }
}

Answer 1

You can write service wrappers by incorporating the go-micro client in the wrapper code. You find on github many examples how to write a go-micro client, I believe there is one in the greeter example in the go-micro repository.

I use a wrapper to disclose a grpc-interface to a rest-service wrapper by using the client boilerplate.

You can write wrappers to a micro-service for almost any purpose in this way.

Don't worry about the ports the client code needs to address, Consul can handle this just fine for you.