गोलंग और जीआरपीसी पर एक सरल माइक्रोसर्विस कैसे बनाएं और इसे डॉकर का उपयोग करके कंटेनरीकृत करें

नमस्कार, हेब्र! मैं आपके लिए मैट इवांस के लेख "गो, जीआरपीसी और डॉकर" का अनुवाद प्रस्तुत करता हूं।

गो और डॉकर को साझा करने के बारे में कई लेख हैं। ऐसे कंटेनर बनाना जो ग्राहकों और आपस में बातचीत कर सकें, बहुत आसान है। निम्नलिखित एक छोटा सा उदाहरण है कि यह बुनियादी स्तर पर कैसे किया जाता है।

हम क्या पैदा करते हैं?

हम बहुत ही सरल क्लाइंट और सर्वर बनाएंगे, एक दूसरे के साथ जीआरपीसी का उपयोग करके बातचीत करेंगे । सर्वर डॉकर कंटेनर के अंदर स्थित होगा ताकि इसे आसानी से तैनात किया जा सके।

मान लीजिए हमें एक ऐसी सेवा की आवश्यकता है जो क्लाइंट से स्ट्रिंग प्राप्त करती है और एक स्ट्रिंग को रिवर्स कैरेक्टर ऑर्डर के साथ लौटाती है। उदाहरण के लिए, एक "बिल्ली" भेजें और प्रतिक्रिया में एक "चालू" प्राप्त करें।

.proto फ़ाइल

.proto- फाइल यह बताती है कि हमारी सेवा किन कार्यों को अंजाम देगी और किस डेटा का आदान-प्रदान करेगी। प्रोजेक्ट में प्रोटो फोल्डर बनाएं, और उसमें रिवर्स.प्रोटो फाइल करें

syntax = "proto3"; package reverse; service Reverse { rpc Do(Request) returns (Response) {} } message Request { string message = 1; } message Response { string message = 1; } 

एक फ़ंक्शन जिसे सर्वर पर दूरस्थ रूप से कहा जाता है और क्लाइंट को डेटा लौटाता है, उसे आरपीसी के रूप में चिह्नित किया जाता है। अंतःक्रियात्मक नोड्स के बीच सूचनाओं के आदान-प्रदान के लिए उपयोग किए जाने वाले डेटा संरचनाओं को संदेश के रूप में चिह्नित किया जाता है। प्रत्येक संदेश फ़ील्ड को एक क्रम संख्या निर्दिष्ट किया जाना चाहिए। इस स्थिति में, हमारा फ़ंक्शन क्लाइंट से अनुरोध प्रकार के संदेश प्राप्त करता है और प्रतिक्रिया प्रकार के संदेश लौटाता है।
एक बार जब हमने एक .proto फ़ाइल बनाई है, तो हमारी सेवा की .go फ़ाइल प्राप्त करना आवश्यक है। ऐसा करने के लिए, प्रोटो फ़ोल्डर में निम्न कंसोल कमांड चलाएँ:

 $ protoc -I . reverse.proto --go_out=plugins=grpc:. 

बेशक, पहले आपको जीआरपीसी बनाने की जरूरत है।
उपरोक्त कमांड को निष्पादित करने से एक नई .go फ़ाइल बनेगी जिसमें क्लाइंट, सर्वर और संदेश बनाने के तरीके हैं, जो वे विनिमय करते हैं। यदि हम गोडोक कहते हैं, तो हम निम्नलिखित देखेंगे:

 $ godoc . PACKAGE DOCUMENTATION package reverse import "." Package reverse is a generated protocol buffer package. It is generated from these files: reverse.proto It has these top-level messages: Request Response .... 

ग्राहक

यह अच्छा होगा यदि हमारे ग्राहक इस तरह काम करें:

 reverse "this is a test" tset a si siht 

यहां वह कोड है जो .proto फ़ाइल से उत्पन्न डेटा संरचनाओं का उपयोग करके gRPC क्लाइंट बनाता है:

 package main import ( "context" "fmt" "os" pb "github.com/matzhouse/go-grpc/proto" "google.golang.org/grpc" "google.golang.org/grpc/grpclog" ) func main() { opts := []grpc.DialOption{ grpc.WithInsecure(), } args := os.Args conn, err := grpc.Dial("127.0.0.1:5300", opts...) if err != nil { grpclog.Fatalf("fail to dial: %v", err) } defer conn.Close() client := pb.NewReverseClient(conn) request := &pb.Request{ Message: args[1], } response, err := client.Do(context.Background(), request) if err != nil { grpclog.Fatalf("fail to dial: %v", err) } fmt.Println(response.Message) } 

सर्वर

सर्वर एक ही उत्पन्न .go फ़ाइल का उपयोग करेगा। हालाँकि, यह केवल सर्वर इंटरफ़ेस को परिभाषित करता है, लेकिन हमें अपने दम पर तर्क को लागू करना होगा:

 package main import ( "net" pb "github.com/matzhouse/go-grpc/proto" "golang.org/x/net/context" "google.golang.org/grpc" "google.golang.org/grpc/grpclog" ) func main() { listener, err := net.Listen("tcp", ":5300") if err != nil { grpclog.Fatalf("failed to listen: %v", err) } opts := []grpc.ServerOption{} grpcServer := grpc.NewServer(opts...) pb.RegisterReverseServer(grpcServer, &server{}) grpcServer.Serve(listener) } type server struct{} func (s *server) Do(c context.Context, request *pb.Request) (response *pb.Response, err error) { n := 0 // reate an array of runes to safely reverse a string. rune := make([]rune, len(request.Message)) for _, r := range request.Message { rune[n] = r n++ } // Reverse using runes. rune = rune[0:n] for i := 0; i < n/2; i++ { rune[i], rune[n-1-i] = rune[n-1-i], rune[i] } output := string(rune) response = &pb.Response{ Message: output, } return response, nil } 

डाक में काम करनेवाला मज़दूर

मुझे लगता है कि आप जानते हैं कि डॉकटर क्या है और इसके लिए क्या है। यहाँ हमारा डॉकफाइल है :

 FROM golang:1.12 ADD . /go/src/github.com/matzhouse/go-grpc/server RUN go install github.com/matzhouse/go-grpc/server ENTRYPOINT ["/go/bin/server"] EXPOSE 5300 

डॉकर छवि के लिए विधानसभा कोड यहां लिखा गया है। हम इसका विश्लेषण लाइन द्वारा करेंगे।

 FROM golang:1.12 

इस कमांड का अर्थ है कि हम पहले से बनाई गई छवि के आधार पर अपने आवेदन की एक छवि बनाना चाहते हैं, जिसका नाम है गोलगंग । यह गो में लिखे गए प्रोग्राम बनाने और चलाने के लिए पहले से कॉन्फ़िगर किए गए वातावरण के साथ एक डॉकटर छवि है।

 ADD . /go/src/github.com/matzhouse/go-grpc/server 

यह कमांड हमारे एप्लीकेशन के सोर्स कोड को GOPATH / src कंटेनर में कॉपी करता है ।

 RUN go install github.com/matzhouse/go-grpc/server 

यह कमांड हमारे एप्लिकेशन को कंटेनर में कॉपी किए गए स्रोतों से इकट्ठा करता है और इसे GOPATH / बिन कंटेनर फ़ोल्डर में स्थापित करता है।

 ENTRYPOINT ["/go/bin/server"] 

यह कमांड कंटेनर को एक निष्पादन योग्य प्रोग्राम के रूप में काम करने के लिए कॉन्फ़िगर करता है। इसमें, हम एप्लिकेशन को निष्पादन योग्य करने के लिए पथ को इंगित करते हैं और, यदि आवश्यक हो, तो कमांड लाइन तर्क।

 EXPOSE 5300 

इस कमांड के साथ, हम कंटेनर को बताते हैं कि किन बंदरगाहों को बाहर से पहुंचना चाहिए।

सर्वर प्रारंभ

हमें अपने सर्वर एप्लिकेशन के साथ कंटेनर को चलाने की आवश्यकता है।
पहले आपको Dockerfile के निर्देशों के आधार पर छवि बनाने की आवश्यकता है:

 $ sudo docker build -t matzhouse/grpc-server . Sending build context to Docker daemon 31.76 MB Step 1/5 : FROM golang ---> a0c61f0b0796 Step 2/5 : ADD . /go/src/github.com/matzhouse/go-grpc ---> 9508be6501c1 Removing intermediate container 94dc6e3a9a20 Step 3/5 : RUN go install github.com/matzhouse/go-grpc/server ---> Running in f3e0b993a420 ---> f7a0370b7f7d Removing intermediate container f3e0b993a420 Step 4/5 : ENTRYPOINT /go/bin/server ---> Running in 9c9619e45df4 ---> fb34dfe1c0ea Removing intermediate container 9c9619e45df4 Step 5/5 : EXPOSE 5300 ---> Running in 0403390af135 ---> 008e09b9aebd Removing intermediate container 0403390af135 Successfully built 008e09b9aebd 

अब हम इस छवि को सूची में देख सकते हैं:

 $ docker images REPOSITORY TAG IMAGE ID ... matzhouse/grpc-server latest 008e09b9aebd ... 

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

 $ docker run -it -p 5300:5300 matzhouse/grpc-server 

इस मामले में, तथाकथित पोर्ट अग्रेषण । ध्यान दें कि इसके लिए हमें EXPOSE स्टेटमेंट और -p तर्क दोनों की आवश्यकता है।

क्लाइंट लॉन्च

क्लाइंट का कंटेनरीकरण बड़ा लाभ नहीं देगा, तो आइए इसे सामान्य तरीके से शुरू करें:

 $ go build -o reverse $ ./reverse "this is a test" tset a si siht 

पढ़ने के लिए धन्यवाद!