āĻ—ā§‹āϞāĻ‚-āĻ āĻ“āϝāĻŧ⧇āĻŦ āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇āϰ āĻŦāĻŋāĻ•āĻžāĻļ - āϏāĻšāϜ āĻĨ⧇āϕ⧇ āϜāϟāĻŋāϞ āĻĒāĻ°ā§āϝāĻ¨ā§āϤ

āĻ—ā§‹āϞāĻ‚-āĻ āĻ“āϝāĻŧ⧇āĻŦ āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇āϰ āĻŦāĻŋāĻ•āĻžāĻļ - āϏāĻšāϜ āĻĨ⧇āϕ⧇ āϜāϟāĻŋāϞ āĻĒāĻ°ā§āϝāĻ¨ā§āϤ

āĻĒāĻžāρāϚ āĻŦāĻ›āϰ āφāϗ⧇ āĻļ⧁āϰ⧁ āĻ•āϰ⧇āĻ›āĻŋāϞāĻžāĻŽ Gophish āĻŦāĻŋāĻ•āĻžāĻļ, āĻāϟāĻŋ āĻ—ā§‹āϞāĻ‚ āĻļ⧇āĻ–āĻžāϰ āϏ⧁āϝ⧋āĻ— āĻ•āϰ⧇ āĻĻāĻŋāϝāĻŧ⧇āϛ⧇āĨ¤ āφāĻŽāĻŋ āĻŦ⧁āĻāϤ⧇ āĻĒ⧇āϰ⧇āĻ›āĻŋ āϝ⧇ āĻ—ā§‹ āĻāĻ•āϟāĻŋ āĻļāĻ•ā§āϤāĻŋāĻļāĻžāϞ⧀ āĻ­āĻžāώāĻž, āĻ…āύ⧇āĻ• āϞāĻžāχāĻŦā§āϰ⧇āϰāĻŋ āĻĻā§āĻŦāĻžāϰāĻž āĻĒāϰāĻŋāĻĒā§‚āϰāĻ•āĨ¤ Go āĻŦāĻšā§āĻŽā§āĻ–ā§€: āĻŦāĻŋāĻļ⧇āώ āĻ•āϰ⧇, āĻāϟāĻŋ āϕ⧋āύ⧋ āϏāĻŽāĻ¸ā§āϝāĻž āĻ›āĻžāĻĄāĻŧāĻžāχ āϏāĻžāĻ°ā§āĻ­āĻžāϰ-āϏāĻžāχāĻĄ āĻ…ā§āϝāĻžāĻĒā§āϞāĻŋāϕ⧇āĻļāύ āĻŦāĻŋāĻ•āĻžāĻļ āĻ•āϰāϤ⧇ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āϝ⧇āϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

āĻāχ āύāĻŋāĻŦāĻ¨ā§āϧāϟāĻŋ Go-āϤ⧇ āĻāĻ•āϟāĻŋ āϏāĻžāĻ°ā§āĻ­āĻžāϰ āϞ⧇āĻ–āĻžāϰ āĻŦāĻŋāώāϝāĻŧ⧇āĨ¤ āφāϏ⧁āύ "āĻšā§āϝāĻžāϞ⧋ āĻ“āϝāĻŧāĻžāĻ°ā§āĻ˛ā§āĻĄ!" āĻāϰ āĻŽāϤ⧋ āϏāĻžāϧāĻžāϰāĻŖ āϜāĻŋāύāĻŋāϏ āĻĻāĻŋāϝāĻŧ⧇ āĻļ⧁āϰ⧁ āĻ•āϰāĻŋ āĻāĻŦāĻ‚ āύāĻŋāĻŽā§āύāϞāĻŋāĻ–āĻŋāϤ āĻ•ā§āώāĻŽāϤāĻž āϏāĻš āĻāĻ•āϟāĻŋ āĻ…ā§āϝāĻžāĻĒā§āϞāĻŋāϕ⧇āĻļāύ āĻĻāĻŋāϝāĻŧ⧇ āĻļ⧇āώ āĻ•āϰāĻŋ:

- āϞ⧇āϟāϏ āĻāύāĻ•ā§āϰāĻŋāĻĒā§āϟ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ HTTPS āĻāϰ āϜāĻ¨ā§āϝāĨ¤
— āĻāĻĒāĻŋāφāχ āϰāĻžāωāϟāĻžāϰ āĻšāĻŋāϏ⧇āĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰāĻžāĨ¤
- āĻŽāĻŋāĻĄāϞāĻ“āϝāĻŧā§āϝāĻžāϰ⧇āϰ āϏāĻžāĻĨ⧇ āĻ•āĻžāϜ āĻ•āϰāĻžāĨ¤
- āĻ¸ā§āĻŸā§āϝāĻžāϟāĻŋāĻ• āĻĢāĻžāχāϞ⧇āϰ āĻĒā§āϰāĻ•ā§āϰāĻŋāϝāĻŧāĻžāĻ•āϰāĻŖāĨ¤
- āϏāĻ āĻŋāĻ• āĻļāĻžāϟāĻĄāĻžāωāύāĨ¤

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 āĻŽāĻžāĻ˛ā§āϟāĻŋāĻĒā§āϞ⧇āĻ•ā§āϏāĻžāϰ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧁āύāĨ¤ āĻŦ⧇āĻļ āĻ•āϝāĻŧ⧇āĻ•āϟāĻŋ āϞāĻžāχāĻŦā§āϰ⧇āϰāĻŋāϤ⧇ āĻāϕ⧇ āĻŦāϞāĻž āĻšāϝāĻŧ āĻŽā§āĻ•ā§āϏāĻžāϰ āĻŦāĻž āϰāĻžāωāϟāĻžāϰ, āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻāϗ⧁āϞāĻŋ āϏāĻŦ āĻāĻ•āχ āϜāĻŋāύāĻŋāϏāĨ¤ āĻŽāĻžāĻ˛ā§āϟāĻŋāĻĒā§āϞ⧇āĻ•ā§āϏāĻžāϰ⧇āϰ āĻ•āĻžāϜ āĻšāϞ āĻ…āύ⧁āϰ⧋āϧ⧇āϰ āĻĒāĻĨ āĻŦāĻŋāĻļā§āϞ⧇āώāĻŖ āĻ•āϰāĻž āĻāĻŦāĻ‚ āωāĻĒāϝ⧁āĻ•ā§āϤ āĻšā§āϝāĻžāĻ¨ā§āĻĄāϞāĻžāϰ āύāĻŋāĻ°ā§āĻŦāĻžāϚāύ āĻ•āϰāĻžāĨ¤

āφāĻĒāύāĻžāϰ āϝāĻĻāĻŋ āϜāϟāĻŋāϞ āϰāĻžāωāϟāĻŋāĻ‚āϝāĻŧ⧇āϰ āϜāĻ¨ā§āϝ āϏāĻŽāĻ°ā§āĻĨāύ⧇āϰ āĻĒā§āϰāϝāĻŧā§‹āϜāύ āĻšāϝāĻŧ āϤāĻŦ⧇ āϤ⧃āϤ⧀āϝāĻŧ āĻĒāĻ•ā§āώ⧇āϰ āϞāĻžāχāĻŦā§āϰ⧇āϰāĻŋāϗ⧁āϞāĻŋ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻ­āĻžāϞāĨ¤ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āωāĻ¨ā§āύāϤ āĻ•āĻŋāϛ⧁ - āĻ—āϰāĻŋāϞāĻž/āĻŽā§āĻ•ā§āϏ и go-chi/chi, āĻāχ āϞāĻžāχāĻŦā§āϰ⧇āϰāĻŋ āϕ⧋āύ⧋ āϏāĻŽāĻ¸ā§āϝāĻž āĻ›āĻžāĻĄāĻŧāĻžāχ āĻŽāĻ§ā§āϝāĻŦāĻ°ā§āϤ⧀ āĻĒā§āϰāĻ•ā§āϰāĻŋāϝāĻŧāĻžāĻ•āϰāĻŖ āĻŦāĻžāĻ¸ā§āϤāĻŦāĻžāϝāĻŧāύ āĻ•āϰāĻž āϏāĻŽā§āĻ­āĻŦ āĻ•āϰ⧇ āϤ⧋āϞ⧇āĨ¤ āϤāĻžāĻĻ⧇āϰ āϏāĻžāĻšāĻžāĻ¯ā§āϝ⧇, āφāĻĒāύāĻŋ āĻ“āϝāĻŧāĻžāχāĻ˛ā§āĻĄāĻ•āĻžāĻ°ā§āĻĄ āϰāĻžāωāϟāĻŋāĻ‚ āĻ•āύāĻĢāĻŋāĻ—āĻžāϰ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āύ āĻāĻŦāĻ‚ āĻ…āĻ¨ā§āϝāĻžāĻ¨ā§āϝ āĻ…āύ⧇āĻ•āϗ⧁āϞāĻŋ āĻ•āĻžāϜ āϏāĻŽā§āĻĒāĻžāĻĻāύ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āύāĨ¤ āϤāĻžāĻĻ⧇āϰ āϏ⧁āĻŦāĻŋāϧāĻž āĻšāϞ āĻ¸ā§āĻŸā§āϝāĻžāĻ¨ā§āĻĄāĻžāĻ°ā§āĻĄ HTTP āĻšā§āϝāĻžāĻ¨ā§āĻĄāϞāĻžāϰ⧇āϰ āϏāĻžāĻĨ⧇ āϏāĻžāĻŽāĻžā§āϜāĻ¸ā§āϝāĻĒā§‚āĻ°ā§āĻŖāĨ¤ āĻĢāϞāĻ¸ā§āĻŦāϰ⧂āĻĒ, āφāĻĒāύāĻŋ āϏāĻšāϜ āϕ⧋āĻĄ āϞāĻŋāĻ–āϤ⧇ āĻĒāĻžāϰ⧇āύ āϝāĻž āĻ­āĻŦāĻŋāĻˇā§āϝāϤ⧇ āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāύ āĻ•āϰāĻž āϝ⧇āϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

āĻāĻ•āϟāĻŋ āĻ¸ā§āĻŦāĻžāĻ­āĻžāĻŦāĻŋāĻ• āĻĒāϰāĻŋāĻ¸ā§āĻĨāĻŋāϤāĻŋāϤ⧇ āϜāϟāĻŋāϞ āĻ•āĻžāĻ āĻžāĻŽā§‹āϰ āϏāĻžāĻĨ⧇ āĻ•āĻžāϜ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻ…-āĻŽāĻžāύāĻ• āϏāĻŽāĻžāϧāĻžāύ⧇āϰ āĻĒā§āϰāϝāĻŧā§‹āϜāύ āĻšāĻŦ⧇ āĻāĻŦāĻ‚ āĻāϟāĻŋ āĻĄāĻŋāĻĢāĻ˛ā§āϟ āĻšā§āϝāĻžāĻ¨ā§āĻĄāϞāĻžāϰ⧇āϰ āĻŦā§āϝāĻŦāĻšāĻžāϰāϕ⧇ āωāĻ˛ā§āϞ⧇āĻ–āϝ⧋āĻ—ā§āϝāĻ­āĻžāĻŦ⧇ āϜāϟāĻŋāϞ āĻ•āϰ⧇ āϤ⧋āϞ⧇āĨ¤ āĻŦ⧇āĻļāĻŋāϰāĻ­āĻžāĻ— āĻ…ā§āϝāĻžāĻĒā§āϞāĻŋāϕ⧇āĻļāύ āϤ⧈āϰāĻŋ āĻ•āϰāϤ⧇, āĻĄāĻŋāĻĢāĻ˛ā§āϟ āϞāĻžāχāĻŦā§āϰ⧇āϰāĻŋ āĻāĻŦāĻ‚ āĻāĻ•āϟāĻŋ āϏāĻžāϧāĻžāϰāĻŖ āϰāĻžāωāϟāĻžāϰ⧇āϰ āϏāĻ‚āĻŽāĻŋāĻļā§āϰāĻŖ āϝāĻĨ⧇āĻˇā§āϟ āĻšāĻŦ⧇āĨ¤

āĻ•ā§āϝ⧋āϝāĻŧāĻžāϰ⧀ āĻĒā§āϰāϏ⧇āϏāĻŋāĻ‚

āωāĻĒāϰāĻ¨ā§āϤ⧁, āφāĻŽāĻžāĻĻ⧇āϰ āĻāĻ•āϟāĻŋ āωāĻĒāĻžāĻĻāĻžāύ āĻĒā§āϰāϝāĻŧā§‹āϜāύ āϝāĻž āχāύāĻ•āĻžāĻŽāĻŋāĻ‚ āϏāĻ‚āϝ⧋āĻ—āϗ⧁āϞāĻŋāϰ āϜāĻ¨ā§āϝ "āĻļ⧁āύāĻŦ⧇" āĻāĻŦāĻ‚ āϏāĻ āĻŋāĻ• āĻšā§āϝāĻžāĻ¨ā§āĻĄāϞāĻžāϰ⧇āϰ āĻ•āĻžāϛ⧇ āϏāĻŽāĻ¸ā§āϤ āĻ…āύ⧁āϰ⧋āϧ āĻĒ⧁āύāσāύāĻŋāĻ°ā§āĻĻ⧇āĻļ āĻ•āϰāĻŦ⧇⧎ http.Server āϏāĻšāĻœā§‡āχ āĻāχ āĻ•āĻžāϜāϟāĻŋ āĻĒāϰāĻŋāϚāĻžāϞāύāĻž āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

āύāĻŋāĻŽā§āύāϞāĻŋāĻ–āĻŋāϤ āĻĻ⧇āĻ–āĻžāϝāĻŧ āϝ⧇ āϏāĻžāĻ°ā§āĻ­āĻžāϰ āϏāĻ‚āϝ⧋āĻ— āĻĒā§āϰāĻ•ā§āϰāĻŋāϝāĻŧāĻžāĻ•āϰāϪ⧇āϰ āϏāĻžāĻĨ⧇ āϏāĻŽā§āĻĒāĻ°ā§āĻ•āĻŋāϤ āϏāĻŽāĻ¸ā§āϤ āĻ•āĻžāĻœā§‡āϰ āϜāĻ¨ā§āϝ āĻĻāĻžāϝāĻŧā§€āĨ¤ āĻāϟāĻŋ, āωāĻĻāĻžāĻšāϰāĻŖāĻ¸ā§āĻŦāϰ⧂āĻĒ, TLS āĻĒā§āϰ⧋āĻŸā§‹āĻ•āϞ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇āĨ¤ http.ListenAndServer āĻ•āϞāϟāĻŋ āĻŦāĻžāĻ¸ā§āϤāĻŦāĻžāϝāĻŧāύ āĻ•āϰāϤ⧇, āĻāĻ•āϟāĻŋ āφāĻĻāĻ°ā§āĻļ HTTP āϏāĻžāĻ°ā§āĻ­āĻžāϰ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤

āĻāĻ–āύ āφāϰāĻ“ āϜāϟāĻŋāϞ āωāĻĻāĻžāĻšāϰāĻŖ āĻĻ⧇āĻ–āĻž āϝāĻžāĻ•āĨ¤

āϝ⧋āĻ— āĻ•āϰāĻž āϝāĻžāĻ• āĻāύāĻ•ā§āϰāĻŋāĻĒā§āϟ āĻ•āϰāĻž āϝāĻžāĻ•

āĻĄāĻŋāĻĢāĻ˛ā§āϟāϰ⧂āĻĒ⧇, āφāĻŽāĻžāĻĻ⧇āϰ āĻ…ā§āϝāĻžāĻĒā§āϞāĻŋāϕ⧇āĻļāύāϟāĻŋ HTTP āĻĒā§āϰ⧋āĻŸā§‹āĻ•āϞ⧇āϰ āωāĻĒāϰ āϚāϞ⧇, āϤāĻŦ⧇ āĻāϟāĻŋ HTTPS āĻĒā§āϰ⧋āĻŸā§‹āĻ•āϞ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻžāϰ āĻĒāϰāĻžāĻŽāĻ°ā§āĻļ āĻĻ⧇āĻ“āϝāĻŧāĻž āĻšāϝāĻŧāĨ¤ āĻāϟāĻŋ Go āĻ āϏāĻŽāĻ¸ā§āϝāĻž āĻ›āĻžāĻĄāĻŧāĻžāχ āĻ•āϰāĻž āϝ⧇āϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ āφāĻĒāύāĻŋ āϝāĻĻāĻŋ āĻāĻ•āϟāĻŋ āĻļāĻ‚āϏāĻžāĻĒāĻ¤ā§āϰ āĻāĻŦāĻ‚ āĻŦā§āϝāĻ•ā§āϤāĻŋāĻ—āϤ āϕ⧀ āĻĒ⧇āϝāĻŧ⧇ āĻĨāĻžāϕ⧇āύ āϤāĻŦ⧇ āϏāĻ āĻŋāĻ• āĻļāĻ‚āϏāĻžāĻĒāĻ¤ā§āϰ āĻāĻŦāĻ‚ āϕ⧀ āĻĢāĻžāχāϞāϗ⧁āϞāĻŋāϰ āϏāĻžāĻĨ⧇ ListenAndServeTLS āύāĻŋāĻŦāĻ¨ā§āϧāύ āĻ•āϰāĻž āϝāĻĨ⧇āĻˇā§āϟāĨ¤

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

āφāĻĒāύāĻŋ āϏāĻŦāϏāĻŽāϝāĻŧ āĻ­āĻžāϞ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āύ.

āĻāϰ āĻāύāĻ•ā§āϰāĻŋāĻĒā§āϟ āϝāĻžāĻ• āĻ¸ā§āĻŦāϝāĻŧāĻ‚āĻ•ā§āϰāĻŋāϝāĻŧ āĻĒ⧁āύāĻ°ā§āύāĻŦā§€āĻ•āϰāĻŖ āϏāĻš āĻŦāĻŋāύāĻžāĻŽā§‚āĻ˛ā§āϝ⧇ āĻļāĻ‚āϏāĻžāĻĒāĻ¤ā§āϰ āĻĒā§āϰāĻĻāĻžāύ āĻ•āϰ⧇āĨ¤ āĻĒāϰāĻŋāώ⧇āĻŦāĻžāϟāĻŋ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ, āφāĻĒāύāĻžāϰ āĻāĻ•āϟāĻŋ āĻĒā§āϝāĻžāϕ⧇āϜ āĻĒā§āϰāϝāĻŧā§‹āϜāύ autocert.

āĻāϟāĻŋ āĻ•āύāĻĢāĻŋāĻ—āĻžāϰ āĻ•āϰāĻžāϰ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āϏāĻšāϜ āωāĻĒāĻžāϝāĻŧ āĻšāϞ autocert.NewListener āĻĒāĻĻā§āϧāϤāĻŋāϟāĻŋ http.Serve-āĻāϰ āϏāĻžāĻĨ⧇ āĻāĻ•āĻ¤ā§āϰ⧇ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻžāĨ¤ 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, āϝāĻž āφāĻĒāύāĻžāϕ⧇ āĻŽāĻŋāĻĄāϞāĻ“āϝāĻŧā§āϝāĻžāϰ āĻ•āĻžāĻ°ā§āϝāĻ•āĻžāϰāĻŋāϤāĻž āĻĒā§āϰāϏāĻžāϰāĻŋāϤ āĻ•āϰāϤ⧇ āĻĻ⧇āϝāĻŧāĨ¤

āĻ¸ā§āĻŸā§āϝāĻžāϟāĻŋāĻ• āĻĢāĻžāχāϞ⧇āϰ āϏāĻžāĻĨ⧇ āĻ•āĻžāϜ āĻ•āϰāĻž

Go āĻ¸ā§āĻŸā§āϝāĻžāĻ¨ā§āĻĄāĻžāĻ°ā§āĻĄ āϞāĻžāχāĻŦā§āϰ⧇āϰāĻŋāϤ⧇ āĻ›āĻŦāĻŋ, āϜāĻžāĻ­āĻžāĻ¸ā§āĻ•ā§āϰāĻŋāĻĒā§āϟ āĻāĻŦāĻ‚ 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 āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇āϰ āĻ—ā§āϰ⧇āϏāĻĢ⧁āϞ āĻļāĻžāϟāĻĄāĻžāωāύ āύāĻžāĻŽā§‡ āĻāĻ•āϟāĻŋ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝ āϰāϝāĻŧ⧇āϛ⧇āĨ¤ āĻāϟāĻŋ 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 āϏ⧁āĻĒāĻžāϰāĻŋāĻļ āĻ•āϰ⧇:

āωāĻ¤ā§āϏ: www.habr.com

DDoS āϏ⧁āϰāĻ•ā§āώāĻž, VPS VDS āϏāĻžāĻ°ā§āĻ­āĻžāϰ āϏāĻš āϏāĻžāχāϟāϗ⧁āϞāĻŋāϰ āϜāĻ¨ā§āϝ āύāĻŋāĻ°ā§āĻ­āϰāϝ⧋āĻ—ā§āϝ āĻšā§‹āĻ¸ā§āϟāĻŋāĻ‚ āĻ•āĻŋāύ⧁āύ đŸ”Ĩ DDoS āϏ⧁āϰāĻ•ā§āώāĻž āϏāĻš āύāĻŋāĻ°ā§āĻ­āϰāϝ⧋āĻ—ā§āϝ āĻ“āϝāĻŧ⧇āĻŦāϏāĻžāχāϟ āĻšā§‹āĻ¸ā§āϟāĻŋāĻ‚ āĻ•āĻŋāύ⧁āύ, VPS VDS āϏāĻžāĻ°ā§āĻ­āĻžāϰ | ProHoster