परिचय

माइक्रोसर्विसेज और वितरित सिस्टम की दुनिया में, सेवाओं के बीच कुशल संचार महत्वपूर्ण है। यहीं पर gRPC, Google द्वारा विकसित एक उच्च-प्रदर्शन RPC (रिमोट प्रोसीजर कॉल) ढांचा, चलन में आता है। सरलता और दक्षता के लिए डिज़ाइन की गई एक सांख्यिकीय रूप से टाइप की गई संकलित प्रोग्रामिंग भाषा गो के साथ संयुक्त, जीआरपीसी आपको मजबूत और स्केलेबल वेब सेवाएं बनाने में मदद कर सकती है।

जीआरपीसी क्या है?

gRPC का मतलब है google Remote Procedure Call. यह एक ओपन-सोर्स फ्रेमवर्क है जो परिवहन के लिए HTTP/2, इंटरफ़ेस विवरण भाषा के रूप में प्रोटोकॉल बफ़र्स का उपयोग करता है, और प्रमाणीकरण, लोड संतुलन और बहुत कुछ जैसी सुविधाएँ प्रदान करता है। जीआरपीसी आपको अपनी सेवा विधियों और संदेश प्रकारों को एक .proto फ़ाइल में परिभाषित करने की अनुमति देता है, जिसका उपयोग कई भाषाओं में क्लाइंट और सर्वर कोड उत्पन्न करने के लिए किया जा सकता है।

गो के साथ जीआरपीसी का उपयोग क्यों करें?

1. प्रदर्शन: जीआरपीसी HTTP/2 का उपयोग करता है, जो एक ही कनेक्शन पर एकाधिक अनुरोधों को मल्टीप्लेक्स करने, विलंबता को कम करने और प्रदर्शन में सुधार करने की अनुमति देता है।
2. कोड जनरेशन: प्रोटोकॉल बफ़र्स के साथ, आप अपनी सेवा को एक बार परिभाषित कर सकते हैं और गो में क्लाइंट और सर्वर कोड जेनरेट कर सकते हैं, स्थिरता सुनिश्चित कर सकते हैं और बॉयलरप्लेट कोड को कम कर सकते हैं।
3. स्ट्रीमिंग: जीआरपीसी क्लाइंट-साइड, सर्वर-साइड और द्विदिशात्मक स्ट्रीमिंग का समर्थन करता है, जो इसे वास्तविक समय अनुप्रयोगों के लिए आदर्श बनाता है।
4. इंटरऑपरेबिलिटी: जीआरपीसी सेवाओं का उपयोग विभिन्न भाषाओं में लिखे गए ग्राहकों द्वारा किया जा सकता है, जो इसे बहुभाषी वातावरण के लिए एक बहुमुखी विकल्प बनाता है।

गो में जीआरपीसी के साथ शुरुआत करना

• ### पूर्वापेक्षाएँ

  शुरू करने से पहले, सुनिश्चित करें कि आपने निम्नलिखित इंस्टॉल कर लिया है:

  • जाओ (दो नवीनतम प्रमुख रिलीज में से कोई भी)
  • प्रोटोकॉल बफ़र कंपाइलर (प्रोटोकॉल)
  • प्रोटोकॉल बफ़र कंपाइलर के लिए गो प्लगइन्स

  आप निम्नलिखित कमांड का उपयोग करके गो प्लगइन्स इंस्टॉल कर सकते हैं:
  

  go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
  go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest
  

  अपना PATH अपडेट करें ताकि प्रोटोक कंपाइलर प्लगइन ढूंढ सके:
  

  export PATH="$PATH:$(go env GOPATH)/bin"
  

  टर्मिनल खोलकर और टाइप करके पुष्टि करें कि प्रोटोक आपके सिस्टम में स्थापित और कॉन्फ़िगर किया गया है:
  

  protoc --version
  

  आपको इसके समान एक आउटपुट देखना चाहिए
  

  C:\Users\Guest>protoc --version
  ~ libprotoc 27.3
  

  यदि यह प्रोटोक कमांड को नहीं पहचानता है, तो आप प्रोटोकॉल बफ़र्स स्थापित करने के लिए विंडोज़ के लिए चॉकलेटी का उपयोग कर सकते हैं:
  

  choco install protoc
  

  यदि यह मामला नहीं है, जहां आपके पास चॉकलेटी इंस्टॉल नहीं है या आप एक अलग ओएस पर हैं, तो आप यहां आधिकारिक इंस्टॉलेशन दस्तावेज़ देख सकते हैं।

  सेवा को परिभाषित करना

  अपनी जीआरपीसी सेवा को परिभाषित करने के लिए एक .proto फ़ाइल बनाएं। उदाहरण के लिए:

  helloworld.proto
  

  syntax = "proto3";
  package helloworld;
  
  message HelloRequest {
      string name = 1;
  }
  message HelloResponse {
      string message = 1;
  }
  
  service Greeter {
      rpc SayHello (HelloRequest) returns (HelloResponse) {}
  }
  

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

  अपनी .proto फ़ाइल से गो कोड जेनरेट करें:
  

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

  सर्वर का कार्यान्वयन

  गो में एक सर्वर बनाएं:

  server.go
  

  package main
  
  import (
      "context"
      "log"
      "net"
  
      "google.golang.org/grpc"
      pb "path/to/your/proto"
  )
  
  type server struct {
      pb.GreeterServer
  }
  
  func main() {
      lis, err := net.Listen("tcp", ":8080")
      if err != nil {
          log.Fatalf("failed to listen: %v", err)
      }
  
      log.Printf("Server started at %v", lis.Addr())
  
      grpcServer := grpc.NewServer()
      pb.RegisterGreeterServer(grpcServer, &server{})
      if err := grpcServer.Serve(lis); err != nil {
          log.Fatalf("failed to serve: %v", err)
      }
  }
  
  // SayHello name should be the same RPC name as defined in your proto file
  func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloResponse, error) {
      return &pb.HelloResponse{Message: "Hello "   in.Name}, nil
  }
  

  क्लाइंट बनाना

  गो में एक क्लाइंट बनाएं:

  client.go
  

  package main
  
  import (
      "context"
      "log"
      "os"
      "time"
  
      "google.golang.org/grpc"
      pb "path/to/your/proto"
  )
  
  func main() {
      conn, err := grpc.NewClient("localhost:8080", grpc.WithTransportCredentials(insecure.NewCredentials()))
      if err != nil {
          log.Fatalf("did not connect: %v", err)
      }
      defer conn.Close()
      client := pb.NewGreeterClient(conn)
  
      name := "John Doe"
      if len(os.Args) > 1 {
          name = os.Args[1]
      }
  
      callSayHello( client, name )
  }
  
  func callSayHello(client pb.GrpcServiceClient, name string) {
      ctx, cancel := context.WithTimeout(context.Background(), time.Second)
      defer cancel()
  
      res, err := client.SayHello(ctx, &pb.HelloRequest{Name: name})
      if err != nil {
          log.Fatalf("Failed to called: %v", err)
      }
      log.Printf("%v", res)
  }
  

निष्कर्ष

जीआरपीसी और गो मिलकर उच्च-प्रदर्शन, स्केलेबल वेब सेवाओं के निर्माण के लिए एक शक्तिशाली संयोजन प्रदान करते हैं। दोनों की शक्तियों का लाभ उठाकर, आप कुशल और विश्वसनीय एप्लिकेशन बना सकते हैं जिनका रखरखाव और विस्तार करना आसान है।

डेमो रेपो से लिंक: Github.com