ການພັດທະນາເຄື່ອງແມ່ຂ່າຍເວັບໃນ Golang - ຈາກງ່າຍດາຍໄປຫາສະລັບສັບຊ້ອນ

ຫ້າປີກ່ອນຫນ້ານີ້ຂ້າພະເຈົ້າໄດ້ເລີ່ມຕົ້ນ ພັດທະນາ Gophish, ນີ້ສະຫນອງໂອກາດທີ່ຈະຮຽນຮູ້ Golang ໄດ້. ຂ້າພະເຈົ້າໄດ້ຮັບຮູ້ວ່າ Go ເປັນພາສາທີ່ມີປະສິດທິພາບ, ປະກອບດ້ວຍຫ້ອງສະຫມຸດຈໍານວນຫຼາຍ. Go ແມ່ນຫຼາກຫຼາຍຊະນິດ: ໂດຍສະເພາະ, ມັນສາມາດຖືກນໍາໃຊ້ເພື່ອພັດທະນາຄໍາຮ້ອງສະຫມັກຂ້າງເຊີຟເວີໂດຍບໍ່ມີບັນຫາໃດໆ.

ບົດຄວາມນີ້ແມ່ນກ່ຽວກັບການຂຽນເຄື່ອງແມ່ຂ່າຍໃນ Go. ເລີ່ມຕົ້ນດ້ວຍສິ່ງທີ່ງ່າຍດາຍເຊັ່ນ "ສະບາຍດີໂລກ!" ແລະສິ້ນສຸດດ້ວຍຄໍາຮ້ອງສະຫມັກທີ່ມີຄວາມສາມາດດັ່ງຕໍ່ໄປນີ້:

- ການນໍາໃຊ້ Let's Encrypt ສໍາລັບ HTTPS.
— ເຮັດ​ວຽກ​ເປັນ router API​.
- ເຮັດ​ວຽກ​ຮ່ວມ​ກັບ​ເຄື່ອງ​ມື​ກາງ​.
- ການ​ປຸງ​ແຕ່ງ​ຂອງ​ໄຟລ​໌ static​.
- ການ​ປິດ​ທີ່​ຖືກ​ຕ້ອງ​.

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 ໃນ Go ແມ່ນປະຕິບັດດັ່ງຕໍ່ໄປນີ້:

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

ຕົວຢ່າງທໍາອິດໃຊ້ຫນ້າທີ່ຜູ້ຊ່ວຍ http.HandleFunc. ມັນຫໍ່ຟັງຊັນອື່ນ, ເຊິ່ງໃຊ້ເວລາ http.ResponseWriter ແລະ http.Request ເຂົ້າໄປໃນ ServeHTTP.

ໃນຄໍາສັບຕ່າງໆອື່ນໆ, handlers ໃນ Golang ແມ່ນນໍາສະເຫນີໃນການໂຕ້ຕອບດຽວ, ເຊິ່ງເຮັດໃຫ້ທາງເລືອກຫຼາຍກັບ programmer. ດັ່ງນັ້ນ, ສໍາລັບຕົວຢ່າງ, ສື່ກາງຖືກປະຕິບັດໂດຍໃຊ້ຕົວຈັດການ, ບ່ອນທີ່ ServeHTTP ທໍາອິດເຮັດບາງສິ່ງບາງຢ່າງແລະຫຼັງຈາກນັ້ນໂທຫາວິທີການ ServeHTTP ຂອງຕົວຈັດການອື່ນ.

ດັ່ງທີ່ໄດ້ກ່າວມາຂ້າງເທິງ, ຜູ້ຈັດການພຽງແຕ່ສ້າງການຕອບສະຫນອງຕໍ່ການຮ້ອງຂໍ. ແຕ່ວ່າຕົວຈັດການສະເພາະໃດທີ່ຄວນຈະຖືກນໍາໃຊ້ໃນຈຸດໃດນຶ່ງໃນເວລາ?

ຮ້ອງຂໍເສັ້ນທາງ

ເພື່ອເຮັດໃຫ້ການເລືອກທີ່ຖືກຕ້ອງ, ໃຊ້ HTTP multiplexer. ໃນຈໍານວນຫ້ອງສະຫມຸດມັນຖືກເອີ້ນວ່າ muxer ຫຼື router, ແຕ່ພວກມັນທັງຫມົດແມ່ນສິ່ງດຽວກັນ. ຫນ້າທີ່ຂອງ multiplexer ແມ່ນການວິເຄາະເສັ້ນທາງການຮ້ອງຂໍແລະເລືອກຕົວຈັດການທີ່ເຫມາະສົມ.

ຖ້າທ່ານຕ້ອງການສະຫນັບສະຫນູນການກໍານົດເສັ້ນທາງທີ່ສັບສົນ, ມັນດີກວ່າທີ່ຈະໃຊ້ຫ້ອງສະຫມຸດຂອງພາກສ່ວນທີສາມ. ບາງ​ສ່ວນ​ທີ່​ກ້າວ​ຫນ້າ​ທີ່​ສຸດ - gorilla/mux и go-chi/chi, ຫ້ອງສະຫມຸດເຫຼົ່ານີ້ເຮັດໃຫ້ມັນເປັນໄປໄດ້ທີ່ຈະປະຕິບັດການປຸງແຕ່ງລະດັບປານກາງໂດຍບໍ່ມີບັນຫາໃດໆ. ດ້ວຍການຊ່ວຍເຫຼືອຂອງພວກເຂົາ, ທ່ານສາມາດຕັ້ງຄ່າການກໍານົດເສັ້ນທາງ wildcard ແລະປະຕິບັດວຽກງານອື່ນໆຈໍານວນຫນຶ່ງ. ປະໂຫຍດຂອງພວກເຂົາແມ່ນຄວາມເຂົ້າກັນໄດ້ກັບຕົວຈັດການ HTTP ມາດຕະຖານ. ດັ່ງນັ້ນ, ທ່ານສາມາດຂຽນລະຫັດງ່າຍໆທີ່ສາມາດດັດແປງໄດ້ໃນອະນາຄົດ.

ການເຮັດວຽກກັບໂຄງຮ່າງການທີ່ສັບສົນໃນສະຖານະການປົກກະຕິຈະຮຽກຮ້ອງໃຫ້ມີການແກ້ໄຂທີ່ບໍ່ແມ່ນມາດຕະຖານ, ແລະນີ້ເຮັດໃຫ້ຄວາມສັບສົນຫຼາຍໃນການນໍາໃຊ້ຕົວຈັດການໃນຕອນຕົ້ນ. ເພື່ອສ້າງຄໍາຮ້ອງສະຫມັກສ່ວນໃຫຍ່, ການປະສົມປະສານຂອງຫ້ອງສະຫມຸດເລີ່ມຕົ້ນແລະ router ແບບງ່າຍດາຍຈະພຽງພໍ.

ການປະມວນຜົນແບບສອບຖາມ

ນອກຈາກນັ້ນ, ພວກເຮົາຕ້ອງການອົງປະກອບທີ່ຈະ "ຟັງ" ສໍາລັບການເຊື່ອມຕໍ່ຂາເຂົ້າແລະປ່ຽນເສັ້ນທາງການຮ້ອງຂໍທັງຫມົດໄປຫາຕົວຈັດການທີ່ຖືກຕ້ອງ. http.Server ສາມາດຈັດການກັບວຽກງານນີ້ໄດ້ຢ່າງງ່າຍດາຍ.

ຕໍ່ໄປນີ້ສະແດງໃຫ້ເຫັນວ່າເຄື່ອງແມ່ຂ່າຍມີຄວາມຮັບຜິດຊອບຕໍ່ຫນ້າວຽກທັງຫມົດທີ່ກ່ຽວຂ້ອງກັບການປຸງແຕ່ງການເຊື່ອມຕໍ່. ຕົວຢ່າງນີ້, ເຮັດວຽກໂດຍໃຊ້ໂປໂຕຄອນ TLS. ເພື່ອປະຕິບັດການໂທ http.ListenAndServer, ເຄື່ອງແມ່ຂ່າຍ HTTP ມາດຕະຖານຖືກນໍາໃຊ້.

ຕອນນີ້ໃຫ້ເບິ່ງຕົວຢ່າງທີ່ສັບສົນຫຼາຍ.

ເພີ່ມໃຫ້ເຂົ້າລະຫັດ

ໂດຍຄ່າເລີ່ມຕົ້ນ, ແອັບພລິເຄຊັນຂອງພວກເຮົາແລ່ນຜ່ານໂປຣໂຕຄໍ HTTP, ແຕ່ແນະນຳໃຫ້ໃຊ້ໂປຣໂຕຄໍ HTTPS. ນີ້ສາມາດເຮັດໄດ້ໂດຍບໍ່ມີບັນຫາໃນ Go. ຖ້າທ່ານໄດ້ຮັບໃບຢັ້ງຢືນແລະລະຫັດສ່ວນຕົວ, ມັນພຽງພໍທີ່ຈະລົງທະບຽນ ListenAndServeTLS ດ້ວຍໃບຢັ້ງຢືນທີ່ຖືກຕ້ອງແລະໄຟລ໌ທີ່ສໍາຄັນ.

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

ເຈົ້າສາມາດເຮັດໄດ້ດີກວ່ານີ້ສະເໝີ.

Let's Encrypt ໃຫ້ໃບຮັບຮອງຟຣີດ້ວຍການຕໍ່ອາຍຸອັດຕະໂນມັດ. ເພື່ອໃຊ້ບໍລິການ, ທ່ານຕ້ອງການຊຸດ 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 ຢ່າງເຕັມທີ່ດ້ວຍການຕໍ່ອາຍຸໃບຢັ້ງຢືນອັດຕະໂນມັດ.

ເພີ່ມເສັ້ນທາງທີ່ກໍາຫນົດເອງ

router ເລີ່ມຕົ້ນທີ່ລວມຢູ່ໃນຫ້ອງສະຫມຸດມາດຕະຖານແມ່ນດີ, ແຕ່ວ່າມັນແມ່ນພື້ນຖານຫຼາຍ. ແອັບພລິເຄຊັນສ່ວນໃຫຍ່ຕ້ອງການການກຳນົດເສັ້ນທາງທີ່ຊັບຊ້ອນກວ່າ, ລວມທັງເສັ້ນທາງທີ່ຊ້ອນກັນ ແລະ ສັນຍາລັກແທນ, ຫຼືຂັ້ນຕອນການກຳນົດຮູບແບບເສັ້ນທາງ ແລະພາລາມິເຕີ.

ໃນກໍລະນີນີ້ມັນເປັນມູນຄ່າທີ່ຈະໃຊ້ແພັກເກັດ gorilla/mux и 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 ສໍາລັບເສັ້ນທາງໃນໄຟລ໌ຕົ້ນຕໍ.

ຫຼັງຈາກນັ້ນ, ພວກເຮົາສາມາດ mount ນີ້ກັບ router ຕົ້ນຕໍຂອງພວກເຮົາພາຍໃຕ້ api / v1 / prefix ກັບຄືນໄປບ່ອນໃນຄໍາຮ້ອງສະຫມັກຕົ້ນຕໍຂອງພວກເຮົາ:

// 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 ກັບເສັ້ນທາງທີ່ສັບສົນເຮັດໃຫ້ມັນເປັນໄປໄດ້ທີ່ຈະເຮັດໃຫ້ໂຄງສ້າງແລະບໍາລຸງຮັກສາຂອງຄໍາຮ້ອງສະຫມັກຂະຫນາດໃຫຍ່, ສະລັບສັບຊ້ອນ.

ເຮັດວຽກກັບຕົວກາງ

Staging ກ່ຽວຂ້ອງກັບການຫໍ່ຕົວຈັດການ 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)
    })
}

ມີ router ຂອງພາກສ່ວນທີສາມ, ເຊັ່ນ: 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(). ເຊີບເວີແມ່ນເລີ່ມຕົ້ນໃນ 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".
• ຫຼັກສູດການສຶກສາອອນໄລນ໌ "ນັກພັດທະນາ Java ມືອາຊີບ".
• ຫຼັກສູດພາກປະຕິບັດ "ນັກພັດທະນາ PHP ຈາກ 0 ເຖິງ PRO".

ແຫຼ່ງຂໍ້ມູນ: www.habr.com