מיכל יישומי Go עם Docker

Docker היא טכנולוגיית המכולות הפופולרית ביותר בשל הפשטות וקלות השימוש שלה. Docker משחרר את הלחץ של בעיות ניידות בפיתוח והפצת תוכנה. אתה יכול לפרוס את מכולות ה- Docker שלך לרוב ספקי שירותי הענן.

מיכל יישומי Go שלך עם Docker יכול לעזור לך להבטיח פריסה עקבית ואמינה בסביבות שונות. אתה יכול לפרוס את אפליקציות ה-Go שלך בסביבות שונות כמו פיתוח, הבמה והפקה. מכולות Docker הן קלות משקל ותופסות פחות מקום ממכונות וירטואליות מסורתיות. זה יכול לחסוך לך כסף בעלויות אירוח, וזה יכול גם להפוך את הפריסה שלך למהירה יותר.

הגדרת שרת אינטרנט פשוט ב-Go

הספרייה הסטנדרטית של Go מכילה את החבילות שתצטרכו כדי להגדיר שרת אינטרנט פשוט.

ראשית, ייבא את http, עֵץ, ו json חבילות. אתה תשתמש חבילת http של Go כדי להגדיר את השרת ו לקבל לבקש נקודת קצה. ה עֵץ חבילה לרישום שגיאות אפשריות למסוף שלך. ה חבילת json לקידוד struct ל-JSON עבור נקודת הקצה של ה-API.

יְבוּא (
"קידוד/json"
"עֵץ"
"נטו/http"
)

אתה יכול לקודד מופע struct בתור JSON ללקוח כתגובה המבוססת על תקפות הבקשה כך:

סוּג הוֹדָעָה struct {
 תְגוּבָה חוּט`json:"תגובה"`
 תיאור חוּט`json:"תיאור"`
}

פונקציית המטפל תחזיר הודעה מוצלחת ללקוח אם הבקשה לנקודת הקצה היא א לקבל בַּקָשָׁה.

// dockerTestEndpoint מטפל בנקודת הקצה של ה-API לבדיקת קישוריות Docker
funcdockerTestEndpoint(כותב http. כותב תגובה, בקשה *http. בַּקָשָׁה) {
// הגדר את כותרת התגובה כדי לציין תוכן JSON
 סוֹפֵר. Header().Set("סוג תוכן,""application/json")
// אם שיטת הבקשה היא GET
אם בַּקָשָׁה. שיטה == "לקבל" {
// הגדר את קוד סטטוס התגובה ל-200 אישור
 סוֹפֵר. WriteHeader (http. סטטוס אישור)
// צור מבנה הודעה לתגובה מוצלחת
 הודעה := הודעה{
 תְגוּבָה: "מוּצלָח",
 תיאור: "הגעת בהצלחה לנקודת הקצה של ה-API" +
"ממכולת הדוקר שלך",
 }
// קודד את ההודעה בתור JSON ושלח אותה כתגובה
 טעות := json. NewEncoder (סופר).Encode(&message)
אם טעות != אֶפֶס {
לַחֲזוֹר
 }
 } אַחֵר {
// אם שיטת הבקשה אינה GET
// הגדר את קוד סטטוס התגובה ל-400 Bad Request
 סוֹפֵר. WriteHeader (http. StatusBadRequest)
// צור מבנה הודעה לתגובת בקשה שגויה
 הודעה := הודעה{
 תְגוּבָה: "בקשה גרועה",
 תיאור: "הגעת בהצלחה לנקודת הקצה של ה-API מה" +
"דוקר קונטיינר, אבל הגשת בקשה גרועה",
 }
// קודד את ההודעה בתור JSON ושלח אותה כתגובה
 טעות := json. NewEncoder (סופר).Encode(&message)
אם טעות != אֶפֶס {
לַחֲזוֹר
 }
 }
}

אתה מגדיר את פונקציית המטפל בפונקציה הראשית עם המסלול כ /api/docker/go. ה dockerTestEndpoint פונקציית המטפל מאמתת שהבקשה למטפל היא בקשת GET. אם זו בקשת GET, היא מקודדת מופע מופע הוֹדָעָה התקן מופע ללקוח בהתבסס על מצב הבקשה.

כך תוכל להעלות את פונקציית המטפל במסלול ולהגדיר את השרת כך שיפעל ביציאה 8080:

funcרָאשִׁי() {
// רשום את פונקציית המטפל 'docerTestEndpoint'
// לטיפול בבקשות עבור כתובת האתר "/api/docker/go".
 http. HandleFunc("/api/docer/go", dockerTestEndpoint)
// הפעל את שרת ה-HTTP והקשב לבקשות נכנסות ביציאה 8080.
 טעות := http. ListenAndServe(":8080", אֶפֶס)
אם טעות != אֶפֶס {
 עֵץ. פתאלן("יש שגיאה בשרת:", טעות)
 }
}

ה רָאשִׁי הפונקציה היא נקודת הכניסה של השרת, שמאזינה ביציאה 8080. ה HandleFunc השיטה מעלה את המסלולים בפונקציית המטפל. ה ListenAndServe השיטה מפעילה את השרת ביציאת המארח המקומית שצוינה 8080.

תחילת העבודה עם יישומי ה-Go שלך במכולות עם Docker

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

הפעל פקודה זו במסוף של סביבת העבודה שלך כדי ליצור Dockerfile.

גע ב-Dockerfile

תציין את הפקודות לבניית תמונת Docker שלך ב- Dockerfile.

אם יש קבצים שאתה רוצה להפריד מתמונת Docker שלך, אתה יכול להשתמש ב-a .docerignore קוֹבֶץ. ה .docerignore קבצים עובדים בדיוק כמו .gitignore קבצים.

גע ב-.docerignore

לאחר מכן, תציין פקודות בנייה ב-Dockerfile שלך ​​כדי לאכלס את האפליקציות שלך.

הגדרת פקודות ב- Dockerfile

קבצי Docker ניתנים להתאמה אישית על סמך מפרטי הפרויקט שלך. אתה תגדיר פקודות לבניית תמונת הבסיס לבניית האפליקציה.

הנה דוגמה לתוכן של Dockerfile שבונה את שרת האינטרנט למעלה:

# השתמש בתמונת בסיס של גולנג
מ golang: האחרון
# הגדר את ספריית העבודה בתוך הקונטיינר
WORKDIR /app
# מעתיק את כל הקבצים בספרייה המקומית לספריית העבודה במיכל
עותק. .
# הורד את התלות של מודול Go
לָרוּץ go mod הורדה
# בנה את אפליקציית Go
לָרוּץ לך לבנות אפליקציית -o
# הגדר את נקודת הכניסה עבור היישום
נקודת כניסה ["./app"]

ה-Dockerfile משתמש golang: האחרון תמונת בסיס, כדי לבנות את האפליקציה לאחר הגדרת ספריית העבודה ל /app.

ה-Dockerfile מעתיק את הקבצים עם ה- עותק פקודה והורדות תלות עם לָרוּץ פקודה.

הקובץ מציין פעולת בנייה והרצה עם ה- לָרוּץ הפקודה, ואז מגדיר את הפקודה לפעול כשהמכולה מתחילה ב- CMD פקודה.

שמור את ה-Dockerfile באותה ספרייה כמו שלך go.mod ו main.go קבצים; ואז הפעל את הפקודה הזו כדי לבנות תמונת Docker מ-Dockerfile זה:

docker build -t Golang Tutorial .

הפקודה לעיל תיצור תמונת Docker עם התג לימוד גולנג. אתה יכול להפעיל מיכל עם הפקודה הזו:

docker run -p 8080:8080 golangtutorial

הפקודה ממפה את יציאה 8080 מהמכולה ליציאה 8080 במארח המקומי של המחשב המארח. אתה יכול לבקש את השרת הפועל בקונטיינר Docker מהמחשב המארח.

הנה התוצאה מ שליחת בקשת ה-CURL לשרת, הפעם פועל ב-Docker:

אתה יכול להשתמש ב-Docker Compose עבור תזמורת מיכל

Docker Compose הוא כלי שבו אתה יכול להשתמש כדי לתזמר (לעבוד עם הרבה) מכולות Docker. Docker Compose מאפשר לך להגדיר יישום ריבוי מיכלים בקובץ YAML יחיד. אתה יכול להפעיל ולנהל את כל האפליקציה בפקודה אחת.

אתה יכול להשתמש ב-Docker Compose לפריסה וניהול של יישומי מכולות מורכבים. Docker Compose מפשט את הניהול עם פריסות אוטומטיות ועקביות.