गो किट के साथ गो ऑन माइक्रोसर्विसेस: परिचय

इस लेख में मैं गो किट का उपयोग, गो पर सूक्ष्म सेवाओं के निर्माण के लिए उपकरणों और पुस्तकालयों के एक सेट का वर्णन करूंगा। यह लेख गो किट का परिचायक है। मेरे ब्लॉग पर पहला भाग, उदाहरणों के लिए स्रोत कोड यहां उपलब्ध है ।

आधुनिक वितरित प्रणालियों के विकास के लिए गो को तेजी से चुना गया है। जब आप क्लाउड-आधारित वितरित प्रणाली विकसित कर रहे हैं, तो आपको अपनी सेवाओं में विभिन्न विशिष्ट कार्यक्षमता का समर्थन करने की आवश्यकता हो सकती है, जैसे: विभिन्न परिवहन प्रोटोकॉल ( आदि। अनुवाद HTTP, gRPC, आदि ) और उनके लिए संदेश एन्कोडिंग प्रारूप, RPC विश्वसनीयता, लॉगिंग। , अनुरेखण, मैट्रिक्स और प्रोफाइलिंग, अनुरोधों को बाधित करना, अनुरोधों की संख्या को सीमित करना, बुनियादी ढांचे में एकीकरण और यहां तक ​​कि वास्तुकला का वर्णन करना। गो अपनी सादगी और "कोई जादू" दृष्टिकोण के कारण एक लोकप्रिय भाषा है, इसलिए गो संकुल, उदाहरण के लिए, एक मानक पुस्तकालय, पहले से ही वितरित सिस्टम को विकसित करने के लिए अधिक उपयुक्त है, जिसमें "हुड के नीचे जादू" के साथ पूर्ण विकसित फ्रेमवर्क का उपयोग किया गया है। व्यक्तिगत रूप से, मैं [ लगभग। प्रति। शिजू वर्गीस ] मैं पूर्ण विकसित ढांचे के उपयोग का समर्थन नहीं करता, मैं पुस्तकालयों का उपयोग करना पसंद करता हूं जो डेवलपर को अधिक स्वतंत्रता देते हैं। गो किट ने गो इकोसिस्टम में गैप को भर दिया, जिससे माइक्रोसिस्टर्स बनाते समय लाइब्रेरी और पैकेज के सेट का उपयोग करना संभव हो गया, जो बदले में वितरित सिस्टम में व्यक्तिगत सेवाओं के डिजाइन के लिए अच्छे सिद्धांतों के उपयोग की अनुमति देता है।

गो किट का परिचय

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

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

आर्किटेक्चर गो किट

गो किट का उपयोग करके विकसित किए गए अनुप्रयोगों की वास्तुकला में तीन मुख्य स्तर हैं:

• परिवहन स्तर
• समापन बिंदु स्तर
• सेवा स्तर

परिवहन स्तर

जब आप वितरित सिस्टम के लिए माइक्रोसॉफ़्ट लिखते हैं, तो उनमें सेवाओं को अक्सर विभिन्न परिवहन प्रोटोकॉल का उपयोग करके एक दूसरे के साथ संवाद करना पड़ता है, जैसे: HTTP या gRPC, या NAT / जैसे पब / उप सिस्टम का उपयोग करना। गो किट में परिवहन परत एक विशिष्ट परिवहन प्रोटोकॉल (इसके बाद परिवहन) से जुड़ी है। गो किट आपकी सेवा के लिए विभिन्न परिवहन का समर्थन करती है, जैसे: HTTP, gRPC, NATS, AMQP और थिरफ़्ट ( लगभग। आप अपने प्रोटोकॉल के लिए अपना परिवहन भी विकसित कर सकते हैं )। इसलिए, गो किट का उपयोग करते हुए लिखी जाने वाली सेवाएं अक्सर विशिष्ट व्यवसाय तर्क के कार्यान्वयन पर ध्यान केंद्रित करती हैं जो कि उपयोग किए गए परिवहन के बारे में कुछ भी नहीं जानती हैं, आप एक ही सेवा के लिए विभिन्न परिवहन का उपयोग करने के लिए स्वतंत्र हैं। एक उदाहरण के रूप में, गो किट में लिखी गई एक सेवा HTTP और gRPC के माध्यम से एक साथ इस तक पहुँच प्रदान कर सकती है।

Endpointy

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

सेवाएं

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

उदाहरण

और अब एक सरल अनुप्रयोग के उदाहरण का उपयोग करके ऊपर वर्णित परतों को देखें।

सेवा में व्यावसायिक तर्क

सेवा में व्यावसायिक तर्क इंटरफेस का उपयोग करके बनाया गया है। हम ई-कॉमर्स में एक आदेश का एक उदाहरण देखेंगे:

// Service describes the Order service. type Service interface { Create(ctx context.Context, order Order) (string, error) GetByID(ctx context.Context, id string) (Order, error) ChangeStatus(ctx context.Context, id string, status string) error } 

ऑर्डर सेवा इंटरफ़ेस ऑर्डर डोमेन इकाई के साथ काम करता है:

 // Order represents an order type Order struct { ID string `json:"id,omitempty"` CustomerID string `json:"customer_id"` Status string `json:"status"` CreatedOn int64 `json:"created_on,omitempty"` RestaurantId string `json:"restaurant_id"` OrderItems []OrderItem `json:"order_items,omitempty"` } // OrderItem represents items in an order type OrderItem struct { ProductCode string `json:"product_code"` Name string `json:"name"` UnitPrice float32 `json:"unit_price"` Quantity int32 `json:"quantity"` } // Repository describes the persistence on order model type Repository interface { CreateOrder(ctx context.Context, order Order) error GetOrderByID(ctx context.Context, id string) (Order, error) ChangeOrderStatus(ctx context.Context, id string, status string) error } 

यहाँ हम आदेश सेवा के इंटरफ़ेस को लागू करते हैं:

 package implementation import ( "context" "database/sql" "time" "github.com/go-kit/kit/log" "github.com/go-kit/kit/log/level" "github.com/gofrs/uuid" ordersvc "github.com/shijuvar/gokit-examples/services/order" ) // service implements the Order Service type service struct { repository ordersvc.Repository logger log.Logger } // NewService creates and returns a new Order service instance func NewService(rep ordersvc.Repository, logger log.Logger) ordersvc.Service { return &service{ repository: rep, logger: logger, } } // Create makes an order func (s *service) Create(ctx context.Context, order ordersvc.Order) (string, error) { logger := log.With(s.logger, "method", "Create") uuid, _ := uuid.NewV4() id := uuid.String() order.ID = id order.Status = "Pending" order.CreatedOn = time.Now().Unix() if err := s.repository.CreateOrder(ctx, order); err != nil { level.Error(logger).Log("err", err) return "", ordersvc.ErrCmdRepository } return id, nil } // GetByID returns an order given by id func (s *service) GetByID(ctx context.Context, id string) (ordersvc.Order, error) { logger := log.With(s.logger, "method", "GetByID") order, err := s.repository.GetOrderByID(ctx, id) if err != nil { level.Error(logger).Log("err", err) if err == sql.ErrNoRows { return order, ordersvc.ErrOrderNotFound } return order, ordersvc.ErrQueryRepository } return order, nil } // ChangeStatus changes the status of an order func (s *service) ChangeStatus(ctx context.Context, id string, status string) error { logger := log.With(s.logger, "method", "ChangeStatus") if err := s.repository.ChangeOrderStatus(ctx, id, status); err != nil { level.Error(logger).Log("err", err) return ordersvc.ErrCmdRepository } return nil } 

आरपीसी एंडपॉइंट्स के लिए अनुरोध और उत्तर

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

 // CreateRequest holds the request parameters for the Create method. type CreateRequest struct { Order order.Order } // CreateResponse holds the response values for the Create method. type CreateResponse struct { ID string `json:"id"` Err error `json:"error,omitempty"` } // GetByIDRequest holds the request parameters for the GetByID method. type GetByIDRequest struct { ID string } // GetByIDResponse holds the response values for the GetByID method. type GetByIDResponse struct { Order order.Order `json:"order"` Err error `json:"error,omitempty"` } // ChangeStatusRequest holds the request parameters for the ChangeStatus method. type ChangeStatusRequest struct { ID string `json:"id"` Status string `json:"status"` } // ChangeStatusResponse holds the response values for the ChangeStatus method. type ChangeStatusResponse struct { Err error `json:"error,omitempty"` } 

आरपीसी एंडपॉइंट जैसी सेवा विधियों के लिए गो किट एंडपॉइंट्स

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

यहाँ गो किट से समापन बिंदु है:

 type Endpoint func(ctx context.Context, request interface{}) (response interface{}, err error) 

जैसा कि हमने ऊपर कहा, एंडपॉइंट एक अलग आरपीसी विधि का प्रतिनिधित्व करता है। प्रत्येक सेवा पद्धति को endpoint.Endpoint परिवर्तित किया जाता है। एडेप्टर का उपयोग करके। आइये जाने गो किट एंडपॉइंट्स फॉर ऑर्डर सर्विस मेथड:

 import ( "context" "github.com/go-kit/kit/endpoint" "github.com/shijuvar/gokit-examples/services/order" ) // Endpoints holds all Go kit endpoints for the Order service. type Endpoints struct { Create endpoint.Endpoint GetByID endpoint.Endpoint ChangeStatus endpoint.Endpoint } // MakeEndpoints initializes all Go kit endpoints for the Order service. func MakeEndpoints(s order.Service) Endpoints { return Endpoints{ Create: makeCreateEndpoint(s), GetByID: makeGetByIDEndpoint(s), ChangeStatus: makeChangeStatusEndpoint(s), } } func makeCreateEndpoint(s order.Service) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (interface{}, error) { req := request.(CreateRequest) id, err := s.Create(ctx, req.Order) return CreateResponse{ID: id, Err: err}, nil } } func makeGetByIDEndpoint(s order.Service) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (interface{}, error) { req := request.(GetByIDRequest) orderRes, err := s.GetByID(ctx, req.ID) return GetByIDResponse{Order: orderRes, Err: err}, nil } } func makeChangeStatusEndpoint(s order.Service) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (interface{}, error) { req := request.(ChangeStatusRequest) err := s.ChangeStatus(ctx, req.ID, req.Status) return ChangeStatusResponse{Err: err}, nil } } 

समापन बिंदु एडाप्टर इंटरफ़ेस को इनपुट के एक पैरामीटर के रूप में स्वीकार करता है और इसे एक अमूर्त गो किट endpoint.Enpoint में परिवर्तित करता है। प्रत्येक व्यक्ति सेवा पद्धति को एक समापन बिंदु बना रहा है। यह एडॉप्टर फ़ंक्शन तुलना करता है और अनुरोधों के लिए रूपांतरण टाइप करता है, सेवा पद्धति को कॉल करता है और प्रतिक्रिया संदेश देता है।

 func makeCreateEndpoint(s order.Service) endpoint.Endpoint { return func(ctx context.Context, request interface{}) (interface{}, error) { req := request.(CreateRequest) id, err := s.Create(ctx, req.Order) return CreateResponse{ID: id, Err: err}, nil } } 

HTTP का उपयोग करते हुए एक सेवा का प्रदर्शन

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

एक उदाहरण के लिए, हम अपनी सेवा के लिए HTTP परिवहन का उपयोग करते हैं। गो किट पैकेज github.com/go-kit/kit/transport/http HTTP अनुरोधों की सेवा करने की क्षमता प्रदान करता है। और transport/http पैकेज से NewServer फ़ंक्शन एक नया http सर्वर बनाएगा जो http.Handler को लागू http.Handler और प्रदान किए गए समापन बिंदुओं को लपेटता है।

नीचे वह कोड है जो गो किट एंडपॉइंट को एक HTTP ट्रांसपोर्ट में कनवर्ट करता है जो HTTP रिक्वेस्ट परोसता है:

 package http import ( "context" "encoding/json" "errors" "github.com/shijuvar/gokit-examples/services/order" "net/http" "github.com/go-kit/kit/log" kithttp "github.com/go-kit/kit/transport/http" "github.com/gorilla/mux" "github.com/shijuvar/gokit-examples/services/order/transport" ) var ( ErrBadRouting = errors.New("bad routing") ) // NewService wires Go kit endpoints to the HTTP transport. func NewService( svcEndpoints transport.Endpoints, logger log.Logger, ) http.Handler { // set-up router and initialize http endpoints r := mux.NewRouter() options := []kithttp.ServerOption{ kithttp.ServerErrorLogger(logger), kithttp.ServerErrorEncoder(encodeError), } // HTTP Post - /orders r.Methods("POST").Path("/orders").Handler(kithttp.NewServer( svcEndpoints.Create, decodeCreateRequest, encodeResponse, options..., )) // HTTP Post - /orders/{id} r.Methods("GET").Path("/orders/{id}").Handler(kithttp.NewServer( svcEndpoints.GetByID, decodeGetByIDRequest, encodeResponse, options..., )) // HTTP Post - /orders/status r.Methods("POST").Path("/orders/status").Handler(kithttp.NewServer( svcEndpoints.ChangeStatus, decodeChangeStausRequest, encodeResponse, options..., )) return r } func decodeCreateRequest(_ context.Context, r *http.Request) (request interface{}, err error) { var req transport.CreateRequest if e := json.NewDecoder(r.Body).Decode(&req.Order); e != nil { return nil, e } return req, nil } func decodeGetByIDRequest(_ context.Context, r *http.Request) (request interface{}, err error) { vars := mux.Vars(r) id, ok := vars["id"] if !ok { return nil, ErrBadRouting } return transport.GetByIDRequest{ID: id}, nil } func decodeChangeStausRequest(_ context.Context, r *http.Request) (request interface{}, err error) { var req transport.ChangeStatusRequest if e := json.NewDecoder(r.Body).Decode(&req); e != nil { return nil, e } return req, nil } func encodeResponse(ctx context.Context, w http.ResponseWriter, response interface{}) error { if e, ok := response.(errorer); ok && e.error() != nil { // Not a Go kit transport error, but a business-logic error. // Provide those as HTTP errors. encodeError(ctx, e.error(), w) return nil } w.Header().Set("Content-Type", "application/json; charset=utf-8") return json.NewEncoder(w).Encode(response) } 

हम transport/http पैकेज से NewServer फ़ंक्शन का उपयोग करके http.Handler बनाते हैं, जो हमें एंडपॉइंट और अनुरोध डिकोडिंग फ़ंक्शंस ( type DecodeRequestFunc func ) का मान प्रदान करता है और एन्कोडिंग एन्कोडिंग (उदा। type EncodeReponseFunc func )।

निम्नलिखित DecodeRequestFunc और EncodeResponseFunc उदाहरण हैं:

 // For decoding request type DecodeRequestFunc func(context.Context, *http.Request) (request interface{}, err error) 

 // For encoding response type EncodeResponseFunc func(context.Context, http.ResponseWriter, interface{}) error 

HTTP सर्वर शुरू करना

अंत में, हम अनुरोधों को संसाधित करने के लिए अपना HTTP सर्वर चला सकते हैं। ऊपर वर्णित NewService फ़ंक्शन http.Handler इंटरफ़ेस को लागू करता है http.Handler जो हमें इसे HTTP सर्वर के रूप में चलाने की अनुमति देता है:

 func main() { var ( httpAddr = flag.String("http.addr", ":8080", "HTTP listen address") ) flag.Parse() var logger log.Logger { logger = log.NewLogfmtLogger(os.Stderr) logger = log.NewSyncLogger(logger) logger = level.NewFilter(logger, level.AllowDebug()) logger = log.With(logger, "svc", "order", "ts", log.DefaultTimestampUTC, "caller", log.DefaultCaller, ) } level.Info(logger).Log("msg", "service started") defer level.Info(logger).Log("msg", "service ended") var db *sql.DB { var err error // Connect to the "ordersdb" database db, err = sql.Open("postgres", "postgresql://shijuvar@localhost:26257/ordersdb?sslmode=disable") if err != nil { level.Error(logger).Log("exit", err) os.Exit(-1) } } // Create Order Service var svc order.Service { repository, err := cockroachdb.New(db, logger) if err != nil { level.Error(logger).Log("exit", err) os.Exit(-1) } svc = ordersvc.NewService(repository, logger) } var h http.Handler { endpoints := transport.MakeEndpoints(svc) h = httptransport.NewService(endpoints, logger) } errs := make(chan error) go func() { c := make(chan os.Signal) signal.Notify(c, syscall.SIGINT, syscall.SIGTERM) errs <- fmt.Errorf("%s", <-c) }() go func() { level.Info(logger).Log("transport", "HTTP", "addr", *httpAddr) server := &http.Server{ Addr: *httpAddr, Handler: h, } errs <- server.ListenAndServe() }() level.Error(logger).Log("exit", <-errs) } 

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

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

स्रोत कोड

उदाहरणों के लिए संपूर्ण स्रोत कोड यहाँ GitHub पर देखा जा सकता है।

गो किट में मध्यवर्ग

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

नीचे गो किट वेबसाइट की एक तस्वीर है, जिसे गो किट में मध्यवर्तियों का उपयोग करते हुए एक विशिष्ट "प्याज वास्तुकला" के रूप में दर्शाया गया है:

स्प्रिंग बूट माइक्रोसर्विसेज सिंड्रोम से सावधान रहें

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

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

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

पुनश्च

अनुवाद का लेखक मूल पाठ के लेखक की राय को साझा नहीं कर सकता है, इस लेख को केवल रूसी रूसी समुदाय के लिए शैक्षिक उद्देश्यों के लिए अनुवादित किया गया है।

युपीडी
यह अनुवाद अनुभाग का पहला लेख भी है और मैं अनुवाद पर किसी भी प्रतिक्रिया के लिए आभारी रहूंगा।