ಗೋಲಾಂಗ್‌ನಲ್ಲಿ ವೆಬ್ ಸರ್ವರ್ ಅಭಿವೃದ್ಧಿ - ಸರಳದಿಂದ ಸಂಕೀರ್ಣಕ್ಕೆ

ಐದು ವರ್ಷಗಳ ಹಿಂದೆ ನಾನು ಪ್ರಾರಂಭಿಸಿದೆ ಗೋಫಿಶ್ ಅನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಿ, ಇದು ಗೋಲಾಂಗ್ ಕಲಿಯಲು ಅವಕಾಶವನ್ನು ಒದಗಿಸಿತು. ಗೋ ಒಂದು ಶಕ್ತಿಯುತ ಭಾಷೆ ಎಂದು ನಾನು ಅರಿತುಕೊಂಡೆ, ಅನೇಕ ಗ್ರಂಥಾಲಯಗಳಿಂದ ಪೂರಕವಾಗಿದೆ. ಗೋ ಬಹುಮುಖವಾಗಿದೆ: ನಿರ್ದಿಷ್ಟವಾಗಿ, ಯಾವುದೇ ಸಮಸ್ಯೆಗಳಿಲ್ಲದೆ ಸರ್ವರ್-ಸೈಡ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಲು ಇದನ್ನು ಬಳಸಬಹುದು.

ಈ ಲೇಖನವು ಗೋದಲ್ಲಿ ಸರ್ವರ್ ಅನ್ನು ಬರೆಯುವ ಬಗ್ಗೆ. "ಹಲೋ ವರ್ಲ್ಡ್!" ನಂತಹ ಸರಳ ವಿಷಯಗಳೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸೋಣ ಮತ್ತು ಕೆಳಗಿನ ಸಾಮರ್ಥ್ಯಗಳೊಂದಿಗೆ ಅಪ್ಲಿಕೇಶನ್‌ನೊಂದಿಗೆ ಕೊನೆಗೊಳ್ಳೋಣ:

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

ಇದರ ನಂತರ, ನೀವು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರನ್ ಮಾಡಿದರೆ ಮತ್ತು ಪುಟವನ್ನು ತೆರೆದರೆ ಸ್ಥಳೀಯ ಹೋಸ್ಟ್, ನಂತರ ನೀವು ತಕ್ಷಣವೇ "ಹಲೋ, ವರ್ಲ್ಡ್!" ಎಂಬ ಪಠ್ಯವನ್ನು ನೋಡುತ್ತೀರಿ. (ಎಲ್ಲವೂ ಸರಿಯಾಗಿ ಕೆಲಸ ಮಾಡಿದರೆ, ಸಹಜವಾಗಿ).

ನಾವು ನಂತರ ಹಲವಾರು ಬಾರಿ ಹ್ಯಾಂಡ್ಲರ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ, ಆದರೆ ಮೊದಲು ಎಲ್ಲವೂ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳೋಣ.

net/http

ಉದಾಹರಣೆಯು ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಬಳಸಿದೆ net/http, ಇದು ಸರ್ವರ್‌ಗಳು ಮತ್ತು HTTP ಕ್ಲೈಂಟ್‌ಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಲು Go ನಲ್ಲಿನ ಪ್ರಾಥಮಿಕ ಸಾಧನವಾಗಿದೆ. ಕೋಡ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ಮೂರು ಪ್ರಮುಖ ಅಂಶಗಳ ಅರ್ಥವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳೋಣ: http.Handler, http.ServeMux ಮತ್ತು http.Server.

HTTP ಹ್ಯಾಂಡ್ಲರ್‌ಗಳು

ನಾವು ವಿನಂತಿಯನ್ನು ಸ್ವೀಕರಿಸಿದಾಗ, ನಿರ್ವಾಹಕರು ಅದನ್ನು ವಿಶ್ಲೇಷಿಸುತ್ತಾರೆ ಮತ್ತು ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ರಚಿಸುತ್ತಾರೆ. ಗೋದಲ್ಲಿನ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳನ್ನು ಈ ಕೆಳಗಿನಂತೆ ಅಳವಡಿಸಲಾಗಿದೆ:

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 ಪ್ರೋಟೋಕಾಲ್ ಅನ್ನು ಬಳಸಲು ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ. ಗೋದಲ್ಲಿ ಸಮಸ್ಯೆಗಳಿಲ್ಲದೆ ಇದನ್ನು ಮಾಡಬಹುದು. ನೀವು ಪ್ರಮಾಣಪತ್ರ ಮತ್ತು ಖಾಸಗಿ ಕೀಲಿಯನ್ನು ಸ್ವೀಕರಿಸಿದ್ದರೆ, ಸರಿಯಾದ ಪ್ರಮಾಣಪತ್ರ ಮತ್ತು ಪ್ರಮುಖ ಫೈಲ್‌ಗಳೊಂದಿಗೆ 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)
    })
}

ಮಿಡಲ್‌ವೇರ್ ಕಾರ್ಯವನ್ನು ವಿಸ್ತರಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುವ ಚಿಯಂತಹ ಮೂರನೇ ವ್ಯಕ್ತಿಯ ಮಾರ್ಗನಿರ್ದೇಶಕಗಳು ಇವೆ.

ಸ್ಥಿರ ಫೈಲ್ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಿ

ಗೋ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಲೈಬ್ರರಿಯು ಚಿತ್ರಗಳು, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮತ್ತು 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 ಸರ್ವರ್ಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಸ್ಕಿಲ್‌ಬಾಕ್ಸ್ ಶಿಫಾರಸು ಮಾಡುತ್ತದೆ:

• ಎರಡು ವರ್ಷಗಳ ಪ್ರಾಯೋಗಿಕ ಕೋರ್ಸ್ "ನಾನು PRO ವೆಬ್ ಡೆವಲಪರ್".
• ಶೈಕ್ಷಣಿಕ ಆನ್‌ಲೈನ್ ಕೋರ್ಸ್ "ವೃತ್ತಿ ಜಾವಾ ಡೆವಲಪರ್".
• ಪ್ರಾಯೋಗಿಕ ಒಂದು ವರ್ಷದ ಕೋರ್ಸ್ "0 ರಿಂದ PRO ವರೆಗೆ PHP ಡೆವಲಪರ್".

ಮೂಲ: www.habr.com