Microservices mit Golang und gRPC: Moderne Architektur
===========================================================

Einführung

In diesem Artikel werden wir die Microservices-Architektur mit Golang und gRPC untersuchen. Diese moderne Architektur konzentriert sich auf Skalierbarkeit, Flexibilität und Sicherheit.

Voraussetzungen

Grundkenntnisse in Golang
Go-Installation (Version 1.15 oder höher)
gRPC-Installation (Version 1.32 oder höher)
Docker-Installation (Version 20.10 oder höher)

Microservices-Architektur

Die Microservices-Architektur basiert auf der Trennung von Verantwortlichkeiten zwischen verschiedenen Diensten. Jeder Dienst hat eine bestimmte Funktion und kommuniziert über definierte Schnittstellen mit anderen Diensten.

Authentifizierungsdienst

Der Authentifizierungsdienst ist für die Überprüfung der Identität der Benutzer verantwortlich. Wir verwenden gRPC, um die Authentifizierungsschnittstelle zu definieren.

„Geh
// auth.proto
Syntax = „proto3“;

Paketauth;

Service-Auth {
rpc Login(LoginRequest) gibt (LoginResponse) {} zurück
}

Nachricht LoginRequest {
Zeichenfolge Benutzername = 1;
Zeichenfolge Passwort = 2;
}

Nachricht LoginResponse {
bool success = 1;
String-Token = 2;
}
„

Wir implementieren den Authentifizierungsdienst in Golang.

„Geh
// auth.go
Paketauthentifizierung

importieren (
„Kontext“
„Protokoll“

„google.golang.org/grpc“

pb „auth/proto“
)

Typ authService struct{}

func (s authService) Login(ctx context.Context, req pb.LoginRequest) (pb.LoginResponse, error) {
// Überprüfen Sie die Identität des Benutzers
if req.Username == "admin" && req.Password == "password" {
return &pb.LoginResponse{Success: true, Token: "token"}, null
}
return &pb.LoginResponse{Success: false}, null
}

func main() {
lis, err := net.Listen("tcp", ":50051")
if err!= nil {
log.Fatalf("failed to listen: %v", err)
}

srv := grpc.NewServer()
pb.RegisterAuthService(srv, &authService{})
log.Println("Auth-Dienst überwacht Port 50051")
srv.Serve(lis)
}
„

Produktservice

Der Produktservice ist für die Abwicklung der Geschäftslogik im Zusammenhang mit den Produkten verantwortlich. Wir verwenden gRPC, um die Produktschnittstelle zu definieren.

„Geh
// products.proto
Syntax = „proto3“;

Verpackungsprodukte;

Service Produkte {
rpc GetProducts(GetProductsRequest) gibt (GetProductsResponse) {} zurück
}

Nachricht GetProductsRequest {
int32 limit = 1;
int32 Offset = 2;
}

Nachricht GetProductsResponse {
wiederholteProduktprodukte = 1;
}

Nachricht Produkt {
int32 id = 1;
Stringname = 2;
Zeichenfolgenbeschreibung = 3;
}
„

Wir haben den Produktservice in Golang implementiert.

„Geh
// products.go
Produkte verpacken

importieren (
„Kontext“
„Protokoll“

„google.golang.org/grpc“

pb „Produkte/Proto“
)

Typ productsService struct{}

func (s productsService) GetProducts(ctx context.Context, req pb.GetProductsRequest) (pb.GetProductsResponse, error) {
// Produktgeschäftslogik verwalten
Produkte := []*pb.Product{
{Id: 1, Name: „Produkt 1“, Beschreibung: „Produktbeschreibung 1“},
{Id: 2, Name: „Produkt 2“, Beschreibung: „Produktbeschreibung 2“},
}
return &pb.GetProductsResponse{Products: products}, null
}

func main() {
lis, err := net.Listen("tcp", ":50052")
if err!= nil {
log.Fatalf("failed to listen: %v", err)
}

srv := grpc.NewServer()
pb.RegisterProductsService(srv, &productsService{})
log.Println("Produktservice lauscht auf Port 50052")
srv.Serve(lis)
}
„

Docker-Konfiguration

Um die Microservices-Architektur zu implementieren, müssen wir Docker-Images für jeden Dienst erstellen.

„dockerfile

auth/Dockerfile

VON golang:alpine

WORKDIR /app

KOPIEREN auth.go.

RUN go build -o auth auth.go

EXPOSE 50051

CMD ["./auth"]
„

„dockerfile

Produkte/Dockerfile

VON golang:alpine

WORKDIR /app

Produkte.go kopieren.

RUN go build -o products products.go

EXPOSE 50052

CMD ["./products"]
„

Architekturimplementierung

Um die Microservices-Architektur zu implementieren, müssen wir für jeden Dienst einen Container erstellen und die Kommunikation zwischen ihnen konfigurieren.

„Bash

Container erstellen

Docker Build -t Auth.
Docker Build -t-Produkte.

Docker run -d --name auth -p 50051:50051 auth
docker run -d --name products -p 50052:50052 Produkte

Konfigurieren Sie die Kommunikation zwischen Diensten

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
„

Fazit

In diesem Artikel haben wir eine Microservices-Architektur mit Golang und gRPC implementiert. Die Architektur konzentriert sich auf Skalierbarkeit, Flexibilität und Sicherheit. Authentifizierungsdienste und -produkte kommunizieren über in gRPC definierte Schnittstellen. Die Implementierung der Architektur erfolgte mit Docker und die Konfiguration der Kommunikation zwischen Diensten.

GitHub-Benachrichtigungen

> [!IMPORTANT]
> Stellen Sie sicher, dass Sie die richtige Version von Go und gRPC installieren, bevor Sie die Architektur bereitstellen.
> [!TIP]
> Verwendet Docker, um die Architektur zu implementieren und die Kommunikation zwischen Diensten zu konfigurieren.
> [!WARNUNG]
> Stellen Sie sicher, dass Sie in Ihrer Microservices-Architektur die entsprechende Sicherheit konfigurieren.