פיתוח שרתי אינטרנט בגולנג - מפשוט למורכב

לפני חמש שנים התחלתי לפתח את Gophish, זה סיפק הזדמנות ללמוד גולאנג. הבנתי ש-Go היא שפה רבת עוצמה, משלימה ספריות רבות. Go הוא רב תכליתי: במיוחד, ניתן להשתמש בו לפיתוח יישומים בצד השרת ללא בעיות.

מאמר זה עוסק בכתיבת שרת ב-Go. נתחיל בדברים פשוטים כמו "שלום עולם!" ונסיים באפליקציה עם היכולות הבאות:

- שימוש ב-Let's Encrypt עבור HTTPS.
- עבודה כנתב API.
- עבודה עם תוכנת ביניים.
- עיבוד קבצים סטטיים.
- כיבוי נכון.

Skillbox ממליצה: קורס מעשי "מפתח Python מאפס".

אנו מזכירים: לכל קוראי Habr - הנחה של 10 רובל בעת הרשמה לכל קורס 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

כאשר אנו מקבלים בקשה, המטפל מנתח אותה ויוצר תגובה. מטפלים ב-Go מיושמים באופן הבא:

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

הדוגמה הראשונה משתמשת בפונקציית העזר http.HandleFunc. זה עוטף פונקציה נוספת, שבתורה לוקחת את http.ResponseWriter ו- http.Request לתוך ServeHTTP.

במילים אחרות, מטפלים בגולנג מוצגים בממשק אחד, מה שנותן הרבה אפשרויות למתכנת. כך, למשל, תוכנת הביניים מיושמת באמצעות מטפל, כאשר ServeHTTP תחילה עושה משהו ואז קורא לשיטת ServeHTTP של מטפל אחר.

כפי שהוזכר לעיל, המטפלים פשוט יוצרים תגובות לבקשות. אבל באיזה מטפל מסוים יש להשתמש בנקודת זמן מסוימת?

בקש ניתוב

כדי לעשות את הבחירה הנכונה, השתמש במרבב HTTP. במספר ספריות זה נקרא muxer או נתב, אבל כולם אותו דבר. תפקידו של המרבה הוא לנתח את נתיב הבקשה ולבחור את המטפל המתאים.

אם אתה זקוק לתמיכה בניתוב מורכב, עדיף להשתמש בספריות של צד שלישי. כמה מהמתקדמים ביותר - גורילה/מוקס и גו-צ'י/צ'י, ספריות אלו מאפשרות ליישם עיבוד ביניים ללא בעיות. בעזרתם, תוכל להגדיר ניתוב תווים כלליים ולבצע מספר משימות אחרות. היתרון שלהם הוא תאימות עם מטפלי 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() . השרת מופעל ב-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".
• קורס חינוכי מקוון "מקצועי מפתח ג'אווה".
• קורס מעשי בן שנה "מפתח PHP מ-0 ל-PRO".

מקור: www.habr.com