Go में gRPC (Golang): लाइब्रेरी, उदाहरण और गाइड

Go (Golang) में gRPC: लाइब्रेरी और उदाहरण

gRPC क्या है और Go में इसकी आवश्यकता क्यों है?

gRPC एक हाई-परफॉर्मेंस रिमोट प्रोसीजर कॉल (RPC) फ्रेमवर्क है, जिसे Google ने विकसित किया है। यह डेटा सीरियलाइजेशन के लिए Protocol Buffers (protobuf) और ट्रांसपोर्ट के लिए HTTP/2 का उपयोग करता है। Go इकोसिस्टम में, gRPC माइक्रोसर्विस आर्किटेक्चर बनाने के लिए एक मानक बन गया है, इसके कारण:

• उच्च प्रदर्शन (बाइनरी प्रोटोकॉल, HTTP/2 मल्टीप्लेक्सिंग)
• सख्त टाइपिंग (Go में जनरेटेड कोड)
• स्ट्रीमिंग सपोर्ट (क्लाइंट, सर्वर और बिडायरेक्शनल)
• बिल्ट-इन ऑथेंटिकेशन और लोड बैलेंसिंग

इस लेख में, हम मुख्य लाइब्रेरी, टूल्स और Golang में एक पूर्ण सर्वर और क्लाइंट का उदाहरण देखेंगे।

आवश्यक लाइब्रेरी और टूल्स

Go में gRPC के साथ काम करने के लिए आवश्यक:

• google.golang.org/grpc — Go के लिए मुख्य gRPC लाइब्रेरी
• google.golang.org/protobuf — Protocol Buffers के साथ काम करना
• protoc — .proto फाइलों का कंपाइलर
• protoc-gen-go — .proto से Go कोड जनरेट करने के लिए प्लगइन
• protoc-gen-go-grpc — gRPC सर्वर/क्लाइंट कोड जनरेट करने के लिए प्लगइन

टूल्स इंस्टॉल करना

# protoc इंस्टॉल करें (Linux/macOS)
sudo apt install protobuf-compiler  # या brew install protobuf

# Go प्लगइन्स इंस्टॉल करें
go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest

# जांचें
protoc --version
protoc-gen-go --version

.proto फाइल बनाना

सर्विस और मैसेज को hello.proto फाइल में परिभाषित करके शुरू करें:

syntax = "proto3";

package hello;

option go_package = "github.com/youruser/grpc-example/hello";

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply);
  rpc SayHelloStream (HelloRequest) returns (stream HelloReply);
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

Go कोड जनरेट करना

protoc --go_out=. --go-grpc_out=. hello.proto

इसे चलाने के बाद दो फाइलें बनेंगी:

• hello.pb.go — मैसेज स्ट्रक्चर
• hello_grpc.pb.go — सर्वर और क्लाइंट इंटरफेस

Go में gRPC सर्वर बनाना

server.go फाइल बनाएं:

package main

import (
    "context"
    "log"
    "net"

    "google.golang.org/grpc"
    pb "github.com/youruser/grpc-example/hello"
)

type server struct {
    pb.UnimplementedGreeterServer
}

func (s *server) SayHello(ctx context.Context, req *pb.HelloRequest) (*pb.HelloReply, error) {
    log.Printf("प्राप्त: %v", req.GetName())
    return &pb.HelloReply{Message: "नमस्ते, " + req.GetName()}, nil
}

func (s *server) SayHelloStream(req *pb.HelloRequest, stream pb.Greeter_SayHelloStreamServer) error {
    for i := 0; i < 5; i++ {
        if err := stream.Send(&pb.HelloReply{
            Message: "नमस्ते " + req.GetName() + " - " + fmt.Sprint(i),
        }); err != nil {
            return err
        }
    }
    return nil
}

func main() {
    lis, err := net.Listen("tcp", ":50051")
    if err != nil {
        log.Fatalf("सुनने में विफल: %v", err)
    }

    s := grpc.NewServer()
    pb.RegisterGreeterServer(s, &server{})

    log.Println("सर्वर :50051 पर सुन रहा है")
    if err := s.Serve(lis); err != nil {
        log.Fatalf("सेवा करने में विफल: %v", err)
    }
}

Go में gRPC क्लाइंट बनाना

client.go फाइल बनाएं:

package main

import (
    "context"
    "log"
    "time"

    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials/insecure"
    pb "github.com/youruser/grpc-example/hello"
)

func main() {
    conn, err := grpc.Dial("localhost:50051",
        grpc.WithTransportCredentials(insecure.NewCredentials()))
    if err != nil {
        log.Fatalf("कनेक्ट नहीं हो सका: %v", err)
    }
    defer conn.Close()

    client := pb.NewGreeterClient(conn)

    ctx, cancel := context.WithTimeout(context.Background(), time.Second)
    defer cancel()

    // अनरी स्ट्रीम कॉल
    reply, err := client.SayHello(ctx, &pb.HelloRequest{Name: "दुनिया"})
    if err != nil {
        log.Fatalf("नमस्ते कहने में विफल: %v", err)
    }
    log.Printf("उत्तर: %s", reply.GetMessage())

    // सर्वर स्ट्रीम कॉल
    stream, err := client.SayHelloStream(ctx, &pb.HelloRequest{Name: "दुनिया"})
    if err != nil {
        log.Fatalf("स्ट्रीम शुरू करने में विफल: %v", err)
    }
    for {
        msg, err := stream.Recv()
        if err != nil {
            break
        }
        log.Printf("स्ट्रीम से प्राप्त: %s", msg.GetMessage())
    }
}

निष्कर्ष

इस गाइड में, हमने Go में gRPC सेटअप करना, .proto फाइलें बनाना, कोड जनरेट करना, और एक पूर्ण सर्वर और क्लाइंट बनाना सीखा। gRPC Go माइक्रोसर्विसेज के लिए एक शक्तिशाली टूल है। अधिक जानकारी के लिए आधिकारिक gRPC Go दस्तावेज़ देखें।