💫 💅🏾 👩🏿 गोलंग और gRPC पर एक माइक्रोसैकेयर आर्किटेक्चर का निर्माण, भाग 2 (docker) 🔎 🚽 🤰🏽

यह कंटेनरों से निपटने का समय है

सबसे पहले, हम नवीनतम लिनक्स अल्पाइन छवि का उपयोग करते हैं। लिनक्स अल्पाइन एक हल्का लिनक्स वितरण है जिसे डॉकर में वेब एप्लिकेशन चलाने के लिए डिज़ाइन और अनुकूलित किया गया है। दूसरे शब्दों में, लिनक्स अल्पाइन में अधिकांश अनुप्रयोगों को चलाने के लिए पर्याप्त निर्भरता और कार्यक्षमता है। इसका मतलब है कि छवि का आकार लगभग 8 एमबी है!

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

इसलिए, अब मुझे उम्मीद है कि आप कंटेनरीकरण में मूल्य देखते हैं, और हम अपनी पहली सेवा "डॉकरीज़िंग" शुरू कर सकते हैं। आइए डॉकफाइल $ टच कंसाइनमेंट-सर्विस / डॉकफेराइल बनाएं ।

पहला भाग
मूल इवानवैलेंटाइन रिपॉजिटरी
मूल लेख

Dockerfile में, निम्नलिखित जोड़ें:

FROM alpine:latest RUN mkdir /app WORKDIR /app ADD consignment-service /app/consignment-service CMD ["./consignment-service"]

फिर हम अपने एप्लिकेशन को होस्ट करने के लिए एक नई निर्देशिका बनाते हैं। फिर हम अपने डॉकर कंटेनर में अपने संकलित बाइनरी को जोड़ते हैं और इसे चलाते हैं।

अब, Docker इमेज बनाने के लिए हमारे Makefile के बिल्ड रिकॉर्ड को अपडेट करें।

 build: ... GOOS=linux GOARCH=amd64 go build docker build -t consignment .

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

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

मैं हमारे Makefile में एक नई प्रविष्टि जोड़ने जा रहा हूं:

 run: docker run -p 50051:50051 shippy-service-consignment

यहाँ हम पोर्ट ५००५१ खोलकर अपनी डॉक इमेज बनाते हैं। चूंकि डॉकर एक अलग नेटवर्क लेयर पर काम करता है, इसलिए आपको पोर्ट को रीडायरेक्ट करना होगा। उदाहरण के लिए, यदि आप पोर्ट 8080 पर यह सेवा शुरू करना चाहते हैं, तो आपको -p तर्क को 8080: 50051 में बदलना होगा। आप -d ध्वज को शामिल करके कंटेनर को पृष्ठभूमि में भी चला सकते हैं। उदाहरण के लिए, docker रन -d -p 50051: 50051 खेप-सेवा ।

$ मेक रन चलाएं , फिर एक अलग टर्मिनल पैनल में $ फिर से रन मेन.ओगो और जांचें कि यह अभी भी काम करता है।

जब आप $ docker बिल्ड चलाते हैं, तो आप इमेज में अपना कोड और रनटाइम एम्बेड करते हैं। डॉकर छवियां आपके पर्यावरण और इसकी निर्भरता की पोर्टेबल छवियां हैं। आप Docker चित्र को Docker Hub पर पोस्ट करके साझा कर सकते हैं। जो कि npm या yum रिपॉजिटरी के समान है docker images के लिए। जब आप अपने Dockerfile में FROM को परिभाषित करते हैं, तो आप Docker को आधार के रूप में उपयोग के लिए Docker रिपॉजिटरी से इस छवि को खींचने के लिए कहते हैं। फिर आप इस आधार फ़ाइल के कुछ हिस्सों को विस्तारित और पुनर्परिभाषित कर सकते हैं, उन्हें अपनी इच्छानुसार पुन: परिभाषित कर सकते हैं। हम अपनी डॉक छवियों को प्रकाशित नहीं करेंगे, लेकिन बेझिझक डॉकर रिपॉजिटरी को ब्राउज़ करें और ध्यान दें कि लगभग किसी भी सॉफ्टवेयर को पहले ही कंटेनरों में पैक किया जा चुका है। कुछ बहुत ही अद्भुत चीजें डॉकटराइज की गईं।

Dockerfile के प्रत्येक विज्ञापन को पहली बार बनाया गया है। यह हर बार जब आप परिवर्तन करते हैं, तो पूरे रनटाइम को फिर से बनाने की आवश्यकता समाप्त हो जाती है। डॉकटर यह पता लगाने के लिए काफी स्मार्ट है कि कौन से विवरण बदल गए हैं और जिन्हें फिर से बनाने की आवश्यकता है। यह निर्माण प्रक्रिया को अविश्वसनीय रूप से तेज बनाता है।

कंटेनरों के बारे में पर्याप्त! आइए अपने कोड पर वापस जाएं।

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

यह वह जगह है जहाँ खोज सेवा खेल में आती है। खोज सेवा आपकी सभी सेवाओं और उनके स्थानों की निर्देशिका को अपडेट करती है। प्रत्येक सेवा रनटाइम में पंजीकृत है और पास में अनरजिस्टर्ड हैं। प्रत्येक सेवा को फिर एक नाम या पहचानकर्ता सौंपा जाता है। इस प्रकार, भले ही इसका एक नया आईपी पता या एक मेजबान पता हो, बशर्ते कि सेवा का नाम समान हो, आपको अन्य सेवाओं से इस सेवा में कॉल अपडेट करने की आवश्यकता नहीं है।

एक नियम के रूप में, इस समस्या के कई दृष्टिकोण हैं, लेकिन, प्रोग्रामिंग में अधिकांश चीजों की तरह, यदि कोई पहले से ही इस समस्या से निपट चुका है, तो पहिया को फिर से स्थापित करने का कोई मतलब नहीं है। @Chuhnk (असीम असलम), गो-माइक्रो का निर्माता, इन समस्याओं को शानदार स्पष्टता और उपयोग में आसानी के साथ हल करता है। वह अकेले ही शानदार सॉफ्टवेयर तैयार करता है। यदि आप जो देखते हैं, तो कृपया उसकी मदद करने पर विचार करें!

माइक्रो जाओ

गो-माइक्रो, गो के साथ, सबसे अधिक समय के लिए, उपयोग के लिए, गो में लिखा गया एक शक्तिशाली माइक्रोसवर्क फ्रेमवर्क है। हालाँकि, आप अन्य भाषाओं के साथ बातचीत करने के लिए Sidecar का उपयोग कर सकते हैं।

Go में माइक्रो-सर्विसेज़ बनाने के लिए गो-माइक्रो की उपयोगी विशेषताएं हैं। लेकिन हम शायद सबसे आम समस्या से शुरू करेंगे जो वह हल करती है, और यह एक सेवा की खोज है।

गो-माइक्रो के साथ काम करने के लिए हमें अपनी सेवा में कई अपडेट करने होंगे। Go-micro एक Protoc प्लगइन के रूप में एकीकृत होता है, इस मामले में मानक gRPC प्लगइन की जगह ले रहा है जिसे हम वर्तमान में उपयोग कर रहे हैं। तो, चलिए इसे हमारे Makefile में प्रतिस्थापित करके शुरू करते हैं।

गो-माइक्रो निर्भरता स्थापित करना सुनिश्चित करें:

 go get -u github.com/micro/protobuf/{proto,protoc-gen-go}

GRPC प्लगइन के बजाय गो-माइक्रो प्लगइन का उपयोग करने के लिए हमारे Makefile को अपडेट करें:

 build: protoc -I. --go_out=plugins=micro:. \ proto/consignment/consignment.proto GOOS=linux GOARCH=amd64 go build docker build -t consignment . run: docker run -p 50051:50051 shippy-service-consignment

अब हमें गो-माइक्रो का उपयोग करने के लिए अपने शिपी-सेवा-कंसाइनमेंट / मेन.गो को अपडेट करना होगा। यह हमारे पिछले gRPC कोड में से अधिकांश को अमूर्त कर देता है। यह आसानी से पंजीकरण की प्रक्रिया करता है और एक सेवा के लेखन को गति देता है।

shippy-service-consignment / main.go

 // shippy-service-consignment/main.go package main import ( "fmt" //  protobuf  pb "github.com/EwanValentine/shippy/consignment-service/proto/consignment" "github.com/micro/go-micro" "context" ) //repository -   type repository interface { Create(*pb.Consignment) (*pb.Consignment, error) GetAll() []*pb.Consignment } // Repository -    , //       type Repository struct { consignments []*pb.Consignment } func (repo *Repository) Create(consignment *pb.Consignment) (*pb.Consignment, error) { updated := append(repo.consignments, consignment) repo.consignments = updated return consignment, nil } func (repo *Repository) GetAll() []*pb.Consignment { return repo.consignments } //         //       proto. //           . type service struct { repo repository } // CreateConsignment -        , //    create,      //     gRPC. func (s *service) CreateConsignment(ctx context.Context, req *pb.Consignment, res *pb.Response) error { // Save our consignment consignment, err := s.repo.Create(req) if err != nil { return err } // Return matching the `Response` message we created in our // protobuf definition. res.Created = true res.Consignment = consignment return nil } //GetConsignments -         func (s *service) GetConsignments(ctx context.Context, req *pb.GetRequest, res *pb.Response) error { consignments := s.repo.GetAll() res.Consignments = consignments return nil } func main() { repo := &Repository{} //     Go-micro srv := micro.NewService( //           proto micro.Name("shippy.service.consignment"), ) // Init will parse the command line flags. srv.Init() //   pb.RegisterShippingServiceHandler(srv.Server(), &service{repo}) //   log.Println(" ") if err := srv.Run(); err != nil { fmt.Println(err) } }

यहाँ मुख्य परिवर्तन है जिस तरह से हम अपने gRPC सर्वर को बनाते हैं, जिसे mico.NewService () से बड़े करीने से सारगर्भित किया गया है, जो हमारी सेवा के पंजीकरण को संभालता है। और अंत में, सेवा। Run () फ़ंक्शन, जो कनेक्शन को स्वयं संसाधित करता है। पहले की तरह, हम अपने कार्यान्वयन को पंजीकृत करते हैं, लेकिन इस बार थोड़ा अलग तरीके से।

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

अंत में, हम अब पोर्ट को प्रोग्राम नहीं करते हैं। गो-माइक्रो को पर्यावरण चर या कमांड लाइन तर्कों का उपयोग करके कॉन्फ़िगर किया जाना चाहिए। पता सेट करने के लिए, MICRO_SERVER_ADDRESS =: 50051 का उपयोग करें। डिफ़ॉल्ट रूप से, माइक्रो स्थानीय उपयोग के लिए सेवा खोज ब्रोकर के रूप में mdns (मल्टीकास्ट डीएनएस) का उपयोग करता है। आमतौर पर आप उत्पादन के वातावरण में सेवाओं की खोज के लिए mdns का उपयोग नहीं करते हैं, लेकिन हम परीक्षण के लिए स्थानीय रूप से कौंसुल या कॉर्ड जैसे कुछ चलाने से बचना चाहते हैं। इस पर और बाद में।

आइए इसे दर्शाने के लिए हमारे Makefile को अपडेट करें।

 build: protoc -I. --go_out=plugins=micro:. \ proto/consignment/consignment.proto GOOS=linux GOARCH=amd64 go build docker build -t consignment . run: docker run -p 50051:50051 \ -e MICRO_SERVER_ADDRESS=:50051 \ shippy-service-consignment

-वह पर्यावरण चर का ध्वज है, यह आपको अपने गोदी कंटेनर में पर्यावरण चर को पारित करने की अनुमति देता है। आपके पास प्रत्येक चर के लिए एक ध्वज होना चाहिए, उदाहरण के लिए -E ENV = स्टेजिंग -e DB_HOST = लोकलहोस्ट, आदि।

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

खेप-CLI

 package main import ( "encoding/json" "io/ioutil" "log" "os" "context" pb "github.com/EwanValentine/shippy-service-consignment/proto/consignment" micro "github.com/micro/go-micro" ) const ( address = "localhost:50051" defaultFilename = "consignment.json" ) func parseFile(file string) (*pb.Consignment, error) { var consignment *pb.Consignment data, err := ioutil.ReadFile(file) if err != nil { return nil, err } json.Unmarshal(data, &consignment) return consignment, err } func main() { service := micro.NewService(micro.Name("shippy.cli.consignment")) service.Init() client := pb.NewShippingServiceClient("shippy.service.consignment", service.Client()) // Contact the server and print out its response. file := defaultFilename if len(os.Args) > 1 { file = os.Args[1] } consignment, err := parseFile(file) if err != nil { log.Fatalf("Could not parse file: %v", err) } r, err := client.CreateConsignment(context.Background(), consignment) if err != nil { log.Fatalf("Could not greet: %v", err) } log.Printf("Created: %t", r.Created) getAll, err := client.GetConsignments(context.Background(), &pb.GetRequest{}) if err != nil { log.Fatalf("Could not list consignments: %v", err) } for _, v := range getAll.Consignments { log.Println(v) } }

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

हालाँकि, यदि आप इसे चलाते हैं, तो यह काम नहीं करेगा। ऐसा इसलिए है क्योंकि हम अब डॉकटर कंटेनर में अपनी सेवा शुरू कर रहे हैं, जिसके अपने स्वयं के mdns हैं, जो mdns होस्ट से अलग हैं जिसे हम वर्तमान में उपयोग कर रहे हैं। इसे ठीक करने का सबसे आसान तरीका यह सुनिश्चित करना है कि सेवा और ग्राहक दोनों डॉकलैंड में चल रहे हैं, ताकि वे दोनों एक ही मेजबान पर काम करें और एक ही नेटवर्क परत का उपयोग करें। तो, चलिए बनाते हैं कंसाइनमेंट-क्ली / मेकफाइल और कुछ प्रविष्टियाँ बनाते हैं।

 build: GOOS=linux GOARCH=amd64 go build docker build -t shippy-cli-consignment . run: docker run shippy-cli-consignment

पहले की तरह, हम लिनक्स के लिए अपना बाइनरी बनाना चाहते हैं। जब हम अपनी डॉक छवि को लॉन्च करते हैं, तो हम mdns का उपयोग करने के लिए गो-माइक्रो कमांड देने के लिए एक पर्यावरण चर को पास करना चाहते हैं।

अब हमारे CLI टूल के लिए Dockerfile बनाते हैं:

 FROM alpine:latest RUN mkdir -p /app WORKDIR /app ADD consignment.json /app/consignment.json ADD consignment-cli /app/consignment-cli CMD ["./shippy-cli-consignment"]

यह हमारी सेवा Dockerfile से बहुत मिलती-जुलती है, सिवाय इसके कि यह हमारी json डेटा फ़ाइल को भी निकालती है।

अब जब आप $ $ मेक रन करते हैं, तो अपने शिप्पी-क्ली-कंसाइनमेंट में, आपको पहले जैसा ही बना हुआ देखना चाहिए।

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

यह हमारे मामले में विशेष रूप से उपयोगी है, क्योंकि हम अपनी बाइनरी फ़ाइल को सभी सही निर्भरताओं के साथ बनाने के लिए एक छवि का उपयोग कर सकते हैं। और फिर इसे लॉन्च करने के लिए दूसरी छवि का उपयोग करें। चलो यह कोशिश करते हैं, मैं कोड के साथ विस्तृत टिप्पणी छोड़ दूंगा:

खेप-सेवा / Dockerfile

 # consignment-service/Dockerfile #     golang,    #     .    `as builder`, #     ,      . FROM golang:alpine as builder RUN apk --no-cache add git #         gopath WORKDIR /app/shippy-service-consignment #       COPY . . RUN go mod download #     ,   #       Alpine. RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o shippy-service-consignment #      FROM, #   Docker        . FROM alpine:latest # ,    -     RUN apk --no-cache add ca-certificates #   ,     . RUN mkdir /app WORKDIR /app #   ,       , #         `builder` #       , #    ,    , #      . ! COPY --from=builder /app/shippy-service-consignment/shippy-service-consignment . #     !        #        # run time . CMD ["./shippy-service-consignment"]

अब मैं अन्य डॉकर फाइलों की ओर बढ़ूंगा और इस नए दृष्टिकोण को अपनाऊंगा। ओह, और अपने Makefiles से $ जाओ निर्माण को हटाने के लिए मत भूलना!

जहाज की सेवा

आइए दूसरी सेवा बनाएं। हमारे पास एक सेवा (शिप्पी-सेवा-खेप) है, जो जहाज के साथ कंटेनरों के बैच के समन्वय से संबंधित है, जो इस बैच के लिए सबसे उपयुक्त है। हमारे बैच से मेल खाने के लिए, हमें अपनी नई जहाज सेवा में कंटेनरों का वजन और संख्या भेजनी होगी, जो बाद में इस बैच को संभालने में सक्षम एक जहाज का पता लगाएंगे।

अपने $ mkdir पोत-सेवा रूट निर्देशिका में एक नई निर्देशिका बनाएं, अब हमारी नई प्रोटोबॉफ़ सेवाओं की परिभाषा, $ mkdir -p shippy-service-port / proto / पोत के लिए एक उपनिर्देशिका बनाएँ। अब एक नई प्रोटोबॉफ़ फ़ाइल बनाते हैं, $ टच शिप्पी-सर्विस-पोत / प्रोटो / पोत / पोत.प्रोटो ।

चूंकि प्रोटोबुफ़ की परिभाषा वास्तव में हमारे सॉफ़्टवेयर डिज़ाइन का मूल है, इसलिए इसके साथ शुरू करें।

पोत / पोत ।proto

 // shippy-service-vessel/proto/vessel/vessel.proto syntax = "proto3"; package vessel; service VesselService { rpc FindAvailable(Specification) returns (Response) {} } message Vessel { string id = 1; int32 capacity = 2; int32 max_weight = 3; string name = 4; bool available = 5; string owner_id = 6; } message Specification { int32 capacity = 1; int32 max_weight = 2; } message Response { Vessel vessel = 1; repeated Vessel vessels = 2; }

जैसा कि आप देख सकते हैं, यह हमारी पहली सेवा के समान है। हम FindAvailable नामक एक आरपीसी पद्धति के साथ एक सेवा बनाते हैं। यह एक प्रकार की विशिष्टता लेता है और एक प्रकार की प्रतिक्रिया देता है। रिस्पांस प्रकार एक दोहराव क्षेत्र का उपयोग करके या तो वेसल प्रकार या कई जहाजों को लौटाता है।

अब हमें अपने बिल्ड लॉजिक और हमारी स्टार्टअप स्क्रिप्ट को संभालने के लिए एक मेकफाइल बनाने की आवश्यकता है। $ स्पर्श शिप्पी-सेवा-पोत / मेकफाइल । इस फ़ाइल को खोलें और निम्नलिखित जोड़ें:

 // vessel-service/Makefile build: protoc -I. --go_out=plugins=micro:. \ proto/vessel/vessel.proto docker build -t shippy-service-vessel . run: docker run -p 50052:50051 -e MICRO_SERVER_ADDRESS=:50051 shippy-service-vessel

यह हमारी कंसाइनमेंट सेवा के लिए बनाए गए पहले मेकफाइल के समान है, हालांकि ध्यान दें कि सेवाओं और बंदरगाहों के नाम थोड़ा बदल गए हैं। हम एक ही पोर्ट पर दो डॉक कंटेनर लॉन्च नहीं कर सकते हैं, इसलिए हम डॉकर्स पोर्ट का उपयोग करते हैं ताकि यह सेवा मेजबान नेटवर्क पर 50051 से 50052 तक रीडायरेक्ट हो जाए।

अब हमें अपने नए बहु-मंच प्रारूप का उपयोग करके डॉकफाइल की आवश्यकता है:

 # vessel-service/Dockerfile FROM golang:alpine as builder RUN apk --no-cache add git WORKDIR /app/shippy-service-vessel COPY . . RUN go mod download RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o shippy-service-vessel FROM alpine:latest RUN apk --no-cache add ca-certificates RUN mkdir /app WORKDIR /app COPY --from=builder /app/shippy-service-vessel . CMD ["./shippy-service-vessel"]

अंत में, हम अपना कार्यान्वयन लिख सकते हैं:

पोत-सेवा / main.go

 // vessel-service/main.go package main import ( "context" "errors" "fmt" pb "github.com/EwanValentine/shippy/vessel-service/proto/vessel" "github.com/micro/go-micro" ) type Repository interface { FindAvailable(*pb.Specification) (*pb.Vessel, error) } type VesselRepository struct { vessels []*pb.Vessel } // FindAvailable -     , //           , //      . func (repo *VesselRepository) FindAvailable(spec *pb.Specification) (*pb.Vessel, error) { for _, vessel := range repo.vessels { if spec.Capacity <= vessel.Capacity && spec.MaxWeight <= vessel.MaxWeight { return vessel, nil } } //     return nil, errors.New("     ") } //    grpc type service struct { repo repository } func (s *service) FindAvailable(ctx context.Context, req *pb.Specification, res *pb.Response) error { //     vessel, err := s.repo.FindAvailable(req) if err != nil { return err } //       res.Vessel = vessel return nil } func main() { vessels := []*pb.Vessel{ &pb.Vessel{Id: "vessel001", Name: "Boaty McBoatface", MaxWeight: 200000, Capacity: 500}, } repo := &VesselRepository{vessels} srv := micro.NewService( micro.Name("shippy.service.vessel"), ) srv.Init() //    pb.RegisterVesselServiceHandler(srv.Server(), &service{repo}) if err := srv.Run(); err != nil { fmt.Println(err) } }

अब दिलचस्प भाग पर चलते हैं। जब हम एक खेप बनाते हैं, तो हमें जहाज खोज सेवा से संपर्क करने, जहाज खोजने और निर्मित खेप में शिप_ड पैरामीटर को अपडेट करने के लिए अपनी कार्गो हैंडलिंग सेवा को बदलने की आवश्यकता होती है:

shippy / खेप-सेवा / main.go

 package main import ( "context" "fmt" "log" "sync" pb "github.com/EwanValentine/shippy-service-consignment/proto/consignment" vesselProto "github.com/EwanValentine/shippy-service-vessel/proto/vessel" "github.com/micro/go-micro" ) const ( port = ":50051" ) type repository interface { Create(*pb.Consignment) (*pb.Consignment, error) GetAll() []*pb.Consignment } // Repository -    , //       type Repository struct { mu sync.RWMutex consignments []*pb.Consignment } //Create -     func (repo *Repository) Create(consignment *pb.Consignment) (*pb.Consignment, error) { repo.mu.Lock() updated := append(repo.consignments, consignment) repo.consignments = updated repo.mu.Unlock() return consignment, nil } //GetAll -       func (repo *Repository) GetAll() []*pb.Consignment { return repo.consignments } //         //       proto. //            type service struct { repo repository vesselClient vesselProto.VesselServiceClient } // CreateConsignment -         create, //     ,     gRPC. func (s *service) CreateConsignment(ctx context.Context, req *pb.Consignment, res *pb.Response) error { //         , //    vesselResponse, err := s.vesselClient.FindAvailable(context.Background(), &vesselProto.Specification{ MaxWeight: req.Weight, Capacity: int32(len(req.Containers)), }) log.Printf(" : %s \n", vesselResponse.Vessel.Name) if err != nil { return err } //     id  req.VesselId = vesselResponse.Vessel.Id //      consignment, err := s.repo.Create(req) if err != nil { return err } res.Created = true res.Consignment = consignment return nil } // GetConsignments -         func (s *service) GetConsignments(ctx context.Context, req *pb.GetRequest, res *pb.Response) error { consignments := s.repo.GetAll() res.Consignments = consignments return nil } func main() { //   repo := &Repository{} //  micro srv := micro.NewService( micro.Name("shippy.service.consignment"), ) srv.Init() vesselClient := vesselProto.NewVesselServiceClient("shippy.service.vessel", srv.Client()) //      gRPC. pb.RegisterShippingServiceHandler(srv.Server(), &service{repo, vesselClient}) //   if err := srv.Run(); err != nil { fmt.Println(err) } }

यहां हमने अपनी जहाज सेवा के लिए एक ग्राहक उदाहरण बनाया, जो हमें सेवा नाम का उपयोग करने की अनुमति देता है, अर्थात। shipy.service.vessel एक ग्राहक के रूप में जहाज की सेवा को कॉल करने और उसके तरीकों के साथ बातचीत करने के लिए।इस मामले में, केवल एक विधि (FindAvailable)। हम जहाज के सेवा के लिए विनिर्देशन के रूप में कंटेनर की संख्या के साथ बैच वजन को जोड़ते हैं। जो हमें इस विनिर्देशन के अनुरूप पोत लौटाता है।

खेप-क्ली / consignment.json फ़ाइल को अपडेट करें, हार्ड-कोडेड जहाज_आईडी को हटाएं, क्योंकि हम पुष्टि करना चाहते हैं कि हमारी जहाज खोज सेवा काम कर रही है। इसके अलावा, चलो कुछ और कंटेनरों को जोड़ते हैं और वजन बढ़ाते हैं। उदाहरण के लिए:

 { "description": "  ", "weight": 55000, "containers": [ { "customer_id": "_001", "user_id": "_001", "origin": "--" }, { "customer_id": "_002", "user_id": "_001", "origin": "" }, { "customer_id": "_003", "user_id": "_001", "origin": "" } ] }

अब कंसाइनमेंट-क्ली में $ मेक बिल्ड && मेक रन चलाएं । आपको बनाए गए सामानों की सूची के साथ एक उत्तर देखना चाहिए। अपनी पार्टियों में, आपको यह देखना चाहिए कि बर्तन_आईडी पैरामीटर सेट है।

तो, हमारे पास दो इंटरकनेक्टेड माइक्रोसर्विसेज और एक कमांड लाइन इंटरफ़ेस है!
इस श्रृंखला के अगले भाग में, हम MongoDB का उपयोग करके इस डेटा को सहेजने पर विचार करेंगे। हम एक तीसरी सेवा भी जोड़ेंगे और हमारे बढ़ते कंटेनर पारिस्थितिकी तंत्र को स्थानीय रूप से प्रबंधित करने के लिए डॉक-कंपोज़ का उपयोग करेंगे।

भाग I
मूल इवानवैलेंटाइन रिपोजिटरी

गोलंग और gRPC पर एक माइक्रोसैकेयर आर्किटेक्चर का निर्माण, भाग 2 (docker)

यह कंटेनरों से निपटने का समय है

माइक्रो जाओ

जहाज की सेवा

More articles: