ვებ სერვერის განვითარება Golang-ში - მარტივიდან რთულამდე

ხუთი წლის წინ დავიწყე გოფშის განვითარება, ამან გოლანგის შესწავლის შესაძლებლობა მისცა. მივხვდი, რომ Go არის ძლიერი ენა, რომელსაც ავსებს მრავალი ბიბლიოთეკა. Go არის მრავალმხრივი: კერძოდ, ის შეიძლება გამოყენებულ იქნას სერვერის მხარეს აპლიკაციების შესაქმნელად უპრობლემოდ.

ეს სტატია ეხება სერვერის დაწერას Go-ში. დავიწყოთ მარტივი რაღაცებით, როგორიცაა "Hello World!" და დავასრულოთ აპლიკაციით შემდეგი შესაძლებლობებით:

- Let's Encrypt-ის გამოყენება HTTPS-ისთვის.
- მუშაობს API როუტერად.
- მუშაობა შუა პროგრამებთან.
- სტატიკური ფაილების დამუშავება.
- სწორი გამორთვა.

Skillbox გირჩევთ: პრაქტიკული კურსი "პითონის დეველოპერი ნულიდან".

შეგახსენებთ: "Habr"-ის ყველა მკითხველისთვის - ფასდაკლება 10 რუბლიდან Skillbox-ის ნებისმიერ კურსზე ჩარიცხვისას "Habr" სარეკლამო კოდის გამოყენებით.

Გამარჯობა მსოფლიო!

თქვენ შეგიძლიათ შექმნათ ვებ სერვერი Go-ში ძალიან სწრაფად. აქ მოცემულია დამმუშავებლის გამოყენების მაგალითი, რომელიც აბრუნებს ზემოთ დაპირებულ „Hello, World!“-ს.

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)
}

ამის შემდეგ თუ გაუშვით აპლიკაცია და გახსენით გვერდი localhost, მაშინვე დაინახავთ ტექსტს "გამარჯობა, სამყარო!" (თუ ყველაფერი სწორად მუშაობს, რა თქმა უნდა).

ჩვენ მოგვიანებით მრავალჯერ გამოვიყენებთ დამმუშავებელს, მაგრამ ჯერ გავიგოთ, როგორ მუშაობს ყველაფერი.

net/http

მაგალითში გამოყენებულია პაკეტი net/http, ის არის მთავარი ინსტრუმენტი Go-ში როგორც სერვერების, ასევე HTTP კლიენტების განვითარებისთვის. კოდის გასაგებად, მოდით გავიგოთ სამი მნიშვნელოვანი ელემენტის მნიშვნელობა: http.Handler, http.ServeMux და http.Server.

HTTP დამმუშავებლები

როდესაც ვიღებთ მოთხოვნას, დამმუშავებელი აანალიზებს მას და ქმნის პასუხს. Handlers in Go დანერგილია შემდეგნაირად:

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

პირველი მაგალითი იყენებს http.HandleFunc დამხმარე ფუნქციას. ის ახვევს სხვა ფუნქციას, რომელიც თავის მხრივ იღებს http.ResponseWriter და http.Request-ს ServeHTTP-ში.

სხვა სიტყვებით რომ ვთქვათ, Golang-ში დამმუშავებლები წარმოდგენილია ერთ ინტერფეისში, რაც უამრავ ვარიანტს აძლევს პროგრამისტს. მაგალითად, შუა პროგრამა დანერგილია დამმუშავებლის გამოყენებით, სადაც ServeHTTP ჯერ აკეთებს რაღაცას და შემდეგ უწოდებს სხვა დამმუშავებლის ServeHTTP მეთოდს.

როგორც ზემოთ აღინიშნა, დამმუშავებლები უბრალოდ ქმნიან პასუხებს მოთხოვნებზე. მაგრამ რომელი კონკრეტული დამმუშავებელი უნდა იყოს გამოყენებული დროის კონკრეტულ მომენტში?

მოითხოვეთ მარშრუტი

სწორი არჩევანის გასაკეთებლად გამოიყენეთ HTTP მულტიპლექსერი. რიგ ბიბლიოთეკაში მას muxer ან როუტერს უწოდებენ, მაგრამ ისინი ყველა ერთი და იგივეა. მულტიპლექსერის ფუნქციაა მოთხოვნის ბილიკის ანალიზი და შესაბამისი დამმუშავებლის შერჩევა.

თუ გჭირდებათ მხარდაჭერა რთული მარშრუტიზაციისთვის, უმჯობესია გამოიყენოთ მესამე მხარის ბიბლიოთეკები. ზოგიერთი ყველაზე მოწინავე - გორილა/მუქსი и გო-ჩი/ჩი, ეს ბიბლიოთეკები შესაძლებელს ხდის შუალედური დამუშავების უპრობლემოდ განხორციელებას. მათი დახმარებით თქვენ შეგიძლიათ დააკონფიგურიროთ wildcard-ის მარშრუტიზაცია და შეასრულოთ მრავალი სხვა დავალება. მათი უპირატესობა არის თავსებადობა სტანდარტული HTTP დამმუშავებლებთან. შედეგად, თქვენ შეგიძლიათ დაწეროთ მარტივი კოდი, რომელიც შეიძლება შეიცვალოს მომავალში.

ნორმალურ სიტუაციაში რთულ ჩარჩოებთან მუშაობა მოითხოვს არასტანდარტულ გადაწყვეტილებებს და ეს მნიშვნელოვნად ართულებს ნაგულისხმევი დამმუშავებლების გამოყენებას. აპლიკაციების დიდი უმრავლესობის შესაქმნელად საკმარისი იქნება ნაგულისხმევი ბიბლიოთეკისა და მარტივი როუტერის კომბინაცია.

შეკითხვის დამუშავება

გარდა ამისა, ჩვენ გვჭირდება კომპონენტი, რომელიც „მოისმენს“ შემომავალ კავშირებს და გადამისამართებს ყველა მოთხოვნას სწორ დამმუშავებელზე. http.Server ადვილად უმკლავდება ამ ამოცანას.

შემდეგი გვიჩვენებს, რომ სერვერი პასუხისმგებელია ყველა დავალებაზე, რომელიც დაკავშირებულია კავშირის დამუშავებასთან. ეს, მაგალითად, მუშაობს TLS პროტოკოლის გამოყენებით. http.ListenAndServer ზარის განსახორციელებლად გამოიყენება სტანდარტული HTTP სერვერი.

ახლა მოდით შევხედოთ უფრო რთულ მაგალითებს.

დაემატება Let's Encrypt

ნაგულისხმევად, ჩვენი აპლიკაცია მუშაობს HTTP პროტოკოლზე, მაგრამ რეკომენდებულია HTTPS პროტოკოლის გამოყენება. ეს შეიძლება გაკეთდეს უპრობლემოდ Go-ში. თუ თქვენ მიიღეთ სერთიფიკატი და პირადი გასაღები, მაშინ საკმარისია დაარეგისტრიროთ ListenAndServeTLS სწორი სერტიფიკატით და გასაღების ფაილებით.

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

თქვენ ყოველთვის შეგიძლიათ უკეთესად გააკეთოთ.

მოდით დაასრულა გთავაზობთ უფასო სერთიფიკატებს ავტომატური განახლებით. სერვისით სარგებლობისთვის საჭიროა პაკეტი autocert.

მისი კონფიგურაციის უმარტივესი გზაა autocert.NewListener მეთოდის გამოყენება http.Serve-თან ერთად. მეთოდი საშუალებას გაძლევთ მიიღოთ და განაახლოთ TLS სერთიფიკატები, სანამ HTTP სერვერი ამუშავებს მოთხოვნებს:

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/v1/api.go, რომელიც შეიცავს მარშრუტებს ჩვენი API-სთვის:

/ 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())

Go-ს რთულ მარშრუტებთან მუშაობის სიმარტივე შესაძლებელს ხდის გამარტივდეს დიდი, რთული აპლიკაციების სტრუქტურირება და შენარჩუნება.

მუშაობა შუალედურთან

დადგმა გულისხმობს ერთი 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, რომელიც საშუალებას გაძლევთ გააფართოვოთ შუა პროგრამის ფუნქციონირება.

სტატიკურ ფაილებთან მუშაობა

Go სტანდარტული ბიბლიოთეკა მოიცავს სტატიკურ კონტენტთან მუშაობის შესაძლებლობებს, მათ შორის სურათებს, 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.

სწორი გამორთვა

Go-ს ასევე აქვს ფუნქცია, სახელწოდებით HTTP სერვერის მოხდენილი გამორთვა. ეს შეიძლება გაკეთდეს Shutdown() მეთოდის გამოყენებით. სერვერი იწყება გორუტინის რეჟიმში, შემდეგ კი არხის მოსმენა ხდება შეფერხების სიგნალის მისაღებად. როგორც კი სიგნალი მიიღება, სერვერი ითიშება, მაგრამ არა მაშინვე, არამედ რამდენიმე წამის შემდეგ.

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 გირჩევთ:

• ორწლიანი პრაქტიკული კურსი "მე ვარ PRO ვებ დეველოპერი".
• საგანმანათლებლო ონლაინ კურსი "პროფესია Java Developer".
• პრაქტიკული წლის კურსი "PHP დეველოპერი 0-დან PRO-მდე".

წყარო: www.habr.com