1、 broker-service->auth-service->postgresdb；
2、 zipkin监控：需代码入侵；
一、broker-service
1、 通过context传递span；
main.go
package main
import (
"broker-service/auth-service"
"broker-service/svc1"
"context"
"fmt"
"log"
"net/http"
"time"
"github.com/opentracing/opentracing-go"
zipkinot "github.com/openzipkin-contrib/zipkin-go-opentracing"
"github.com/openzipkin/zipkin-go"
zipkinhttp "github.com/openzipkin/zipkin-go/reporter/http"
)
var webPort = "8080"
const (
// Our service name.
serviceName = "client"
// Host + port of our service.
hostPort = "0.0.0.0:0"
// Endpoint to send Zipkin spans to.
zipkinHTTPEndpoint = "http://localhost:9411/api/v2/spans"
// Base endpoint of our Auth service.
authEndpoint = "http://localhost:8090"
)
type Config struct {
Client Services
Ctx context.Context
}
type Services struct {
Auth auth.Service
}
func main() {
fmt.Println("Starting broker service: ", webPort)
// set up a span reporter
reporter := zipkinhttp.NewReporter(zipkinHTTPEndpoint)
defer reporter.Close()
// create our local service endpoint
endpoint, err := zipkin.NewEndpoint(serviceName, hostPort)
if err != nil {
log.Fatalf("unable to create local endpoint: %+v\n", err)
}
// initialize our tracer
nativeTracer, err := zipkin.NewTracer(reporter, zipkin.WithLocalEndpoint(endpoint))
if err != nil {
log.Fatalf("unable to create tracer: %+v\n", err)
}
// use zipkin-go-opentracing to wrap our tracer
tracer := zipkinot.Wrap(nativeTracer)
// optionally set as Global OpenTracing tracer instance
opentracing.SetGlobalTracer(tracer)
// Create Client to auth Services
as := auth.NewHTTPClient(tracer, authEndpoint)
// Create Root Span for duration of the interaction with svc1
span := opentracing.StartSpan("Run")
// Put root span in context so it will be used in our calls to the client.
ctx := opentracing.ContextWithSpan(context.Background(), span)
//setup config
app := Config{
Client: Services{
Auth: as,
},
Ctx: ctx,
}
span.Finish()
srv := &http.Server{
Addr: ":8080",
Handler: app.routes(),
}
err = srv.ListenAndServe()
if err != nil {
log.Panic(err)
}
}
1、 路由到auth服务；
router.go
package main
import (
"net/http"
"github.com/go-chi/chi/v5"
"github.com/go-chi/chi/v5/middleware"
"github.com/go-chi/cors"
)
func (app *Config) routes() http.Handler {
mux := chi.NewRouter()
mux.Use(cors.Handler(cors.Options{
AllowedOrigins: []string{
"https://*", "http://*"},
AllowedMethods: []string{
"GET", "POST", "PUT", "DELETE", "OPTIONS"},
AllowedHeaders: []string{
"Accept", "Authorization", "Content-Type", "X-CSRF-Token"},
ExposedHeaders: []string{
"link"},
AllowCredentials: true,
MaxAge: 300,
}))
mux.Use(middleware.Heartbeat("/ping"))
mux.Post("/", app.Broker)
mux.Post("/authenticate", app.Authenticate)
mux.Post("/auth", app.Auth)
return mux
}
二、handler.go
package main
import (
"broker-service/auth-service"
"broker-service/event"
"broker-service/logs"
"context"
"encoding/json"
"errors"
"log"
"net/http"
"net/rpc"
"strconv"
"time"
"github.com/opentracing/opentracing-go"
otlog "github.com/opentracing/opentracing-go/log"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials/insecure"
)
type RequestPayload struct {
Action string json:"action"
Auth AuthPayload json:"auth,omitempty"
Log loggerPayload json:"log,omitempty"
}
type AuthPayload struct {
Email string json:"email"
Password string json:"password"
}
type loggerPayload struct {
Name string json:"name"
Data string json:"data"
}
// zipkin 未监控
func (app *Config) authenticate(w http.ResponseWriter, r *http.Request, a AuthPayload) {
var jsonFromService jsonResponse
// create json and send to the auth microservice
log.Println("auth: ", a)
jsonData, _ := json.Marshal(a)
//call the service
msg := &HttpMessage{
Url: "http://authentication-service",
Api: "authenticate",
Data: jsonData,
Method: "POST"}
jsonFromService, status := msg.HttpClient()
//make sure get back the correct status code
if status == http.StatusUnauthorized {
app.errorJSON(w, errors.New("invalid credentials"))
return
} else if status != http.StatusOK {
log.Println("Data: ", jsonFromService, " | status:", status)
app.errorJSON(w, errors.New("calling from service failed"))
return
}
var payload jsonResponse
payload.Error = false
payload.Message = "Authenticated!"
payload.Data = jsonFromService.Data
app.writeJSON(w, http.StatusAccepted, payload)
}
// zipkin 监控
func (app *Config) Auth(w http.ResponseWriter, r *http.Request) {
span, ctx := opentracing.StartSpanFromContext(app.Ctx, "Auth")
defer span.Finish()
var payload jsonResponse
payload.Error = true
payload.Message = "Authentication failed!"
var requestPayload AuthPayload
log.Println("request Auth")
err := app.readJSON(w, r, &requestPayload)
if err != nil {
app.errorJSON(w, err)
return
}
log.Println(requestPayload)
span.LogFields(otlog.String("event", "Call Auth"))
response, err := app.Client.Auth.Auth(
ctx, auth.AuthPayload(requestPayload))
//check
if err != nil {
app.errorJSON(w, errors.New("calling from svc1 failed"))
log.Printf("Response err: %s\n", err.Error())
return
}
log.Printf("Auth Rresponse: %v Err: %+v\n", response, err)
payload.Error = false
payload.Message = response.Message
payload.Data = response.Data
app.writeJSON(w, http.StatusAccepted, payload)
}