Go Academy · Leçon

Implémenter un service gRPC unaire

Serveur et client avec grpc-go

Implémenter un service gRPC unaire est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Go Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Go Academy comprend 4 leçons au total.

Qu’est-ce qu’un RPC unaire ?

Un RPC unaire est le modèle gRPC le plus simple : le client envoie une requête et reçoit une réponse, comme lors d’un appel de fonction classique sur le réseau.

Implémentation du serveur

Implémentez l’interface générée. Intégrez la structure Unimplemented*Server pour assurer la compatibilité avec les versions futures :

type userServer struct {
    pb.UnimplementedUserServiceServer
    db *sql.DB
}

func (s *userServer) GetUser(ctx context.Context, req *pb.GetUserRequest) (*pb.User, error) {
    // query DB
    return &pb.User{Id: req.Id, Name: "Alice"}, nil
}

Démarrage du serveur

Créez un serveur gRPC, enregistrez l’implémentation et écoutez sur un port TCP :

lis, _ := net.Listen("tcp", ":50051")
grpcSrv := grpc.NewServer()
pb.RegisterUserServiceServer(grpcSrv, &userServer{})
log.Fatal(grpcSrv.Serve(lis))

Connexion du client

Contactez le serveur et créez un stub client :

conn, err := grpc.NewClient("localhost:50051", grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil { log.Fatal(err) }
defer conn.Close()
client := pb.NewUserServiceClient(conn)

Effectuer un appel unaire

Appelez la méthode RPC sur le stub client comme s’il s’agissait d’une fonction locale :

ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
user, err := client.GetUser(ctx, &pb.GetUserRequest{Id: 42})
if err != nil { log.Fatalf("error: %v", err) }
fmt.Println(user.Name)

Gestion des erreurs

gRPC utilise des codes d’état. Renvoyez les erreurs avec status.Errorf et vérifiez-les avec status.Code(err) :

import "google.golang.org/grpc/status"
import "google.golang.org/grpc/codes"

// Server:
return nil, status.Errorf(codes.NotFound, "user %d not found", req.Id)
// Client:
if status.Code(err) == codes.NotFound { /* handle */ }

Propagation du contexte

Le contexte transmis à l’appel RPC du client transporte les délais d’expiration et l’annulation jusqu’au serveur. Le serveur doit le transmettre aux appels en aval (base de données, autres RPC).

TLS en production

En production, remplacez les identifiants non sécurisés par TLS :

creds, _ := credentials.NewServerTLSFromFile("cert.pem", "key.pem")
grpcSrv := grpc.NewServer(grpc.Creds(creds))

UnimplementedServer

L’intégration de pb.UnimplementedXxxServer fournit des implémentations factices de toutes les méthodes RPC qui renvoient le statut Unimplemented. Ainsi, le serveur continue de se compiler lorsque de nouveaux RPC sont ajoutés au fichier proto avant que vous ne les implémentiez.

grpc.Dial et grpc.NewClient

grpc.Dial est obsolète dans les versions récentes. Utilisez grpc.NewClient, qui n’établit pas immédiatement de connexion, mais le fait de manière différée lors du premier appel RPC.

Service de réflexion

Enregistrez le service de réflexion gRPC pour permettre à des outils comme grpcurl d’inspecter les services disponibles sans le fichier .proto :

reflection.Register(grpcSrv)

Vérification rapide

À quoi sert l’intégration de pb.UnimplementedXxxServer dans une structure de serveur gRPC ?

Récapitulatif : RPC gRPC unaire

Points clés :

Implémentez l’interface générée ; intégrez UnimplementedServer
grpc.NewServer() + Register + Serve sur un écouteur TCP
Client : grpc.NewClient + NewXxxClient généré
Utilisez status.Errorf/status.Code pour gérer les erreurs gRPC

Questions Fréquemment Posées

La leçon « Implémenter un service gRPC unaire » est-elle gratuite ?

Oui — le texte complet de « Implémenter un service gRPC unaire » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Go Academy, passe à CoddyKit PRO. Le cours Go Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Implémenter un service gRPC unaire » ?

Serveur et client avec grpc-go Tu pratiques Go Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Go Academy ?

Aucune expérience préalable n'est requise. Go Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Implémenter un service gRPC unaire » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Go Academy ?

Oui. Chaque leçon Go Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Go Academy