Goஎன்பது ஒரு கட்டற்ற நிரலாக்க (கணினி)மொழியாகும், இது மிகவும் எளிய, நம்பகமான திறனுடைய மென்பொருட்களை (பயன்பாடுகளை) உருவாக்குவதை எளிதாக்குகிறது. இது மிகவும் செயல்திறன் மிக்க, எளிதாக தொகுக்கப்படக்கூடிய, சிறிய, பொருள் சார்ந்த, நிலையானவகை கணினி மெழியாகும். எளிய ஆனால் மிகத் திறனுடைய இணைய சேவையகங்களை உருவாக்குவதே இதனுடைய குறைந்தபட்ச குறிக்கோளாகும், இந்த கணினி மொழி வாயிலாக அவ்வாறான சேவையகங்களை நாம் ஒருசில நிமிடங்களிலேயே உருவாக்கி செயல்படுத்திடத் துவங்கலாம். மற்ற அனைத்து கணினி மொழிகளுடன் ஒப்பிடும்போது இதனுடைய செயல்திட்டங்களின் தொகுப்பு நேரமும் செயற்படுத்திடும் நேரமும் மிகவும் குறைவாகும். இது நிலையானதாக வகைபடுத்தப்ப் பட்ட கணினிமொழி என்பதால், பெரும்பாலான பிழைகள் உடனடியாக தொகுத்திடும் நேரத்திலேயே கண்டுபிடிக்கப்பட்டு சரிசெய்யப்படுகின்றன. இது முன்கூட்டியே கட்டமைக்கப்பட்ட ஒத்திசைவினையும் ஆதரவையும் கொண்டுள்ளது, இது அதன் குறிமுறைவரிகளை பல்வேறு சூழலிலும் இயங்கச் செய்கிறது. இதனுடைய வழக்கமான (இலகுரக செயல்முறை), channels , select statements ஆகிய கருத்தமைவுகள் பயனாளர்களுக்கு ஒரே நேரத்தில் நிரல்களை எளிதாக செயல்படுத்த உதவுகிறது மேலும் பல்லடுக்கு அமைப்பை அதிகபட்சமாகப் பயன்படுத்திகொள்கின்றது. நாம் ஒரு HTTP சேவையகத்தை உருவாக்குவதற்காக நமக்கு இதில் ஒரு இயந்திர மொழி மாற்றி , உரை / குறிமுறைவரிகளின் பதிப்பாளர் ஆகிய இரண்டு மட்டுமே தேவையாகும். அவ்வாறான இயந்திர மொழி மாற்றியை இதனுடைய அதிகாரப்பூர்வ மின்னனு விநியோகத்திலிருந்து பதிவிறக்கம் செய்யலாம், இது FreeBSD க்கான golang.org/dl/ எனும் இணையமுகவரியில் கிடைக்கிறது (இதனுடைய பதிப்பு10-நிலையானது ,அதனைவிடமேம்பட்ட வெளியீடு), லினக்ஸ், மேக் (10.11 அல்லது அதற்கு மேற்பட்டவை), விண்டோ இயக்கத்தில் 32-பிட் (386) , 64-பிட் (amd64) x86 செயலி கட்டமைப்புகளுக்கான அமைப்புகள். பதிவிறக்கம் செய்தவுவுடன்,இதனை நிறுவுகை செய்வதற்கான முழுமையான செயல்முறைகள் நிறுவுகையை பரிசோதிப்பது ஆகிய வழிமுறைவிவரங்களை golang.org/doc/install#install எனும் இணையமுகவரியில் அறிந்துகொள்ளலாம். இந்த செயல்திட்டம் இதனுடைய பிறசெயல்திட்டங்களில் சார்புகளை உள்ளடக்கியிருந்தால்,Go 1.13 முதல் இயல்புநிலை சார்பு மேலாண்மை அமைப்பிற்கு தேவைப்படும் தொகுப்புகளை பயன்படுத்தவேண்டும். இதனுடைய தொகுப்புகள் Go எனும் கட்டுகளின் தொகுப்பாகும், இது go.mod எனும் கோப்புடன் அதன் மூலகோப்பில் சேமிக்கப்படுகிறது. Go.mod கோப்பில் உள்ளீடுகள் உள்ளன, அவை வழிசெலுத்தியின் கோப்பகத்திற்கு பயன்படுத்தப்படும் பதிவிறக்க வழி அதன் சார்பு தேவைகளாகும். அடுத்து, இதில் குறிமுறைவரிகளை எழுதுவதற்கு, textpad, notepad அல்லது IDE போன்ற உரை திருத்திகள் தேவையாகும். ஆயினும் code.visualstudio.com/download இலிருந்து பதிவிறக்கம் செய்யக்கூடிய கட்டணமற்ற கட்டற்ற குறிமுறைவரி பதிப்பாளாரான VSCODE ஐ பயன்படுத்தலாம். வலைபின்னலை ஆதரிக்க, இதில் ‘net’ என்ற பெயரில் ஒரு தொகுப்பு உள்ளது, இதில் HTTP / HTTPS சேவையகத்தை உருவாக்கவும் வாடிக்கையாளர் கோரிக்கைகளைச் செயற்படுத்தி கொள்ளவும் பயன்படுத்தப்படுகின்ற http எனும் தொகுப்பு ஒன்றும உள்ளது. வலைபின்னல்தொகுப்பினை (golang.org/src/net/net.go) TCP / IP, UDP, domain பெயர் தெளிவுதிறன் , மின்னஞ்சல்கள் போன்ற பிணைய I / O ஐ ஆதரிப்பதற்காக ஒரு இடைமுகத்தை வழங்குகிறது. Http தொகுப்பானது கவணித்தலும் சேவையும்( ListenAndServe) எனும் ஒரு வழி முறையைக் கொண்டுள்ளது, இது சேவையகத்தைத் துவங்கி உள்வரும் கோரிக்கைகளை கேட்கிறது. இந்த முறை இரண்டு தருக்கங்களை ஏற்றுக்கொள்கிறது:
1. முகவரி(address):: இது சுட்டியின் முகவரி , இயந்திரத்திரநுழைவுவாயில் ஆகியவற்றின் சரவடிவமாகும். ‘9000’ போன்ற இணைய வாயில் மட்டுமே வழங்கப்பட்டால், இந்த இணைய வாயிலை கணினியின் அனைத்து சுட்டிமுகவரிகளின் மூலமும் அணுகமுடியும்.
2. கையாளுபவர்(handler): இந்த தருக்கம் கையாளுபவர் எனும் இடைமுகத்தின் வகையாகும். இது servHTTP வழிமுறையைப் பயன்படுத்திகொள்கிறது, இது கவணித்தலும் சேவையும் எனும் வழிமுறை செயல்படுத்தப்படும் போதெல்லாம் வளாகத்தில் அழைக்கப்படுகிறது.
3. servHTTPஎனும் வழிமுறை இது ( (res http.ResponseWriter, req * http.Request) எனும் வடிவமைப்பில் உள்ளது, மேலும் இது கோரிக்கையை ஏற்று பதிலை வழங்கும் முக்கிய செயல்பாடாகும்.
அடுத்தபடிமுறைக்கு செல்வதற்கு முன், (res 9000 இல் இயங்கும் ஒரு சேவையகத்திற்கான குறிமுறைவரிகளை காண்போம், இது இணைய உலாவியில் திறக்கப்படும் போது ‘Welcome to the World of Go Lang’ என்ற உரையுடன் பதிலளிக்கிறது:
package main
import (
“net/http”
))
// HttpHandler is a handler struct
type HttpHandler struct{}
// implement `ServeHTTP` method on `HttpHandler` struct
func (h HttpHandler) ServeHTTP(res http.ResponseWriter, req *http.Request) {
// create response binary data
data := []byte(“Welcome to the world of Go Lang”)
// write `data` to response
res.Write(data)
}
func main() {
// create a new handler
handler := HttpHandler{}
// listen and serve on localhost
http.ListenAndServe(“:9000”, handler)
}
மேலே காணும் குறிமுறைவரிகளில் ஒரு நிரலை http-server.go என்ற கோப்பில் எழுதப்பட்டுள்ளதை காணலாம், அதில் ஒரு HttpHandler என்பதை உருவாக்கி, serveHTTP எனும் வழிமுறை செயல்படுத்தப்பட்டுள்ளது. முகப்புத்திரையில் http-server.go என்ற கட்டளையை இயக்குவதன் மூலம் இந்த நிரல் இயங்கும்போது, முக்கிய செயல்பாடு செயல்படுத்தப்படுகிறது, இது http ListenAndServe எனும் வழிமுறையை அழைக்கிறது, இதன் மூலம் சேவையகத்தை ஒரு தருக்கமாக வழங்கப்பட்ட முகவரியில் துவங்குகிறது. ServHTTP இன் உள்ளே, மின்னனு தரவுகள் உருவாக்கப்பட்டுள்ளது, இது வழக்கமாக எழுதும் முறையைப் பயன்படுத்தி பதிலுக்கு எழுதப்பட்டுள்ளது. இணைய உலாவியில் http: // localhost: 9000 என்ற முகவரியை சென்றடைந்ததும், சேவையகம் அனுப்பிய தரவானது ஒரு பதிலாக காட்டப்படும். சேவையக முகப்புத்திரையில் CTRL ஐத் தட்டச்சு செய்வதன் மூலம் சேவையகமானது நிறுத்தப்படும் வரை தொடர்ந்து இயங்கும். மேலே உள்ள குறிமுறைவரிகள் ஒரு எளிய சேவையகத்தை உருவாக்குகின்றது, ஆனால் அதில் உள்ள சிக்கல் என்னவென்றால், எல்லா கோரிக்கைகளுக்கும் ஒரே பதிலையே திரும்ப திரும்ப அளிக்கிறது. எடுத்துக்காட்டாக, URL இல் /index.html அல்லது /test.pdf இருந்தால், பதில் எப்போதும் நிலையானதாக ஒரேபதிலாக இருக்கும் இதைத் தீர்வுசெய்வதற்காக, வெவ்வேறு URL களுக்கு வெவ்வேறு பதில்களைக் கையாளும் ஒரு பாதை அடிப்படையிலான கட்டுப்பாட்டு பொறிமுறையிலான சேவையகம் நமக்குத் தேவையாகும். ServerMux என்பது HTTP தொகுப்பில் உள்ளமைக்கப்பட்ட கட்டமைப்பாகும், மேலும் இது ஒரு பாதைக்கான செயல்பாட்டை ஏற்றுக்கொள்கிறது. கோரிக்கைகள் பாதையுடன் பொருந்தும்போது, விரும்பிய பதிலை வழங்க தொடர்புடைய செயலி அழைக்கப்படுகிறது. உதாரணமாக, கணக்குகளின் செயல்பாட்டிற்கு /api/accounts maps, இது கணக்கு தொடர்பான தகவல்களைத் தருகிறது, அதேசமயம் /api/subscription maps தகவலை வழங்குகிறது. கீழேயுள்ள குறிமுறைவரிகள் /home, /home/accounts, /home/subscription:எனும் இணைய URL களுக்கான வெவ்வேறு வெளியீடுகளை சித்தரிக்கிறது /
.package main
import (
“fmt”
“net/http”
))
func main() {
// Create a new ServerMux
mux := http.NewServeMux()
// handle `/` route
mux.HandleFunc(“/home”, func(res http.ResponseWriter, req *http.Request) {
fmt.Fprint(res, “ Welcome to Home Page!”)
})
// handle `Accounts` route
mux.HandleFunc(“/home/accounts”, func(res http.ResponseWriter, req *http.Request) {
fmt.Fprint(res, “ Welcome to Accounts page!”)
})
mux.HandleFunc(“/home/subscription”, func(res http.ResponseWriter, req *http.Request) {
fmt.Fprint(res, “ Welcome to Subscription Page!”)
})
// Listen and serve using ServerMux
http.ListenAndServe(“:9000”, mux)
}
கோ எனும் கணினிமொழியில் சேவையகத்தை அமைப்பதற்கான அடிப்படைகளை இந்த கட்டுரை உள்ளடக்கியுள்ளது. மேலும் விவரங்களுக்கு, golang.org/ எனும் இணையமுகவரியில் உள்ள ஆவணங்கள் வழியாக அறிந்துகொள்ளலாம். இந்த கணினிமொழியை கற்றுக்கொள்வதற்கு tour.golang.org/welcome/1 எனும் இணையமுகவரிக்கு செல்க மேலும் play.golang.org/ எனும் இணையமுகவரியில் இதனை ஒரு செயல்முறைவாயிலாக அறிந்துகொள்ளலாம்.