ગોલાંગમાં વેબ સર્વરનો વિકાસ - સરળથી જટિલ સુધી

પાંચ વર્ષ પહેલાં મેં શરૂઆત કરી હતી ગોફિશનો વિકાસ કરો, આનાથી ગોલાંગ શીખવાની તક મળી. મને સમજાયું કે ગો એક શક્તિશાળી ભાષા છે, જે ઘણી લાઇબ્રેરીઓ દ્વારા પૂરક છે. ગો બહુમુખી છે: ખાસ કરીને, તેનો ઉપયોગ કોઈપણ સમસ્યા વિના સર્વર-સાઇડ એપ્લિકેશનો વિકસાવવા માટે થઈ શકે છે.

આ લેખ Go માં સર્વર લખવા વિશે છે. ચાલો "હેલો વર્લ્ડ!" જેવી સરળ વસ્તુઓથી શરૂઆત કરીએ અને નીચેની ક્ષમતાઓ સાથેની એપ્લિકેશન સાથે સમાપ્ત કરીએ:

- HTTPS માટે લેટ્સ એન્ક્રિપ્ટનો ઉપયોગ કરવો.
— API રાઉટર તરીકે કામ કરવું.
- મિડલવેર સાથે કામ કરવું.
- સ્થિર ફાઇલોની પ્રક્રિયા.
- યોગ્ય શટડાઉન.

સ્કિલબોક્સ ભલામણ કરે છે: પ્રેક્ટિકલ કોર્સ "શરૂઆતથી પાયથોન ડેવલપર".

અમે યાદ કરાવીએ છીએ: Habrના તમામ વાચકો માટે - Habr પ્રોમો કોડનો ઉપયોગ કરીને કોઈપણ સ્કિલબોક્સ કોર્સમાં નોંધણી કરતી વખતે 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 ક્લાયંટ બંને વિકસાવવા માટે ગોમાં પ્રાથમિક સાધન છે. કોડને સમજવા માટે, ચાલો ત્રણ મહત્વના ઘટકોનો અર્થ સમજીએ: http.Handler, http.ServeMux અને http.Server.

HTTP હેન્ડલર્સ

જ્યારે અમને વિનંતી મળે છે, ત્યારે હેન્ડલર તેનું વિશ્લેષણ કરે છે અને પ્રતિભાવ જનરેટ કરે છે. Go માં હેન્ડલર્સ નીચે પ્રમાણે લાગુ કરવામાં આવે છે:

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

પ્રથમ ઉદાહરણ http.HandleFunc હેલ્પર ફંક્શનનો ઉપયોગ કરે છે. તે બીજા ફંક્શનને લપેટી લે છે, જે બદલામાં http.ResponseWriter અને http.Request ને ServeHTTP માં લે છે.

બીજા શબ્દોમાં કહીએ તો, ગોલાંગમાં હેન્ડલર્સ એક જ ઇન્ટરફેસમાં રજૂ થાય છે, જે પ્રોગ્રામરને ઘણા બધા વિકલ્પો આપે છે. તેથી, ઉદાહરણ તરીકે, મિડલવેરને હેન્ડલરનો ઉપયોગ કરીને અમલમાં મૂકવામાં આવે છે, જ્યાં ServeHTTP પહેલા કંઈક કરે છે અને પછી બીજા હેન્ડલરની ServeHTTP પદ્ધતિને કૉલ કરે છે.

ઉપર સૂચવ્યા મુજબ, હેન્ડલર્સ ફક્ત વિનંતીઓનો પ્રતિસાદ જનરેટ કરે છે. પરંતુ ચોક્કસ સમયે કયા ચોક્કસ હેન્ડલરનો ઉપયોગ કરવો જોઈએ?

રૂટીંગની વિનંતી કરો

યોગ્ય પસંદગી કરવા માટે, HTTP મલ્ટિપ્લેક્સરનો ઉપયોગ કરો. સંખ્યાબંધ પુસ્તકાલયોમાં તેને મક્સર અથવા રાઉટર કહેવામાં આવે છે, પરંતુ તે બધી સમાન વસ્તુ છે. મલ્ટિપ્લેક્સરનું કાર્ય વિનંતી પાથનું વિશ્લેષણ કરવાનું અને યોગ્ય હેન્ડલર પસંદ કરવાનું છે.

જો તમને જટિલ રૂટીંગ માટે સમર્થનની જરૂર હોય, તો તૃતીય-પક્ષ પુસ્તકાલયોનો ઉપયોગ કરવો વધુ સારું છે. કેટલાક સૌથી અદ્યતન - ગોરીલા/મક્સ и ગો-ચી/ચી, આ પુસ્તકાલયો કોઈપણ સમસ્યા વિના મધ્યવર્તી પ્રક્રિયાને અમલમાં મૂકવાનું શક્ય બનાવે છે. તેમની સહાયથી, તમે વાઇલ્ડકાર્ડ રૂટીંગને ગોઠવી શકો છો અને સંખ્યાબંધ અન્ય કાર્યો કરી શકો છો. તેમનો ફાયદો પ્રમાણભૂત HTTP હેન્ડલર્સ સાથે સુસંગતતા છે. પરિણામે, તમે સરળ કોડ લખી શકો છો જે ભવિષ્યમાં સુધારી શકાય છે.

સામાન્ય પરિસ્થિતિમાં જટિલ ફ્રેમવર્ક સાથે કામ કરવા માટે બિન-માનક ઉકેલોની જરૂર પડશે, અને આ ડિફોલ્ટ હેન્ડલર્સના ઉપયોગને નોંધપાત્ર રીતે જટિલ બનાવે છે. મોટાભાગની એપ્લિકેશનો બનાવવા માટે, ડિફૉલ્ટ લાઇબ્રેરી અને એક સરળ રાઉટરનું સંયોજન પૂરતું હશે.

ક્વેરી પ્રોસેસિંગ

વધુમાં, અમને એક ઘટકની જરૂર છે જે આવનારા કનેક્શન્સ માટે "સાંભળશે" અને બધી વિનંતીઓને યોગ્ય હેન્ડલર પર રીડાયરેક્ટ કરશે. http.Server આ કાર્યને સરળતાથી હેન્ડલ કરી શકે છે.

નીચે દર્શાવેલ છે કે સર્વર કનેક્શન પ્રોસેસિંગથી સંબંધિત તમામ કાર્યો માટે જવાબદાર છે. આ, ઉદાહરણ તરીકે, TLS પ્રોટોકોલનો ઉપયોગ કરીને કામ કરે છે. http.ListenAndServer કૉલને અમલમાં મૂકવા માટે, પ્રમાણભૂત HTTP સર્વરનો ઉપયોગ થાય છે.

હવે ચાલો વધુ જટિલ ઉદાહરણો જોઈએ.

ચાલો એન્ક્રિપ્ટ ઉમેરી રહ્યા છીએ

મૂળભૂત રીતે, અમારી એપ્લિકેશન HTTP પ્રોટોકોલ પર ચાલે છે, પરંતુ HTTPS પ્રોટોકોલનો ઉપયોગ કરવાની ભલામણ કરવામાં આવે છે. આ Go માં સમસ્યાઓ વિના કરી શકાય છે. જો તમને પ્રમાણપત્ર અને ખાનગી કી પ્રાપ્ત થઈ હોય, તો તે યોગ્ય પ્રમાણપત્ર અને કી ફાઇલો સાથે 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 સમર્થનને અમલમાં મૂકવાની આ એક સરળ રીત છે.

કસ્ટમ રૂટ્સ ઉમેરી રહ્યા છીએ

સ્ટાન્ડર્ડ લાઇબ્રેરીમાં સમાવિષ્ટ ડિફોલ્ટ રાઉટર સારું છે, પરંતુ તે ખૂબ જ મૂળભૂત છે. મોટાભાગની એપ્લિકેશનોને વધુ જટિલ રૂટીંગની જરૂર હોય છે, જેમાં નેસ્ટેડ અને વાઇલ્ડકાર્ડ રૂટનો સમાવેશ થાય છે, અથવા પાથ પેટર્ન અને પરિમાણો સેટ કરવા માટેની પ્રક્રિયા.

આ કિસ્સામાં તે પેકેજોનો ઉપયોગ કરવા યોગ્ય છે ગોરીલા/મક્સ и ગો-ચી/ચી. અમે બાદમાં સાથે કેવી રીતે કામ કરવું તે શીખીશું - એક ઉદાહરણ નીચે બતાવેલ છે.

અમારા 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, જે તમને મિડલવેર કાર્યક્ષમતાને વિસ્તારવા દે છે.

સ્થિર ફાઇલો સાથે કામ કરવું

ગો સ્ટાન્ડર્ડ લાઇબ્રેરીમાં છબીઓ, JavaScript અને 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

તે ચોક્કસપણે યાદ રાખવા યોગ્ય છે કે http.Dir ડિરેક્ટરીના સમાવિષ્ટો દર્શાવે છે જો તેમાં મુખ્ય index.html ફાઇલ શામેલ ન હોય. આ કિસ્સામાં, ડિરેક્ટરીને ચેડા થવાથી રોકવા માટે, તમારે પેકેજનો ઉપયોગ કરવો જોઈએ unindexed.

યોગ્ય શટડાઉન

ગોમાં HTTP સર્વરનું ગ્રેસફુલ શટડાઉન નામની સુવિધા પણ છે. આ શટડાઉન() પદ્ધતિનો ઉપયોગ કરીને કરી શકાય છે. સર્વર ગોરોટીનમાં શરૂ થાય છે, અને પછી ચેનલને ઇન્ટરપ્ટ સિગ્નલ પ્રાપ્ત કરવા માટે સાંભળવામાં આવે છે. જલદી સિગ્નલ પ્રાપ્ત થાય છે, સર્વર બંધ થાય છે, પરંતુ તરત જ નહીં, પરંતુ થોડી સેકંડ પછી.

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)

નિષ્કર્ષ તરીકે

ગો લગભગ સાર્વત્રિક પ્રમાણભૂત પુસ્તકાલય સાથેની શક્તિશાળી ભાષા છે. તેની ડિફૉલ્ટ ક્ષમતાઓ ખૂબ વિશાળ છે, અને તેને ઇન્ટરફેસનો ઉપયોગ કરીને વધારી શકાય છે - આ તમને ખરેખર વિશ્વસનીય HTTP સર્વર્સ વિકસાવવા માટે પરવાનગી આપે છે.

સ્કિલબોક્સ ભલામણ કરે છે:

• બે વર્ષનો પ્રેક્ટિકલ કોર્સ "હું પ્રો વેબ ડેવલપર છું".
• શૈક્ષણિક ઓનલાઈન કોર્સ "પ્રોફેશન જાવા ડેવલપર".
• એક વર્ષનો પ્રેક્ટિકલ કોર્સ "0 થી PRO સુધી PHP વિકાસકર્તા".

સોર્સ: www.habr.com