கோலாங்கில் இணைய சேவையக மேம்பாடு - எளிமையானது முதல் சிக்கலானது வரை

ஐந்து வருடங்களுக்கு முன்பு நான் ஆரம்பித்தேன் கோபிஷை உருவாக்குங்கள், இது கோலாங் கற்க ஒரு வாய்ப்பை வழங்கியது. கோ ஒரு சக்திவாய்ந்த மொழி என்பதை நான் உணர்ந்தேன், பல நூலகங்களால் நிரப்பப்பட்டது. Go பல்துறை: குறிப்பாக, எந்த பிரச்சனையும் இல்லாமல் சர்வர் பக்க பயன்பாடுகளை உருவாக்க இதைப் பயன்படுத்தலாம்.

இந்த கட்டுரை Go இல் ஒரு சேவையகத்தை எழுதுவது பற்றியது. "ஹலோ வேர்ல்ட்!" போன்ற எளிய விஷயங்களில் தொடங்கி, பின்வரும் திறன்களைக் கொண்ட பயன்பாட்டுடன் முடிப்போம்:

- HTTPS க்காக லெட்ஸ் என்க்ரிப்ட் செய்வதைப் பயன்படுத்துதல்.
- API திசைவியாக வேலை செய்கிறது.
- மிடில்வேருடன் பணிபுரிதல்.
- நிலையான கோப்புகளின் செயலாக்கம்.
- சரியான பணிநிறுத்தம்.

Skillbox பரிந்துரைக்கிறது: நடைமுறை படிப்பு "புதிதாக பைதான் டெவலப்பர்".

நாங்கள் நினைவூட்டுகிறோம்: "Habr" இன் அனைத்து வாசகர்களுக்கும் - "Habr" விளம்பரக் குறியீட்டைப் பயன்படுத்தி எந்த Skillbox படிப்பிலும் சேரும்போது 10 ரூபிள் தள்ளுபடி.

வணக்கம், உலகம்!

Go இல் மிக விரைவாக இணைய சேவையகத்தை உருவாக்கலாம். மேலே வாக்குறுதியளிக்கப்பட்ட "ஹலோ, வேர்ல்ட்!"ஐ வழங்கும் ஹேண்ட்லரைப் பயன்படுத்துவதற்கான உதாரணம் இதோ.

package main
 
import (
"fmt"
"net/http"
)
 
func main() {
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Hello World!")
})
http.ListenAndServe(":80", nil)
}

இதற்குப் பிறகு, நீங்கள் பயன்பாட்டை இயக்கி பக்கத்தைத் திறந்தால் லோக்கல் ஹோஸ்ட், நீங்கள் உடனடியாக "வணக்கம், உலகம்!" என்ற உரையைப் பார்ப்பீர்கள். (எல்லாம் சரியாக வேலை செய்தால், நிச்சயமாக).

ஹேண்ட்லரைப் பிறகு பலமுறை பயன்படுத்துவோம், ஆனால் முதலில் எல்லாம் எப்படி வேலை செய்கிறது என்பதைப் புரிந்துகொள்வோம்.

நிகர/http

உதாரணம் தொகுப்பைப் பயன்படுத்தியது net/http, சேவையகங்கள் மற்றும் HTTP கிளையண்டுகள் இரண்டையும் உருவாக்குவதற்கு Go இல் முதன்மையான கருவி இதுவாகும். குறியீட்டைப் புரிந்து கொள்ள, மூன்று முக்கியமான கூறுகளின் பொருளைப் புரிந்துகொள்வோம்: http.Handler, http.ServeMux மற்றும் http.Server.

HTTP கையாளுபவர்கள்

நாங்கள் ஒரு கோரிக்கையைப் பெறும்போது, ​​கையாளுபவர் அதை பகுப்பாய்வு செய்து பதிலை உருவாக்குகிறார். Go இல் கையாளுபவர்கள் பின்வருமாறு செயல்படுத்தப்படுகின்றன:

type Handler interface {
        ServeHTTP(ResponseWriter, *Request)
}

முதல் எடுத்துக்காட்டு http.HandleFunc உதவி செயல்பாட்டைப் பயன்படுத்துகிறது. இது மற்றொரு செயல்பாட்டைச் சுருக்குகிறது, இது http.ResponseWriter மற்றும் http.Request ஆகியவற்றை ServeHTTP க்கு எடுக்கும்.

வேறு வார்த்தைகளில் கூறுவதானால், கோலாங்கில் கையாளுபவர்கள் ஒரே இடைமுகத்தில் வழங்கப்படுகிறார்கள், இது புரோகிராமருக்கு நிறைய விருப்பங்களை வழங்குகிறது. எனவே, எடுத்துக்காட்டாக, மிடில்வேர் ஹேண்ட்லரைப் பயன்படுத்தி செயல்படுத்தப்படுகிறது, அங்கு ServeHTTP முதலில் ஏதாவது செய்து, பின்னர் மற்றொரு ஹேண்ட்லரின் ServeHTTP முறையை அழைக்கிறது.

மேலே குறிப்பிட்டுள்ளபடி, கையாளுபவர்கள் கோரிக்கைகளுக்கு பதில்களை உருவாக்குகிறார்கள். ஆனால் ஒரு குறிப்பிட்ட நேரத்தில் எந்த குறிப்பிட்ட கையாளுதலைப் பயன்படுத்த வேண்டும்?

ரூட்டிங் கோரிக்கை

சரியான தேர்வு செய்ய, HTTP மல்டிபிளெக்சரைப் பயன்படுத்தவும். பல நூலகங்களில் இது muxer அல்லது router என்று அழைக்கப்படுகிறது, ஆனால் அவை அனைத்தும் ஒன்றுதான். மல்டிபிளெக்சரின் செயல்பாடு கோரிக்கை பாதையை பகுப்பாய்வு செய்து பொருத்தமான கையாளுநரைத் தேர்ந்தெடுப்பதாகும்.

உங்களுக்கு சிக்கலான ரூட்டிங் ஆதரவு தேவைப்பட்டால், மூன்றாம் தரப்பு நூலகங்களைப் பயன்படுத்துவது நல்லது. மிகவும் மேம்பட்ட சில - கொரில்லா/மக்ஸ் и go-chi/chi, இந்த நூலகங்கள் இடைநிலை செயலாக்கத்தை எந்த பிரச்சனையும் இல்லாமல் செயல்படுத்துவதை சாத்தியமாக்குகிறது. அவர்களின் உதவியுடன், நீங்கள் வைல்டு கார்டு ரூட்டிங்கை உள்ளமைக்கலாம் மற்றும் பல பணிகளைச் செய்யலாம். அவற்றின் நன்மை நிலையான HTTP கையாளுபவர்களுடன் பொருந்தக்கூடியது. இதன் விளைவாக, எதிர்காலத்தில் மாற்றியமைக்கக்கூடிய எளிய குறியீட்டை நீங்கள் எழுதலாம்.

ஒரு சாதாரண சூழ்நிலையில் சிக்கலான கட்டமைப்புகளுடன் பணிபுரிவதற்கு தரமற்ற தீர்வுகள் தேவைப்படும், மேலும் இது இயல்புநிலை கையாளுபவர்களின் பயன்பாட்டை கணிசமாக சிக்கலாக்குகிறது. பெரும்பாலான பயன்பாடுகளை உருவாக்க, இயல்புநிலை நூலகம் மற்றும் ஒரு எளிய திசைவி ஆகியவற்றின் கலவை போதுமானதாக இருக்கும்.

வினவல் செயலாக்கம்

கூடுதலாக, உள்வரும் இணைப்புகளை "கேட்க" மற்றும் அனைத்து கோரிக்கைகளையும் சரியான கையாளுதலுக்கு திருப்பிவிடும் ஒரு கூறு எங்களுக்குத் தேவை. http.Server இந்த பணியை எளிதாக கையாள முடியும்.

இணைப்புச் செயலாக்கத்துடன் தொடர்புடைய அனைத்துப் பணிகளுக்கும் சர்வர் பொறுப்பு என்பதை பின்வருபவை காட்டுகிறது. எடுத்துக்காட்டாக, இது TLS நெறிமுறையைப் பயன்படுத்தி செயல்படுகிறது. http.ListenAndServer அழைப்பைச் செயல்படுத்த, நிலையான HTTP சேவையகம் பயன்படுத்தப்படுகிறது.

இப்போது மிகவும் சிக்கலான எடுத்துக்காட்டுகளைப் பார்ப்போம்.

லெட்ஸ் என்க்ரிப்ட் சேர்ப்பது

இயல்பாக, எங்கள் பயன்பாடு HTTP நெறிமுறையில் இயங்குகிறது, ஆனால் HTTPS நெறிமுறையைப் பயன்படுத்த பரிந்துரைக்கப்படுகிறது. கோவில் பிரச்சனைகள் இல்லாமல் இதைச் செய்யலாம். நீங்கள் சான்றிதழ் மற்றும் தனிப்பட்ட விசையைப் பெற்றிருந்தால், சரியான சான்றிதழ் மற்றும் முக்கிய கோப்புகளுடன் ListenAndServeTLS ஐ பதிவு செய்தால் போதும்.

http.ListenAndServeTLS(":443", "cert.pem", "key.pem", nil)

நீங்கள் எப்போதும் சிறப்பாக செய்ய முடியும்.

என்க்ரிப்ட் தானியங்கி புதுப்பித்தலுடன் இலவச சான்றிதழ்களை வழங்குகிறது. சேவையைப் பயன்படுத்த, உங்களுக்கு ஒரு தொகுப்பு தேவை autocert.

http.Serve உடன் இணைந்து autocert.NewListener முறையைப் பயன்படுத்துவதே அதை உள்ளமைப்பதற்கான எளிதான வழி. HTTP சேவையகம் கோரிக்கைகளை செயலாக்கும்போது TLS சான்றிதழ்களைப் பெறவும் புதுப்பிக்கவும் இந்த முறை உங்களை அனுமதிக்கிறது:

http.Serve(autocert.NewListener("example.com"), nil)

உலாவியில் திறந்தால் example.com, “வணக்கம், உலகம்!” என்ற HTTPS பதிலைப் பெறுவோம்!

உங்களுக்கு விரிவான உள்ளமைவு தேவைப்பட்டால், நீங்கள் autocert.Manager மேலாளரைப் பயன்படுத்த வேண்டும். பின்னர் நாங்கள் எங்கள் சொந்த http.Server நிகழ்வை உருவாக்குகிறோம் (இப்போது வரை நாங்கள் அதை இயல்பாகவே பயன்படுத்தினோம்) மற்றும் மேலாளரை TLSConfig சேவையகத்தில் சேர்க்கிறோம்:

m := &autocert.Manager{
Cache:      autocert.DirCache("golang-autocert"),
Prompt:     autocert.AcceptTOS,
HostPolicy: autocert.HostWhitelist("example.org", "www.example.org"),
}
server := &http.Server{
    Addr:      ":443",
    TLSConfig: m.TLSConfig(),
}
server.ListenAndServeTLS("", "")

தானியங்கு சான்றிதழ் புதுப்பித்தலுடன் முழு HTTPS ஆதரவைச் செயல்படுத்த இது எளிதான வழியாகும்.

தனிப்பயன் வழிகளைச் சேர்த்தல்

நிலையான நூலகத்தில் சேர்க்கப்பட்டுள்ள இயல்புநிலை திசைவி நன்றாக உள்ளது, ஆனால் இது மிகவும் அடிப்படையானது. பெரும்பாலான பயன்பாடுகளுக்கு உள்ளமைக்கப்பட்ட மற்றும் வைல்டு கார்டு வழிகள் அல்லது பாதை வடிவங்கள் மற்றும் அளவுருக்களை அமைப்பதற்கான செயல்முறை உட்பட மிகவும் சிக்கலான ரூட்டிங் தேவைப்படுகிறது.

இந்த வழக்கில், தொகுப்புகளைப் பயன்படுத்துவது மதிப்பு கொரில்லா/மக்ஸ் и go-chi/chi. பிந்தையவற்றுடன் எவ்வாறு வேலை செய்வது என்பதை நாங்கள் கற்றுக்கொள்வோம் - ஒரு எடுத்துக்காட்டு கீழே காட்டப்பட்டுள்ளது.

எங்கள் APIக்கான வழிகளைக் கொண்ட api/v1/api.go கோப்பு கொடுக்கப்பட்டுள்ளது:

/ HelloResponse is the JSON representation for a customized message
type HelloResponse struct {
Message string `json:"message"`
}
 
// HelloName returns a personalized JSON message
func HelloName(w http.ResponseWriter, r *http.Request) {
name := chi.URLParam(r, "name")
response := HelloResponse{
Message: fmt.Sprintf("Hello %s!", name),
}
jsonResponse(w, response, http.StatusOK)
}
 
// NewRouter returns an HTTP handler that implements the routes for the API
func NewRouter() http.Handler {
r := chi.NewRouter()
r.Get("/{name}", HelloName)
return r
}

பிரதான கோப்பில் வழிகளுக்கான api/vq முன்னொட்டை அமைத்துள்ளோம்.

எங்கள் பிரதான பயன்பாட்டில் மீண்டும் api/v1/ முன்னொட்டின் கீழ் இதை எங்கள் பிரதான திசைவிக்கு ஏற்றலாம்:

// NewRouter returns a new HTTP handler that implements the main server routes
func NewRouter() http.Handler {
router := chi.NewRouter()
    router.Mount("/api/v1/", v1.NewRouter())
    return router
}
http.Serve(autocert.NewListener("example.com"), NewRouter())

கோவின் சிக்கலான வழிகளில் எளிதாக வேலை செய்வது, பெரிய, சிக்கலான பயன்பாடுகளின் கட்டமைப்பையும் பராமரிப்பையும் எளிதாக்குகிறது.

மிடில்வேருடன் பணிபுரிதல்

ஸ்டேஜிங் என்பது ஒரு HTTP ஹேண்ட்லரை மற்றொன்றுடன் போர்த்தி, அங்கீகரிப்பு, சுருக்கம், பதிவு செய்தல் மற்றும் பல செயல்பாடுகளை விரைவாகச் செய்வதை சாத்தியமாக்குகிறது.

உதாரணமாக, http.Handler இடைமுகத்தைப் பார்ப்போம்; சேவைப் பயனர்களை அங்கீகரிக்கும் ஹேண்ட்லரை எழுத அதைப் பயன்படுத்துவோம்.

func RequireAuthentication(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if !isAuthenticated(r) {
            http.Redirect(w, r, "/login", http.StatusTemporaryRedirect)
            return
        }
        // Assuming authentication passed, run the original handler
        next.ServeHTTP(w, r)
    })
}

மிடில்வேர் செயல்பாட்டை நீட்டிக்க அனுமதிக்கும் chi போன்ற மூன்றாம் தரப்பு திசைவிகள் உள்ளன.

நிலையான கோப்புகளுடன் பணிபுரிதல்

கோ நிலையான நூலகத்தில் படங்கள், ஜாவாஸ்கிரிப்ட் மற்றும் CSS கோப்புகள் உட்பட நிலையான உள்ளடக்கத்துடன் பணிபுரியும் திறன்கள் உள்ளன. அவற்றை http.FileServer செயல்பாடு மூலம் அணுகலாம். இது ஒரு குறிப்பிட்ட கோப்பகத்தில் இருந்து கோப்புகளை வழங்கும் ஹேண்ட்லரை வழங்குகிறது.

func NewRouter() http.Handler {
    router := chi.NewRouter()
    r.Get("/{name}", HelloName)
 
// Настройка раздачи статических файлов
staticPath, _ := filepath.Abs("../../static/")
fs := http.FileServer(http.Dir(staticPath))
    router.Handle("/*", fs)
    
    return r

முக்கிய index.html கோப்பைக் கொண்டிருக்கவில்லை என்றால், http.Dir கோப்பகத்தின் உள்ளடக்கங்களைக் காண்பிக்கும் என்பதை நிச்சயமாக நினைவில் கொள்வது மதிப்பு. இந்த வழக்கில், கோப்பகம் சமரசம் செய்யப்படுவதைத் தடுக்க, நீங்கள் தொகுப்பைப் பயன்படுத்த வேண்டும் unindexed.

சரியான பணிநிறுத்தம்

Go ஆனது HTTP சேவையகத்தின் க்ரேஸ்ஃபுல் ஷட் டவுன் என்ற அம்சத்தையும் கொண்டுள்ளது. இதை Shutdown() முறையில் செய்யலாம். சர்வர் ஒரு goroutine இல் தொடங்கப்பட்டது, பின்னர் குறுக்கீடு சிக்னலைப் பெற சேனல் கேட்கப்படுகிறது. சிக்னல் கிடைத்தவுடன், சர்வர் ஆஃப் ஆகிவிடும், ஆனால் உடனடியாக அல்ல, சில நொடிகளுக்குப் பிறகு.

handler := server.NewRouter()
srv := &http.Server{
    Handler: handler,
}
 
go func() {
srv.Serve(autocert.NewListener(domains...))
}()
 
// Wait for an interrupt
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
<-c
 
// Attempt a graceful shutdown
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
srv.Shutdown(ctx)

ஒரு முடிவாக

Go என்பது கிட்டத்தட்ட உலகளாவிய தரநிலை நூலகத்துடன் கூடிய சக்திவாய்ந்த மொழியாகும். அதன் இயல்புநிலை திறன்கள் மிகவும் பரந்தவை, மேலும் அவை இடைமுகங்களைப் பயன்படுத்தி மேம்படுத்தப்படலாம் - இது உண்மையிலேயே நம்பகமான HTTP சேவையகங்களை உருவாக்க உங்களை அனுமதிக்கிறது.

Skillbox பரிந்துரைக்கிறது:

• இரண்டு வருட நடைமுறை படிப்பு "நான் ஒரு புரோ வெப் டெவலப்பர்".
• கல்வி ஆன்லைன் படிப்பு "தொழில் ஜாவா டெவலப்பர்".
• நடைமுறை ஆண்டு படிப்பு "0 முதல் PRO வரையிலான PHP டெவலப்பர்".

ஆதாரம்: www.habr.com