Microservices avec Golang et gRPC : architecture moderne
==============================================================
Présentation
Dans cet article, nous explorerons l'architecture des microservices utilisant Golang et gRPC. Cette architecture moderne se concentre sur l'évolutivité, la flexibilité et la sécurité.
Prérequis
Connaissance de base de Golang
Allez à l'installation (version 1.15 ou supérieure)
Installation de gRPC (version 1.32 ou supérieure)
Installation Docker (version 20.10 ou supérieure)
Architecture des microservices
L'architecture des microservices repose sur la séparation des responsabilités entre les différents services. Chaque service a une fonction spécifique et communique avec d'autres services via des interfaces définies.
Service d'authentification
Le service d'authentification est chargé de vérifier l'identité des utilisateurs. Nous utilisons gRPC pour définir l'interface d'authentification.
va
// auth.proto
syntaxe = "proto3" ;
paquetauth ;
authentification du service {
La connexion rpc (LoginRequest) renvoie (LoginResponse) {}
}
message Demande de connexion {
chaîne nom d'utilisateur = 1 ;
mot de passe de chaîne = 2 ;
}
message ConnexionRéponse {
booléen succès = 1 ;
jeton de chaîne = 2 ;
}
Nous implémentons le service d'authentification dans Golang.
va
// auth.go
authentification du paquet
importer (
"contexte"
"journal"
"google.golang.org/grpc"
pb "auth/proto"
)
tapez la structure authService{}
func (s *authService) Login (ctx context.Context, req *pb.LoginRequest) (*pb.LoginResponse, erreur) {
// Vérifier l'identité de l'utilisateur
if req.Username == "admin" && req.Password == "password" {
return &pb.LoginResponse{Succès : vrai, Jeton : "jeton"}, nul
}
return &pb.LoginResponse{Succès : false}, nul
}
fonction main() {
lis, err := net.Listen("tcp", ":50051")
si erreur ! = nul {
log.Fatalf("échec de l'écoute : %v", err)
}
srv := grpc.NewServer()
pb.RegisterAuthService(srv, &authService{})
log.Println("Service d'authentification à l'écoute sur le port 50051")
srv.Serve(lis)
}
Service produit
Le service produit est responsable de la gestion de la logique métier liée aux produits. Nous utilisons gRPC pour définir l'interface du produit.
va
// produits.proto
syntaxe = "proto3" ;
produits d'emballage;
produits de service {
rpc GetProducts(GetProductsRequest) renvoie (GetProductsResponse) {}
}
message GetProductsRequest {
limite int32 = 1 ;
int32 décalage = 2 ;
}
message GetProductsResponse {
produitsproduits répétés = 1 ;
}
message Produit {
int32 identifiant = 1 ;
nom de chaîne = 2 ;
description de la chaîne = 3 ;
}
Nous avons mis en œuvre le service produit à Golang.
va
// produits.go
produits d'emballage
importer (
"contexte"
"journal"
"google.golang.org/grpc"
pb "produits/proto"
)
tapez la structure productsService{}
func (s *productsService) GetProducts(ctx context.Context, req *pb.GetProductsRequest) (*pb.GetProductsResponse, erreur) {
// Gérer la logique métier du produit
produits := []*pb.Product{
{Id : 1, Nom : "Produit 1", Description : "Description du produit 1"},
{Id : 2, Nom : "Produit 2", Description : "Description du produit 2"},
}
return &pb.GetProductsResponse{Produits : produits}, nul
}
fonction main() {
lis, err := net.Listen("tcp", ":50052")
si erreur ! = nul {
log.Fatalf("échec de l'écoute : %v", err)
}
srv := grpc.NewServer()
pb.RegisterProductsService(srv, &productsService{})
log.Println("Service de produits en écoute sur le port 50052")
srv.Serve(lis)
}
###Configuration du Docker
Pour implémenter l'architecture des microservices, nous devons créer des images Docker pour chaque service.
fichier docker
# auth/Dockerfile
DE golang:alpin
RÉPERT TRAVAIL /app
COPIER auth.go.
EXÉCUTER go build -o auth auth.go
EXPOSER 50051
CMD ["./auth"]
fichier docker
# produits/fichier Docker
DE golang:alpin
RÉPERT TRAVAIL /app
COPIER produits.go.
RUN go build -o produits produits.go
EXPOSER 50052
CMD ["./produits"]
Implémentation de l'architecture
Pour implémenter l'architecture des microservices, nous devons créer un conteneur pour chaque service et configurer la communication entre eux.
bash
# Créer des conteneurs
docker build -t auth.
produits docker build -t.
docker run -d --name auth -p 50051:50051 auth
docker run -d --name produits -p 50052:50052 produits
# Configurer la communication entre les services
docker exec -it auth grpcurl -plaintext -d '{"username": "admin", "password": "password"}' localhost:50051/auth/Login
docker exec -it products grpcurl -plaintext -d '{"limit": 10, "offset": 0}' localhost:50052/products/GetProducts
###Conclusion
Dans cet article, nous avons implémenté une architecture de microservices utilisant Golang et gRPC. L'architecture se concentre sur l'évolutivité, la flexibilité et la sécurité. Les services et produits d'authentification communiquent via des interfaces définies dans gRPC. La mise en œuvre de l'architecture a été réalisée à l'aide de Docker et la communication entre les services a été configurée.
Alertes GitHub
> [!IMPORTANT]
> Assurez-vous d'installer la bonne version de Go et gRPC avant de déployer l'architecture.
> [!ASTUCE]
> Utilise Docker pour implémenter l'architecture et configurer la communication entre les services.
> [!AVERTISSEMENT]
> Assurez-vous de configurer une sécurité appropriée dans votre architecture de microservices.
