Processus d'authentification avec gRPC et authentification Firebase

introduction

Je vais vous présenter comment traiter l'authentification sur le serveur Go à l'aide de gRPC et de l'authentification Firebase. J'écrirai sur le processus d'autorisation dans un autre article.

Firebase Authentication Vous pouvez ajouter le SDK à partir de la commande suivante.

go get firebase.google.com/go

Reportez-vous à ce qui suit pour initialiser le SDK Firebase Admin pour Go. Ajouter le SDK d'administration Firebase au serveur (https://firebase.google.com/docs/admin/setup?hl=ja#initialize_the_sdk)

Dans le passé, il semble que l'initialisation à l'aide de l'option ```option.WithCredentialsFile () `` `était courante, mais il semble que l'initialisation à l'aide de la variable d'environnement GOOGLE_APPLICATION_CREDENTIALS soit fortement recommandée.

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_Lire implicitement le fichier d'informations d'identification spécifié par CREDENTIALS
	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
}

Processus d'authentification

C'est la définition d'un récepteur qui a une méthode d'authentification à utiliser comme argument dans grpc_auth.UnaryServerInterceptor '' '' qui sera expliquée plus loin. Ayez la Firebase sur le terrain.

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")

	//Vérification JWT
	token, err := au.firebase.Auth.VerifyIDToken(context.Background(), idToken)
	if err != nil {
		return
	}
	//Renvoie les informations JWT dans le jeton de clé dans le contexte de l'argument
	newCtx = context.WithValue(ctx, "token", token.Claims)
	return
}

Au fait, cet article était facile à comprendre, je vais donc le partager comme référence. Si vous lisez l'explication sur Interceptor, vous pouvez comprendre le contenu du traitement suivant en douceur. Essayez de vous authentifier / autoriser avec le middleware de gRPC-Go (Inerceptor)

Le middleware utilisé pour l'authentification utilise grpc_auth défini dans Go gRPC Middleware.

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)
	}

	//Créer une instance Firebase
	firebase, err := NewFirebase()
	if err != nil {
		log.Fatalln(err)
	}
	//Générer une instance d'authentification
	auth = *NewAuthentication(*firebase)

	//Ajouter des paramètres d'authentification au serveur
	server := grpc.NewServer(
		grpc_middleware.WithUnaryServerChain(
			grpc_auth.UnaryServerInterceptor(auth),
		),
		//Requis lors de l'utilisation du 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)
	}
}

Sommaire

C'était un moyen simple de traiter l'authentification sur le serveur Go à l'aide de gRPC et de l'authentification Firebase. L'autorisation peut être implémentée dans Interceptor de la même manière, je vais donc la dessiner dans un autre article.