गो एप्लिकेशन के लिए मेकफाइल बनाने का एक उदाहरण

इस ट्यूटोरियल में, हम देखेंगे कि कैसे गो डेवलपर अपने स्वयं के अनुप्रयोगों को विकसित करने के लिए मेकफाइल का उपयोग कर सकता है।

Makefiles क्या हैं?

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

इसे अक्सर Github और Gitlab पर कई गो ऐप की रूट डायरेक्टरी में देखा जा सकता है। यह व्यापक रूप से डेवलपर्स के साथ काम करने वाले कार्यों को स्वचालित करने के लिए एक उपकरण के रूप में उपयोग किया जाता है।

यदि आप वेब सेवाओं को बनाने के लिए Go का उपयोग करते हैं, तो मेकफाइल निम्नलिखित कार्यों को हल करने में मदद करेगा:

• सरल आदेशों के आह्वान को स्वचालित करें, जैसे: संकलन, प्रारंभ, रोक, घड़ी, आदि।
• प्रोजेक्ट-विशिष्ट वातावरण चर प्रबंधित करें। इसमें .env फ़ाइल शामिल होनी चाहिए।
• एक विकास मोड जो स्वचालित रूप से परिवर्तन पर संकलित करता है।
• एक विकास मोड जो संकलन त्रुटियों को दर्शाता है।
• एक विशिष्ट परियोजना के लिए GOPATH को परिभाषित करना ताकि हम विक्रेता फ़ोल्डर में निर्भरता को स्टोर कर सकें।
• उदाहरण के लिए सरलीकृत फ़ाइल मॉनिटरिंग, वॉच रन बनाना = "परीक्षण जाना"। / ... "

यहाँ एक परियोजना के लिए एक विशिष्ट निर्देशिका संरचना है:

.env Makefile main.go bin/ src/ vendor/ 

यदि हम इस निर्देशिका में मेक कमांड कहते हैं, तो हमें निम्न आउटपुट मिलते हैं:

 $ make Choose a command run in my-web-server: install Install missing dependencies. Runs `go get` internally. start Start in development mode. Auto-starts when code changes. stop Stop development mode. compile Compile the binary. watch Run given command when code changes. eg; make watch run="go test ./..." exec Run given command, wrapped with custom GOPATH. eg; make exec run="go test ./..." clean Clean build files. Runs `go clean` internally. 

पर्यावरण चर

पहली बात जो हम मेकफाइल से चाहते हैं, वह है पर्यावरण वैरिएबल को शामिल करना जिसे हमने प्रोजेक्ट के लिए परिभाषित किया था। इसलिए, पहली पंक्ति इस तरह दिखाई देगी:

 include .env 

अगला, हम प्रोजेक्ट नाम को परिभाषित करते हैं, फ़ोल्डर / फ़ाइलें, पथ पर जाएँ ...

 PROJECTNAME=$(shell basename "$(PWD)") # Go . GOBASE=$(shell pwd) GOPATH=$(GOBASE)/vendor:$(GOBASE):/home/azer/code/golang #       . GOBIN=$(GOBASE)/bin GOFILES=$(wildcard *.go) #     ,       . STDERR=/tmp/.$(PROJECTNAME)-stderr.txt # PID-    ,       PID=/tmp/.$(PROJECTNAME)-api-server.pid # Make     Linux.   silent. MAKEFLAGS += --silent 

Makefile के शेष भाग में, हम अक्सर GOPATH चर का उपयोग करेंगे। हमारी सभी टीमों को एक विशिष्ट परियोजना के GOPATH के साथ संबद्ध होना चाहिए, अन्यथा वे काम नहीं करेंगे। यह हमारी परियोजनाओं को एक स्वच्छ अलगाव प्रदान करता है, लेकिन एक ही समय में काम को जटिल करता है। कार्य को सरल बनाने के लिए, हम एक निष्पादन कमांड जोड़ सकते हैं जो हमारे GOPATH के साथ किसी भी कमांड को निष्पादित करेगा।

 # exec:     GOPATH. : make exec run = " go test ./...” exec: @GOPATH=$(GOPATH) GOBIN=$(GOBIN) $(run) 

हालांकि, यह याद रखने योग्य है कि आपको निष्पादन का उपयोग करने की आवश्यकता है यदि आप ऐसा कुछ करना चाहते हैं जो मेकफाइल में नहीं लिखा जा सकता है।

विकास मोड

विकास मोड चाहिए:

• कैश का निर्माण करें
• संकलन कोड
• सेवा को पृष्ठभूमि में चलाएं
• कोड बदलने पर इन चरणों को दोहराएं।

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

 start: bash -c "trap 'make stop' EXIT; $(MAKE) compile start-server watch run='make compile start-server'" stop: stop-server 

ऊपर वर्णित कोड निम्नलिखित कार्यों को हल करता है:

• संकलित करता है और पृष्ठभूमि में सेवा चलाता है।
• मुख्य प्रक्रिया पृष्ठभूमि में नहीं चलती है, इसलिए हम इसे नियंत्रण-सी का उपयोग करके बाधित कर सकते हैं।
• मुख्य प्रक्रिया बाधित होने पर पृष्ठभूमि की प्रक्रियाएं रुक जाती हैं। इसके लिए जाल की जरूरत है।
• कोड बदलने पर सर्वर को फिर से संकलित करता है और पुनः आरंभ करता है।

निम्नलिखित अनुभागों में, मैं इन आदेशों को और अधिक विस्तार से बताऊंगा।

संकलन

संकलित आदेश पृष्ठभूमि में केवल संकलित कॉल नहीं करता है - यह त्रुटि आउटपुट को साफ़ करता है और एक सरलीकृत संस्करण प्रिंट करता है।

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

 compile: @-touch $(STDERR) @-rm $(STDERR) @-$(MAKE) -s go-compile 2> $(STDERR) @cat $(STDERR) | sed -e '1s/.*/\nError:\n/' | sed 's/make\[.*/ /' | sed "/^/s/^/ /" 1>&2 

सर्वर प्रारंभ / बंद

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

 start-server: @echo " > $(PROJECTNAME) is available at $(ADDR)" @-$(GOBIN)/$(PROJECTNAME) 2>&1 & echo $$! > $(PID) @cat $(PID) | sed "/^/s/^/ \> PID: /" stop-server: @-touch $(PID) @-kill `cat $(PID)` 2> /dev/null || true @-rm $(PID) restart-server: stop-server start-server 

निगरानी बदलें

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

 $ go get github.com/azer/yolo 

स्थापना के बाद, हम विक्रेता और बिन फ़ोल्डर को छोड़कर, परियोजना निर्देशिका में परिवर्तन का निरीक्षण कर सकते हैं।

 ## watch:      ,  make watch run="echo 'hey'" watch: @yolo -i . -e vendor -e bin -c $(run) 

अब हमारे पास एक वॉच कमांड है, जो वेंडर डायरेक्टरी के अपवाद के साथ, प्रोजेक्ट डायरेक्टरी में बदलावों की पुनरावृत्ति करता है। हम बस चलाने के लिए कोई भी आदेश पारित कर सकते हैं।
उदाहरण के लिए, कोड बदलने पर कॉल मेक-स्टार्ट-सर्वर शुरू करें:

 make watch run="make compile start-server" 

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

 make watch run="go test ./..." 

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

 yolo -i . -e vendor -e bin -c "go run foobar.go" -a localhost:9001 

किसी ब्राउज़र में लोकलहोस्ट: 9001 खोलें और तुरंत काम का परिणाम देखें:

निर्भरता स्थापना

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

 install: go-get 

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

 make install get="github.com/foo/bar" 

आंतरिक रूप से, इस कमांड को निम्न में बदल दिया जाएगा:

 $ GOPATH=~/my-web-server GOBIN=~/my-web-server/bin go get github.com/foo/bar 

यह कैसे काम करता है? अगला भाग देखें जहां हम उच्च स्तर के आदेशों को लागू करने के लिए नियमित गो कमांड जोड़ते हैं।

जाओ कमांड्स

चूँकि हम निर्भरता प्रबंधन को आसान बनाने के लिए परियोजना निर्देशिका में GOPATH को स्थापित करना चाहते हैं, जिसे अभी तक गो पारिस्थितिकी तंत्र में आधिकारिक रूप से तय नहीं किया गया है, हमें Makefile में सभी गो कमांड को लपेटने की आवश्यकता है।

 go-compile: go-clean go-get go-build go-build: @echo " > Building binary..." @GOPATH=$(GOPATH) GOBIN=$(GOBIN) go build -o $(GOBIN)/$(PROJECTNAME) $(GOFILES) go-generate: @echo " > Generating dependency files..." @GOPATH=$(GOPATH) GOBIN=$(GOBIN) go generate $(generate) go-get: @echo " > Checking if there is any missing dependencies..." @GOPATH=$(GOPATH) GOBIN=$(GOBIN) go get $(get) go-install: @GOPATH=$(GOPATH) GOBIN=$(GOBIN) go install $(GOFILES) go-clean: @echo " > Cleaning build cache" @GOPATH=$(GOPATH) GOBIN=$(GOBIN) go clean 

सहायता

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

 help: Makefile @echo " Choose a command run in "$(PROJECTNAME)":" @sed -n 's/^##//p' $< | column -t -s ':' | sed -e 's/^/ /' 

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

यदि हम कुछ टिप्पणियां जोड़ते हैं:

 ## install: Install missing dependencies. Runs `go get` internally. install: go-get ## start: Start in development mode. Auto-starts when code changes. start: ## stop: Stop development mode. stop: stop-server 

हम प्राप्त करेंगे:

 $ make help Choose a command run in my-web-server: install Install missing dependencies. Runs `go get` internally. start Start in development mode. Auto-starts when code changes. stop Stop development mode. 

अंतिम संस्करण

 include .env PROJECTNAME=$(shell basename "$(PWD)") # Go related variables. GOBASE=$(shell pwd) GOPATH="$(GOBASE)/vendor:$(GOBASE)" GOBIN=$(GOBASE)/bin GOFILES=$(wildcard *.go) # Redirect error output to a file, so we can show it in development mode. STDERR=/tmp/.$(PROJECTNAME)-stderr.txt # PID file will keep the process id of the server PID=/tmp/.$(PROJECTNAME).pid # Make is verbose in Linux. Make it silent. MAKEFLAGS += --silent ## install: Install missing dependencies. Runs `go get` internally. eg; make install get=github.com/foo/bar install: go-get ## start: Start in development mode. Auto-starts when code changes. start: bash -c "trap 'make stop' EXIT; $(MAKE) compile start-server watch run='make compile start-server'" ## stop: Stop development mode. stop: stop-server start-server: stop-server @echo " > $(PROJECTNAME) is available at $(ADDR)" @-$(GOBIN)/$(PROJECTNAME) 2>&1 & echo $$! > $(PID) @cat $(PID) | sed "/^/s/^/ \> PID: /" stop-server: @-touch $(PID) @-kill `cat $(PID)` 2> /dev/null || true @-rm $(PID) ## watch: Run given command when code changes. eg; make watch run="echo 'hey'" watch: @GOPATH=$(GOPATH) GOBIN=$(GOBIN) yolo -i . -e vendor -e bin -c "$(run)" restart-server: stop-server start-server ## compile: Compile the binary. compile: @-touch $(STDERR) @-rm $(STDERR) @-$(MAKE) -s go-compile 2> $(STDERR) @cat $(STDERR) | sed -e '1s/.*/\nError:\n/' | sed 's/make\[.*/ /' | sed "/^/s/^/ /" 1>&2 ## exec: Run given command, wrapped with custom GOPATH. eg; make exec run="go test ./..." exec: @GOPATH=$(GOPATH) GOBIN=$(GOBIN) $(run) ## clean: Clean build files. Runs `go clean` internally. clean: @(MAKEFILE) go-clean go-compile: go-clean go-get go-build go-build: @echo " > Building binary..." @GOPATH=$(GOPATH) GOBIN=$(GOBIN) go build -o $(GOBIN)/$(PROJECTNAME) $(GOFILES) go-generate: @echo " > Generating dependency files..." @GOPATH=$(GOPATH) GOBIN=$(GOBIN) go generate $(generate) go-get: @echo " > Checking if there is any missing dependencies..." @GOPATH=$(GOPATH) GOBIN=$(GOBIN) go get $(get) go-install: @GOPATH=$(GOPATH) GOBIN=$(GOBIN) go install $(GOFILES) go-clean: @echo " > Cleaning build cache" @GOPATH=$(GOPATH) GOBIN=$(GOBIN) go clean .PHONY: help all: help help: Makefile @echo @echo " Choose a command run in "$(PROJECTNAME)":" @echo @sed -n 's/^##//p' $< | column -t -s ':' | sed -e 's/^/ /' @echo