הגבירו את המיומנויות שלכם עם השיעור הזה של Docker Compose

מדריכים
Docker

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

האם אתה מוכן? בואו נתחיל!

תנאי קדם

אם ברצונך להמשיך לעקוב אחר צעד אחר צעד, במדריך זה, ודא שיש לך את הבאים:

  1. A fresh install of Ubuntu Server LTS with SSH Enabled. This guide will use Ubuntu Server LTS 20.04.1 as the Docker host machine.
  2. A computer with VS Code installed (optional). This guide will use Visual Studio Code 1.52.1 to SSH to the Docker host and run commands.
  3. התקן הרשמי של VS Code להרחבת SSH מותקן ומחובר לשרת ה-Docker. (אופציונלי)

קשור: VS Code ו-Remote SSH

מהו דוקר קומפוז?

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

docker create \
   --name=bookstack \
   -e PUID # מזהה משתמש שיקבל בעלות על היישום/קבצים \
   -e PGID # מזהה קבוצת משתמש שיקבל בעלות על היישום/קבצים \
   -e DB_USER # המשתמש בבסיס הנתונים \
   -e DB_PASS # סיסמת בסיס הנתונים \
   -e DB_HOST # מארח בסיס הנתונים \
   -e DB_DATABASE # בסיס הנתונים שיש להשתמש בו \
   -e APP_URL # כתובת ה-URL שבה ייגשו ליישום שלך (נדרש לפעולה תקינה של פרוקסי הפוך) \
   -v /host/path/to/config:/config # מיקום של כל הנתונים שהועלו \
   -p 80:80/tcp # יציאת ממשק משתמש רשת \
   --restart unless-stopped \
   linuxserver/bookstack:version-v0.31.4

כפי שהמורכבות של סביבת דוקר מתרבה, כך גם כמות הדגלים והתנאים הנדרשים להגדרת היכולת של תצורת המיכל. שורת הפקודה של דוקר מתחילה להיות מסורבלת וקשה לפתרון; במיוחד כאשר התקנות מרובות של מיכלים מתחילות להיכנס לתמצית.

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

דוקר קומפוז מהר מתגלה חסון במיוחד כאשר מתמודדים עם תלותי מיכל או סביבות מיכל מרובות.

דוקר קומפוז הוא אופן נהדר להתחיל בקוד תשתיות מבלי להתמודד עם הרכבות המבוזרות כמו Kubernetes.

דוקר קומפוז משתמש במבנה קובץ התצורה הנקרא YAML. YAML דומה ל-JSON או ל-HTML בכך שהוא שפת מבנה, קריאה למכונה. YAML מתמקד בהיותו קריא ככל האפשר לאדם בעוד ששומר על הכוח המבנהי שלו.

YAML יש לו חסרון שבו טאבים ורווחים אחרים חשובים וחייבים להיות מעוצבים בצורה המתאימה. VS Code עושה המון מהעבודה הקשה הזו עבורך וגם זה הסיבה שתראה המון מהדוגמאות נעשות ב-VS Code.

התקנת דוקר קומפוז

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

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

כדי להתקין דוקר קומפוז ואת רצת דוקר, הריץ את שני הפקודות הבאות.

# עדכן את רשימת התוכנות (שנקראת גם repository) ואז התקן את Docker Compose
# עם כל התלויות הדרושות. הדגל -y משמש לדילוג על אישור
sudo apt update -y
sudo apt install docker-compose -y
The installation command for Docker Compose

לאחר ההתקנה, עליך ליצור מבנה תיקיות כדי לאחסן תוכניות

יצירת מבנה תיקיות עבור Docker Compose

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

הרכיב החשוב ביותר של Docker Compose הוא קובץ התצורה שלו שנקרא docker-compose.yaml. קובץ התצורה הזה, כפי שנבאר לעיל, מגדיר איך יש לבנות מיכל בזמן ריצת ה-Docker.

כאשר אתה מפעיל את Docker Compose, הפקודה תחפש את קובץ התצורה שלה באותה תיקייה בה רץ הפקודה. בשל דרישה זו, תמיד כדאי ליצור תיקייה נפרדת בעת הפעלת Docker Compose.

יכול להיות רק קובץ תצורה אחד של Docker Compose לכל תיקייה.

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

Caddy הוא שרת קבצים, דומה ל-apache httpd או ל-nginx, אך נכתב בשפת Go. Caddy מותאם במיוחד לשימוש נוח (וייצור או שירות אוטומטי של קובץ index.html) ללא צורך בתצורה. השילוב הזה עושה את Caddy לבחירה טובה למתחילים.

בהנחה שאתה מחובר לשרת Docker שלך, צור את מבנה התיקיות כך:

  1. בתיקיית הבית שלך, צור תיקייה בשם containers. תיקייה זו תהיה מקום טוב להכניס את Caddy וקונטיינרים אחרים.
  2. בתוך תיקיית containers, צור תיקייה משנה בשם caddy. תיקייה זו תכיל את קובץ התצורה של Docker Compose ואת קונטיינר Caddy עצמו.
  3. לבסוף, בתוך תיקיית הקונטיינר, caddy, צור קובץ טקסט ריק בשם docker-compose.yaml שיהפוך לקובץ התצורה של Docker Compose.

עם מבנה התיקיות וקובץ התצורה של Docker Compose שנוצר, כעת תוכל להתחיל למלא את קובץ התצורה הזה בתצורת Docker Compose.

יצירת קובץ התצורה של Docker Compose

בצורתה הבסיסית ביותר, קובץ docker-compose.yaml עבור קונטיינר Caddy נראה כמו הבא. בעזרת העורך הטקסט האהוב עליך ב-Linux או ב-VS Code, העתק והדבק את הקוד לקובץ התצורה של Docker Compose שיצרת לפני כן.

version: "3.7"
services:
  caddy:
    container_name: "caddy"
    image: "caddy:latest"
    ports:
      - "80:80"

בוא נעבור דרך כל אחת מהאפשרויות המוצגות:

  • גרסה מציינת את גרסת קובץ ה-docker-compose. כל הגדרה חדשה של Docker Compose כוללת שינויים שבורים במפרט. לכן הגרסה חשובה כדי ש-Docker Compose יוכל לקבוע אילו תכונות יש לו להשתמש בהן. גרסה 3.7 היא הגרסה האחרונה שתומכת בה Ubuntu 20.04.1 LTS.

המפרט המלא ל-Docker Compose 3.x ניתן למצוא כאן. התיעוד המקושר מציין כל אפשרות אפשרית שניתן להשתמש בה בתוך Docker Compose

  • שירותים מכיל את המפרטים למיכלים האמיתיים. ניתן להגדיר מספר מיכלים במקטע זה.
  • caddy הוא שם המיכל הראשון (זה מהווית רק הפניה).
  • container_name מגדיר את השם האמיתי שניתן למיכל על ידי Docker וחייב להיות ייחודי.
  • image הוא שם התמונה. במקרה זה, caddy מה-Docker Hub מוגדר. השם או המספר לאחר התג מופרדים בפסיק הוא הגרסה.

מיפוי פורט

אפשרות האחרונה במיוחד דורשת תשומת לב מיוחדת:

ports:
  - "80:80"

ב־Docker Compose, הַהַכְוָנָה ports מאפשרת לך להגדיר רישומים של אחד או יותר מהמארח אל המיכל. לדוגמה, למעלה, הגדרת את יצירת הפורט 80 במארח אל פורט 80 במיכל. עם זאת, אין צורך להתאים את מספר הפורט. בדוגמה למטה מפיים את הפורט 8800 במארח אל פורט 80 במיכל.

ports:
  - "8800:80"

ניתן גם להגדיר מספר פורטים כמו בדוגמה למטה.

ports:
  - "80:80"
  - "443:443"

כך תמפת את הפורטים 80 ו־443 למארח (הגדרה נפוצה לשרתי רשת, כדי לספק גם HTTP וגם HTTPS).

יוצר תמונת ה־Docker מגדיר פורטים זמינים בזמן היצירה. יש לוודא את תיעוד התמונה שאתה עובד איתו ב־Docker Hub או באתר של המתחזק לפורטים שניתנים למיפוי. אין טעם למפות פורט אם הפורט אינו בשימוש!

במודעות לכך, בואו נסתכל על הרצת המיכל בפועל.

הרצת המיכל

עד כה אמור לך קובץ ה־docker-compose.yaml בתוך התיקייה ~\containers\caddy. זו העת ליצור ולהתחיל את מיכל Caddy.

בטרמינל שלך, הפעל את הפקודה הבאה שתעלה את מיכלי ה־Docker שהוגדרו בקובץ docker-compose.yaml.

# יש להפעיל את הפקודה באותה התיקייה כמו הקובץ. האופציה -d מפעילה
# את הפקודה *בפירוש*, ובכך תעלה את המיכל ברקע
sudo docker-compose up -d

עשוי שתשימו לב שלא הייתה צורך לציין את מיקום קובץ ה- docker-compose.yaml בעת הרצת sudo docker-compose up -d. Docker Compose מצפה מכם להריץ את כל הפקודות בתוך התיקייה שמכילה את קובץ ה- docker-compose.yaml, מכיוון שהרבה מהפקודות יחסיות לתיקייה זו.

עכשיו ודאו שהקונטיינר פועל ועובד על ידי ניווט אל http://<כתובת ה-IP שלך>. המדריך משתמש ב- http://homelab-docker להפניה.

תוכלו לראות את התהליך הזה מתרחש ב- VS Code כאשר מחוברים דרך SSH לשרת ה-Docker באנימציה שבתחתית:

Demonstrating a container created with Docker Compose

הצלחה! עכשיו ביצעתם בהצלחה שימוש ב- Docker Compose כדי להתחיל קונטיינר מקובץ התצורה. עם השלב הראשון החשוב הזה, בואו נסתכל על איך תנהלו את מצב הקונטיינר שלכם.

פקודות לניהול קונטיינרים מנותקים

בקטע הקודם, הפעלתם את קונטיינר ה- caddy באמצעות הדגל -d. בעקבות כך, הופעל קונטיינר במצב מנותק. כאשר קונטיינר נמצא במצב מנותק, הוא ימשיך לרוץ ברקע. אך, יש בעיה: איך לנהל את הקונטיינר אם אין לכם שליטה ישירה יותר?

כדי לפתור את הבעיה הזו, Docker Compose מציע סדרת פקודות שתנהל קונטיינרים שהופעלו עם קובץ docker-compose.yaml:

  • docker-compose restart נעשה שימוש כדי לאתחל מחדש תיק שמופעל כרגע. לעשות כך שונה מהרצת מחדש של docker-compose up -d. פקודת האתחול מבצעת פשוט אתחול מחדש של תיק קיים, מפעילה מחדש את פקודת docker-compose up -d ויוצרת מחדש את התיק מאפס (אם קובץ התצורה שונה).
  • docker-compose stop תעצור תיק שמופעל בלי להרוס אותו. באופן דומה, docker-compose start יפעיל מחדש את התיק.
  • docker-compose down יעצור את התיקים שמופעלים וגם יורס אותם. כאן נכנסים לשימוש של חיבורי כמויות (ניתן לקרוא עוד למטה).
  • docker-compose pull ישדרג לגרסה הנוכחית של דוקר (או דוקרים) מהמאגר. אם תשתמש בתגית latest, תוכל להמשיך עם docker-compose down && sudo docker-compose up -d כדי להחליף את התיק בגרסה העדכנית ביותר. שימוש ב-docker-compose pull הוא דרך נוחה לעדכן תיקים במהירות עם זמן עומק מינימלי.
  • docker-compose logs יציג את הלוגים של התיק (או תיק שנעצר). ניתן גם לכתוב לתיקים ספציפיים (אם יש מספר תיקים מוגדרים בקובץ ההרכב) עם docker-compose logs <שם התיק>.

A full list of docker-compose commands can be seen by running docker-compose with no additional arguments or referenced here in the documentation.

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

יצירת חיבורי כמויות ב-Docker Compose

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

  1. על המארח של Docker, בתוך התיקייה ~/containers/caddy יש ליצור תיקייה חדשה בשם קבצים.

2. ליצור קובץ חדש בשם index.html בתוך התיקייה ~/containers/caddy שנראה כמו שמופיע למטה. זה יהיה הדף הראשי של שרת האינטרנט של Caddy. 

<body><h2>hello world!</h2></body>

3. לשנות את קובץ התצורה של Docker Compose כך שיראה כמו שמופיע למטה. הקובץ הדוגמה מוסיף את קטע הקוד volumes ומצביע על הדבקת מאמץ לתיקיית קבצים שנוצרה לפני כדי להפוך אותה לזמינה לקונטיינר. 

version: "3.7" services: caddy: container_name: "caddy" image: "caddy:latest" ports: - "80:80" volumes: #הנתיב ./ מפנה לתיקייה היחסית לקובץ docker-compose - "./files:/usr/share/caddy"

4. להריץ את docker-compose up -d שוב. Docker Compose כעת יזהה שהקובץ השתנה וישחזר את הקונטיינר שלך.

5. לנווט לדף הקונטיינר באמצעות דפדפן וכעת יש לראות שהוא מספק את דף "שלום עולם!".

ניתן לראות את המציאות הבאה באנימציה למטה:

Creating a bind mount using Docker Compose

כעת אתה מאחסן תוכן המאוחסן מקומית על המכשיר שלך! אך מה קורה אם התוכן שלך נמצא על מקור חיצוני כמו שיתוף רשת?

שימוש ב-Docker Compose עם כוננים של Docker

לאחר שתיצור מיכל פשוט עם Docker Compose, כנראה שתצטרך לגשת לקבצים במקום אחר, אולי בשיתוף רשת. אם כך, תוכל להגדיר למיכל להשתמש בנתונים מחיצה ב-Docker volumes ישירות בקובץ הגדרות Docker Compose שלך.

למטרות הדגמה, מדריך זה ייצור שרת Network File Share (NFS) על מחשב המארח של Docker. הגשת תוכן מקומי כמחצית NFS אין לה מטרה מעשית מעבר למטרות הדגמה. אם תרצה לערוך חיבור NFS, בדרך כלל זה יהיה ממקור חיצוני כמו NAS או שרת מרוחק.

הגדר שיתוף NFS

אם אין לך כבר שיתוף NFS הוגדר, תצטרך ליצור אחד כעת על מחשב המארח של Docker עבור המדריך הזה. כדי לעשות זאת:

  1. התקן את החבילה שרת NFS על ידי הרצת apt install nfs-kernel-server -y.

2. הוסף את המיכל כיצוא NFS (דומה לשיתוף CIFS של Windows) על ידי הרצת הפקודות הבאות. 

# הוסף שורה לקובץ הגדרות /etc/exports כדי ליצור שיתוף NFS עבור # /home/homelab/containers. השיתוף הזה נגיש רק מהמחשב המקומי (כדי # למנוע גישה ממחשבים אחרים) echo '/home/homelab/containers localhost(rw,sync,no_root_squash,no_subtree_check)' | sudo tee -a /etc/exports # הפעל מחדש את שרת ה-NFS עם התצורה החדשה sudo systemctl restart nfs-kernel-server

3. עכשיו בדוק שהמארח חושף את השיתוף NFS על ידי הרצת הפקודה showmount -e localhost. פקודה זו תציג כל שיתופי NFS שמחושפים כעת ומי מסוגל לגשת אליהם.

בצילום המסך למטה, תראה את /home/homelab/containers שנחשף, אך רק למחשב המקומי (הוא גם השרת שמפעיל את מארח ה-Docker).

Creating a NFS share in Ubuntu 20.04

אם אתה רואה את התיקייה /home/<שם משתמש>/containers בפלט, השיתוף NFS הוא מוכן.

הגדרת כרך בשם של Docker

לאחר שיצרת את שיתוף ה-NFS, עכשיו עליך לספר ל-Docker איך לגשת אליו. באמצעות Docker Compose, אתה יכול לעשות זאת על ידי הגדרת כרך בשם בקובץ התצורה של Docker Compose.

A named volume is a way for Docker to abstract network-based file shares. Network file sharing comes in all sorts of shapes and sizes these days: CIFS (windows) shares, NFS (Linux) shares, AWS S3 Buckets, and more. By creating a Named Volume, Docker does the hard part of figuring out how to talk to the network share and lets the container just treat the share as if it is local storage.

כדי ליצור כרך בשם:

  1. פתח את קובץ התצורה של Docker Compose (docker-compose.yaml). אם אתה עוקב אחרי, הקובץ אמור להימצא בתיקייה ~/containers/caddy.

2. בתוך קובץ התצורה של Docker Compose, הוסף קטע volumes לאחר קטע ה-services. קובץ התצורה שלך אמור להיראות כמו שלמטה. הקטע volumes יוצר כרך בשם בשם MyWebsite. בתוך הכרך בשם זה, מוגדרים הפרמטרים הדרושים (כמו IP, הגדרות NFS ונתיב). פרמטר ה-volumes בקטע של services גם משתנה, כך שהוא מצביע על השם של הכרך בשם במקום תיקייה מקומית.

version: "3.7"
 services:
   caddy:
     container_name: "caddy"
     image: "caddy:latest"
     ports:
       - "80:80"
     volumes:
       - "MyWebsite:/usr/share/caddy"
 volumes:
   MyWebsite:
     driver_opts:
       type: "nfs"
       o: "addr=localhost,nolock,soft,rw"
       device: ":/home/homelab/containers/caddy/files"

3. לאחר שהגדרת את הנפח שקובע את הכמות של האחסון הנקרא לנפח שמצביע לשיתוף NFS בקובץ התצורה של Docker Compose, הפעל את הפקודה docker-compose up -d כדי ליצור ולהתחיל את הקונטיינר. אם הכול מתרחש בהצלחה, הקונטיינר והאתר יצטרפו שוב.

Setting NFS client settings within Docker Compose in VS Code

4. נווט שוב לדף הקונטיינר. תוכן ה־index.html צריך להופיע בדיוק כמו אם הקובץ הותקן מקומית. אך, הקובץ הזה מתקבל דרך השרת NFS שהוגדר ברשת.

Demonstrating access to the index.html file through an NFS share in Docker

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

המדריך הזה לא יעשה יותר שימוש בקונטיינר של caddy, כך שתוכל להסיר את הקונטיינר באמצעות הפקודה docker-compose down.

הגדרת מספר קונטיינרים ב־Docker Compose

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

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

כדי להדגים תרחיש כזה, נקבע אפליקציית ויקי פופולרית שנקראת BookStack.

BookStack הוא תוכנת ויקי פופולרית הידועה בזכות קלות השימוש שלה ובסידור ההיררכי שלה (בניגוד לסידור שטוח, כמו mediawiki).

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

צור את קובץ התצורה של Docker Compose

BookStack אין לה תמונת Docker שמתוחזקת פנימית, אך linuxserver.io שומרת על תמונת Docker Hub אמינה מטעם BookStack. בעוד שהתיעוד באתר של docker hub מכיל קובץ תצורה מומלץ של Docker Compose, במדריך זה נבנה קובץ תצורה חדש ובו יתבררו המושגים.

על מארח ה-Docker:

  1. ראשית, צור תיקייה עבור BookStack. אם עקבת אחרי המדריכים בקטע הקודם, יש לך תיקייה בשם ~/containers. צור תיקייה בשם bookstack בתוך זו.

2. לאחר מכן, צור קובץ תצורה ריק שנקרא docker-compose.yaml בתוך התיקייה bookstack.

Creating the folder structure for Bookstack in VS Code

3. כעת פתח את קובץ התצורה של Docker Compose והגדר שני קונטיינרים: קונטיינר ה-bookstack וקונטיינר ה-bookstack_db (mariadb).

version: "3.7"
 services:
   bookstack:
     container_name: "bookstack"
     image: "ghcr.io/linuxserver/bookstack"
     ports:
       - "8080:80"
     volumes:
       - "./files:/usr/share/caddy"
     depends_on:
       - "bookstack_db"
   bookstack_db:
     container_name: "bookstack_db"
     image: "mariadb"
     volumes:
       - "./db:/var/lib/mysql"

עד כה, קובץ ה־docker-compose.yaml הזה בעיקר משתמש במושגים שכבר נכנסו: יש לך שני שירותים (bookstack ו־bookstack_db), כאשר לכל אחד מהם יש תמונות ו-bind mounts. המיכל של bookstack יש מיפוי פורטים מפורט מארח 8080 לפורט פנימי 80.

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

אפשרות חדשה שאתה רואה בקובץ למעלה היא פקודת depends_on. פקודה זו מספרת ל־Docker את הסדר שבו יש להתחיל את המיכלים. קביעת פקודת depends_on מספרת ל־Docker שהמיכל bookstack_db חייב להתחיל ראשון.

הגדרת תקשורת בין מיכלים באמצעות משתני סביבה

קובץ ההגדרה הזה שנבנה בסעיף האחרון עדיין לא הושלם. במרכז שהגדרת שני שירותים (מיכלים), הם לא מדברים אחד עם השני! המיכל של bookstack לא יודע איך לתקשר עם המיכל של bookstack_db. בוא נפתור זאת בעזרת משתנים סביבתיים.

משתנים סביבתיים הם הדרך הנפוצה ביותר לספק משתנים למיכלים של Docker. אלה הם משתנים שניתנים בזמן הרצת המיכל (או הוגדרו בקובץ ההגדרה של docker-compose.yaml) כדי לספק מידע על מה שהמיכל צריך לעשות.

משתני סביבה מוגדרים על ידי האדם שיוצר את תמונת ה-Docker. הם יהיו שונים בהתאם לתמונת ה-Docker שאתה משתמש בה, ועליך להתייחס לתיעוד מהיוצר בנוגע לאילו משתני סביבה להשתמש.

ישנם שני אופציות להגדרת משתני סביבה; ישירות בקובץ ה-docker-compose.yaml עצמו או כקובץ נפרד.

A separate file is, typically, the recommended method, especially if variables contain sensitive data such as passwords. A docker-compose.yaml file is designed to be shared or even uploaded to a public-facing GitHub repo. Having a separate file for sensitive data reduces the chance of an accidental security breach.

על המארח של Docker, צור כעת שני משתני סביבה; אחד עבור התכולה של bookstack ואחד עבור התכולה של bookstack_db.

  1. צור קובץ חדש בתיקיית ~/containers/bookstack בשם bookstack.env עם התוכן הבא: 
APP_URL is the IP address or hostname of your server. This article is using homelab-docker
 APP_URL=http://homelab-docker:8080
 DB_HOST is the container name you gave your container
 DB_HOST=bookstack_db
 DB_USER is defined in the bookstack_DB environment file
 DB_USER=bookstack_user
 DB_PASS is also defined in the bookstack_DB environment file
 DB_PASS=MySecurePassword
 DB_DATABASE is the name of the database within mariadb
 DB_DATABASE=bookstack

2. צור קובץ חדש בתיקיית ~/containers/bookstack בשם bookstack_db.env וכלול את התוכן הבא: 

The root password for our database, keep it secret, keep it safe
 MYSQL_ROOT_PASSWORD=MySecureRootPassword
 The database bookstack will be using
 MYSQL_DATABASE=bookstack
 the user bookstack will be using
 MYSQL_USER=bookstack_user
 the password bookstack will be using
 MYSQL_PASSWORD=MySecurePassword

3. כקריאת מומלץ, וודא כעת ששני קבצי ה-env אינם ניתנים לקריאה על ידי משתמשים אחרים. 

chmod 600 bookstack.env bookstack_db.env

עליך לשנות את הגישה לקריאה מאחר שבשני קבצי ה- bookstack.env ו- bookstack_db.env קיימים נתונים רגישים.

4. עדכן את קובץ ה- Docker Compose של ~/containers/bookstack/docker-compose.yaml כך שיפנה לשני קבצי הסביבה הללו כפי שמוצג למטה. 

version: "3.7"
 services:
   bookstack:
     container_name: "bookstack"
     image: "ghcr.io/linuxserver/bookstack"
     ports:
       - "8080:80"
     volumes:
       - "./files:/usr/share/caddy"
     depends_on:
       - "bookstack_db"
     env_file:
       - "./bookstack.env"
   bookstack_db:
     container_name: "bookstack_db"
     image: "mariadb"
     volumes:
       - "./db:/var/lib/mysql"
     env_file:
       - "./bookstack_db.env"

5. כעת הפעל את התכולות bookstack ו- bookstack_db באמצעות Docker Compose. 

sudo docker-compose up -d

ניתן לראות כל אחת מהשלבים האמורים בסעיף זה מבוצעת ב-VS Code למטה.

Setting up environment variables and the Docker Compose file with VS Code

ניטור של לוגים של Docker Compose

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

כדי לפקח על הקונטיינר של ה-BookStack, לדוגמה, ניתן להשתמש בפקודת logs. במדריך זה, לאחר שתראה את הלוגים מציגים [services.d] done, תוכל לעבור אל כתובת ה-URL של ה-BookStack.

sudo docker-compose logs bookstack
Using the docker-compose logs command
The bookstack welcome screen. Default login is [email protected]/password

בשלב זה, עליך לקבל ויקי פועלת לחלוטין בתוך קונטיינר משלו, עם מסד נתונים משלו, לחלוטין ב-Docker!

כל עוד יש לך את תיקיות ה-BookStack וה-BookStack_db, תוכל לבנות מחדש את סביבת ה-BookStack שלך מאפס.

Docker Compose ורשתות

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

כאשר אתה יוצר מספר קונטיינרים בתוך קובץ docker-compose.yaml יחיד כפי שעשית בקטעים הקודמים, כולם מוקצים לאותה רשת (בדרך כלל נקראת name-of-parent-folder_default).

ניתן לראות את הרשת שנוצרה עבור הקונטיינרים כאשר אתה מפעיל docker-compose up -d כפי שמוצג למטה.

The default network created with docker-compose comes up

כאשר כל הקונטיינרים מוקצים לאותה רשת, Docker יוצר ערכי DNS עבורם פנימית. זה הסיבה שבדוגמה הקודמת התייחסת למסד הנתונים שלך כ-bookstack_db במשתני הסביבה. שם bookstack_db הוא למעשה ערך DNS שמצביע על כתובת ה-IP של קונטיינר המסד נתונים.

אתה גם לא צריך להישען על Docker Compose כדי ליצור רשתות באופן אוטומטי עבורך. תוכל להגדיר רשתות פנימיות או חיצוניות באופן ידני. הגדרת רשתות באופן ידני היא נהדרת כאשר יש לך תוכניות שצריכות לדבר עם תוכנית אחרת בקובץ docker-compose.yaml נפרד. תוכל לחשוף את הפורטים, או ליצור רשת שבה שני הקונטיינרים יכולים להצטרף אליה!

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

עכשיו שנה את קובץ ה-docker-compose.yaml של bookstack כדי לכלול רשת שנוצרה מחוץ.

  1. צור את הרשת החיצונית עם docker network create my_external_network .

2. הגדר את הרשת החיצונית בקובץ ה-docker-compose.yaml: 

version: "3.7"
 services:
   bookstack:
     container_name: "bookstack"
     image: "ghcr.io/linuxserver/bookstack"
     ports:
       - "8080:80"
     volumes:
       - "./files:/usr/share/caddy"
     depends_on:
       - "bookstack_db"
     env_file:
       - "./bookstack.env"
     networks:
       - "my_external_network"
       - "bookstack_default"
   bookstack_db:
     container_name: "bookstack_db"
     image: "mariadb"
     volumes:
       - "./db:/var/lib/mysql"
     env_file:
       - "./bookstack_db.env"
     networks:
       - "bookstack_default"
 networks:
   bookstack_default:
   my_external_network:
     external: true

3. הרץ docker-compose up -d כדי ליצור מחדש את הקונטיינרים. שני הקונטיינרים שלך מצטרפים כעת לשתי רשתות כפי שמוצג למטה.

A highlight of the networks defined within a docker-compose file

הקונטיינר של bookstack מצטרף כעת גם לרשת שהוגדרה באופן חיצוני. זה מאפשר לך ליצור קונטיינר נוסף שמפנה תעבורת HTTP של bookstack ל-HTTPS לפני שהיא יוצאת מ-Docker (נקרא זה כ-reverse-proxy).

הגדרת משתמש ספציפי להפעלת קונטיינר

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

הבעיה השנייה עם הרצת התהליך כ-root היא ההרשאות על קבצים. ייתכן שתגלה שאם תנסה למחוק את התיקייה db בתוך התיקייה bookstack, אתה לא יכול לעשות זאת בפועל; התוכן משוייך ל-root.

בעוד שרוב הדמויות לא מעריכות לרוץ כמשתמש שאינו root, דמויות מסוימות מציעות משתנה סביבה להגדיר את המשתמש שרץ בתוך הקונטיינר. ניתן לעשות זאת על ידי הוספת UID=1000 ו-GID=1000 בתוך הקובץ ה-bookstack.env configuration.

1000:1000 הוא זיהוי המשתמש והקבוצה ברירת המחדל עבור המשתמש הראשון ב-ubuntu (שאתה כנראה לא הוא). ניתן לקרוא עוד על זיהויי משתמש וקבוצה ב-קשור: אדם מWindows בעולם של Linux: משתמשים והרשאות קובצים)

ניתן גם להכריח UID ו-GID באמצעות הפרמטר user בקובץ ה-compose של Docker, אך זה לא מומלץ מאחר ורוב הקונטיינרים לא פועלים בצורה נכונה כאשר מוטרדים למשתמש שונה

הגדרת מדיניות האתחול

אם אתה רוצה שמכולות שנבנות עם Docker Compose יתחילו מחדש בכישלון, השתמש במדיניות ההתחלה מחדש על ידי הוספת פרמטר restart: <אפשרות> מתחת להגדרות המכולה בdocker-compose.yaml.

restart: "no"
restart: always
restart: on-failure
restart: unless-stopped

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

הגדרת רשומות DNS ידנית למכולות

בדיוק כמו עם Windows ו-Linux, ל-Docker יש גם "קובץ hosts". על ידי שימוש בפרמטר extra_hosts בקובץ תצורה, אתה יכול לכפות ששם מארח יתורגם ל-IP מסוים. זה יכול להיות שימושי כאשר יש לך אילוצי DNS, כמו DNS מפוצל או שרת ניסיון שאתה רוצה להתערב עימו זמנית.

extra_hosts:
  - "somehost:x.x.x.x"
  - "otherhost:x.x.x.x"

הרצת פקודות

לאחר שהמכולה התחילה, אתה יכול להריץ פקודות בתוך המכולה באמצעות הdocker-compose run. לדוגמה, אולי היית רוצה להפעיל טרמינל Bash בתוך המכולה שלך bookstack. לשם כך, היית מריץ את הפקודה למטה.

docker-compose run web bash

מסקנה

בשלב זה, אתה אמור להיות בעל מספיק מידע לעקוב אחרי רוב המדריכים של docker-compose הזמינים ברשת. הידע הזה יכול להרחיב מאוד את היכולת שלך להיכנס לעולם של Docker, ובניית אפליקציות אינטרנט בתשתית כקוד.

Source:
https://adamtheautomator.com/docker-compose-tutorial/