ការអភិវឌ្ឍម៉ាស៊ីនមេគេហទំព័រនៅក្នុង Golang - ពីសាមញ្ញទៅស្មុគស្មាញ

កាលពីប្រាំឆ្នាំមុនខ្ញុំបានចាប់ផ្តើម អភិវឌ្ឍ Gophishវាបានធ្វើឱ្យវាអាចរៀន Golang ។ ខ្ញុំបានដឹងថា Go គឺជាភាសាដ៏មានអានុភាព ដែលត្រូវបានបំពេញបន្ថែមដោយបណ្ណាល័យជាច្រើន។ Go គឺអាចប្រើប្រាស់បាន៖ ជាពិសេស អ្នកអាចបង្កើតកម្មវិធីចំហៀងម៉ាស៊ីនមេបានយ៉ាងងាយស្រួលជាមួយវា។

អត្ថបទនេះនិយាយអំពីការសរសេរម៉ាស៊ីនមេនៅក្នុង Go ។ តោះចាប់ផ្តើមជាមួយរឿងសាមញ្ញៗដូចជា "Hello world!" ហើយបញ្ចប់ដោយកម្មវិធីដែលមានមុខងារទាំងនេះ៖

- ការប្រើប្រាស់ Let's Encrypt សម្រាប់ HTTPS ។
- ធ្វើការជារ៉ោតទ័រ API ។
- ធ្វើការជាមួយឧបករណ៍កណ្តាល។
- ដោះស្រាយឯកសារឋិតិវន្ត។
- ការបិទត្រឹមត្រូវ។

Skillbox ណែនាំ៖ វគ្គសិក្សាជាក់ស្តែង "អ្នកអភិវឌ្ឍន៍ Python ពីដំបូង".

យើងរំលឹក៖ សម្រាប់អ្នកអានទាំងអស់នៃ "Habr" - ការបញ្ចុះតម្លៃ 10 rubles នៅពេលចុះឈ្មោះក្នុងវគ្គសិក្សា Skillbox ណាមួយដោយប្រើលេខកូដផ្សព្វផ្សាយ "Habr" ។

សួស្តី​ពិភពលោក!

ការបង្កើតម៉ាស៊ីនមេគេហទំព័រនៅក្នុង 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)
}

បន្ទាប់ពីនោះប្រសិនបើអ្នកដំណើរការកម្មវិធីហើយបើកទំព័រ 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 multiplexer ។ នៅក្នុងបណ្ណាល័យមួយចំនួនវាត្រូវបានគេហៅថា muxer ឬ Router ប៉ុន្តែពួកវាដូចគ្នាទាំងអស់។ មុខងាររបស់ multiplexer គឺដើម្បីវិភាគផ្លូវស្នើសុំ ហើយជ្រើសរើស handler ដែលសមស្រប។

ប្រសិនបើអ្នកត្រូវការការគាំទ្រសម្រាប់ផ្លូវស្មុគស្មាញ នោះវាជាការប្រសើរក្នុងការប្រើប្រាស់បណ្ណាល័យភាគីទីបី។ មួយក្នុងចំណោមកម្រិតខ្ពស់បំផុត។ ហ្គោរីឡា/មូស и go-chi/chiបណ្ណាល័យទាំងនេះធ្វើឱ្យវាអាចអនុវត្តដំណើរការកម្រិតមធ្យមដោយមិនមានបញ្ហាអ្វីឡើយ។ ដោយមានជំនួយរបស់ពួកគេ អ្នកអាចរៀបចំការបញ្ជូនសញ្ញាជំនួស និងអនុវត្តការងារមួយចំនួនផ្សេងទៀត។ អត្ថប្រយោជន៍របស់ពួកគេគឺភាពឆបគ្នាជាមួយនឹងឧបករណ៍ដោះស្រាយ HTTP ស្តង់ដារ។ ជាលទ្ធផល អ្នកអាចសរសេរកូដសាមញ្ញដែលអាចកែប្រែបាននៅពេលអនាគត។

ការធ្វើការជាមួយក្របខ័ណ្ឌស្មុគ្រស្មាញក្នុងស្ថានភាពធម្មតានឹងតម្រូវឱ្យមានដំណោះស្រាយដែលមិនមានលក្ខណៈស្តង់ដារ ហើយនេះធ្វើឱ្យស្មុគស្មាញយ៉ាងខ្លាំងដល់ការប្រើប្រាស់ឧបករណ៍ដោះស្រាយលំនាំដើម។ ការរួមបញ្ចូលគ្នានៃបណ្ណាល័យលំនាំដើម និងរ៉ោតទ័រសាមញ្ញនឹងគ្រប់គ្រាន់ដើម្បីបង្កើតកម្មវិធីភាគច្រើន។

ដំណើរការសំណួរ

លើសពីនេះ យើងត្រូវការធាតុផ្សំដែលនឹង "ស្តាប់" សម្រាប់ការតភ្ជាប់ចូល និងបញ្ជូនបន្តសំណើទាំងអស់ទៅកាន់អ្នកដោះស្រាយត្រឹមត្រូវ។ http.Server អាចដោះស្រាយយ៉ាងងាយស្រួលជាមួយនឹងកិច្ចការនេះ។

ខាងក្រោមនេះបង្ហាញថាម៉ាស៊ីនមេទទួលខុសត្រូវចំពោះកិច្ចការទាំងអស់ដែលទាក់ទងនឹងការគ្រប់គ្រងការតភ្ជាប់។ ជាឧទាហរណ៍ នេះគឺធ្វើការលើពិធីការ TLS។ ម៉ាស៊ីនមេ HTTP ស្តង់ដារត្រូវបានប្រើដើម្បីអនុវត្តការហៅ http.ListenAndServer ។

ឥឡូវនេះសូមក្រឡេកមើលឧទាហរណ៍ដ៏ស្មុគស្មាញបន្ថែមទៀត។

ការបន្ថែម 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 instance របស់យើង (រហូតមកដល់ពេលនេះ យើងបានប្រើវាតាមលំនាំដើម) ហើយបន្ថែមអ្នកគ្រប់គ្រងទៅម៉ាស៊ីនមេ 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/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 handler មួយជាមួយឧបករណ៍ផ្សេងទៀតត្រូវបានប្រើ ដែលធ្វើឱ្យវាអាចអនុវត្តការផ្ទៀងផ្ទាត់ ការបង្ហាប់ ការកត់ត្រា និងមុខងារមួយចំនួនផ្សេងទៀតបានយ៉ាងឆាប់រហ័ស។

ជាឧទាហរណ៍ ចូរយើងពិចារណាលើចំណុចប្រទាក់ 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)
    })
}

មានរ៉ោតទ័រភាគីទីបីដូចជា ជី ដែលអនុញ្ញាតឱ្យអ្នកពង្រីកមុខងារនៃដំណើរការកម្រិតមធ្យម។

ធ្វើការជាមួយឯកសារឋិតិវន្ត

បណ្ណាល័យស្តង់ដាររបស់ 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 () ។ ម៉ាស៊ីនមេត្រូវបានចាប់ផ្តើមនៅក្នុង 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 ណែនាំ៖

• វគ្គសិក្សាជាក់ស្តែងរយៈពេលពីរឆ្នាំ "ខ្ញុំជាអ្នកបង្កើតគេហទំព័រ PRO".
• វគ្គសិក្សាតាមអ៊ីនធឺណិត "Profession Java Developer".
• វគ្គសិក្សាជាក់ស្តែងឆ្នាំ "អ្នកអភិវឌ្ឍន៍ PHP ពី 0 ដល់ PRO".

ប្រភព: www.habr.com