[GO] Authentifizierungsprozess mit gRPC- und Firebase-Authentifizierung

Einführung

Ich werde vorstellen, wie die Authentifizierung auf dem Go-Server mithilfe der gRPC- und Firebase-Authentifizierung verarbeitet wird. Ich werde in einem anderen Artikel über den Autorisierungsprozess schreiben.

Firebase Authentication Sie können das SDK über den folgenden Befehl hinzufügen.

go get firebase.google.com/go

Informationen zum Initialisieren des Firebase Admin SDK for Go finden Sie im Folgenden. Fügen Sie dem Server das Firebase Admin SDK hinzu (https://firebase.google.com/docs/admin/setup?hl=ja#initialize_the_sdk).

In der Vergangenheit schien die Initialisierung mit `` option.WithCredentialsFile () `üblich zu sein, aber es scheint, dass die Initialisierung mit der Umgebungsvariablen GOOGLE_APPLICATION_CREDENTIALS dringend empfohlen wird.

firebase.go

package middleware

import (
	"context"
	firebase "firebase.google.com/go"
	"firebase.google.com/go/auth"
)

type Firebase struct {
	Auth *auth.Client
}

func NewFirebase() (inst *Firebase, err error) {
	inst = new(Firebase)
	// GOOGLE_APPLICATION_Lesen Sie implizit die von CREDENTIALS angegebene Anmeldeinformationsdatei
	app, err := firebase.NewApp(context.Background(), nil)
	if err != nil {
		return
	}
	authInst, err := app.Auth(context.Background())
	if err != nil {
		return
	}

	inst.Auth = authInst
	return
}

Authentifizierungsprozess

Dies ist die Definition des Empfängers mit der Authentifizierungsmethode, die für das Argument in `` `grpc_auth.UnaryServerInterceptor``` verwendet wird, was später erläutert wird. Habe die Feuerbasis im Feld.

package middleware

import (
	"context"
	grpc_auth "github.com/grpc-ecosystem/go-grpc-middleware/auth"
)

type Authentication struct {
	firebase Firebase
}

func NewAuthentication(firebase Firebase) *Authentication {
	authInst := new(Authentication)
	authInst.firebase = firebase
	return authInst
}

func (au *Authentication) Authenticate(ctx context.Context) (newCtx context.Context, err error) {

	idToken, err := grpc_auth.AuthFromMD(ctx, "bearer")

	//JWT-Überprüfung
	token, err := au.firebase.Auth.VerifyIDToken(context.Background(), idToken)
	if err != nil {
		return
	}
	//Gibt JWT-Informationen im Schlüsseltoken im Kontext des Arguments zurück
	newCtx = context.WithValue(ctx, "token", token.Claims)
	return
}

Dieser Artikel war übrigens leicht zu verstehen, daher werde ich ihn als Referenz weitergeben. Wenn Sie die Erklärung zu Interceptor lesen, können Sie den Inhalt der nachfolgenden Verarbeitung reibungslos verstehen. Versuchen Sie, sich mit der Middleware (Inerceptor) von gRPC-Go zu authentifizieren / zu autorisieren

Die zur Authentifizierung verwendete Middleware verwendet grpc_auth, das in Go gRPC Middleware definiert ist.

main.go

package main

import (
	grpc_middleware "github.com/grpc-ecosystem/go-grpc-middleware"
	grpc_auth "github.com/grpc-ecosystem/go-grpc-middleware/auth"
	"google.golang.org/grpc"
	"google.golang.org/grpc/reflection"
	"log"
	pb "my-project/grpc"
	"my-project/middleware"
	"net"
)

func main() {

	listenPort, err := net.Listen("tcp", ":800")
	if err != nil {
		log.Fatalln(err)
	}

	//Erstellen Sie eine Firebase-Instanz
	firebase, err := NewFirebase()
	if err != nil {
		log.Fatalln(err)
	}
	//Authentifizierungsinstanz generieren
	auth = *NewAuthentication(*firebase)

	//Fügen Sie dem Server Authentifizierungseinstellungen hinzu
	server := grpc.NewServer(
		grpc_middleware.WithUnaryServerChain(
			grpc_auth.UnaryServerInterceptor(auth),
		),
		//Erforderlich bei Verwendung von Streaming
		grpc_middleware.WithStreamServerChain(
			grpc_auth.StreamServerInterceptor(auth),
		))

	pb.MyProjectServer(server, &handler)

	reflection.Register(server)

	if err := server.Serve(listenPort); err != nil {
		log.Fatalf("failed to serve: %v", err)
	}
}

Zusammenfassung

Es war eine einfache Möglichkeit, die Authentifizierung auf dem Go-Server mithilfe der gRPC- und Firebase-Authentifizierung zu verarbeiten. Die Autorisierung kann in Interceptor auf ähnliche Weise implementiert werden, daher werde ich sie in einem anderen Artikel zeichnen.