אהלן לכם, וברוכים הבאים לחלק השלישי במדריך "דוקר למתחילים בעברית"!
בפרק הזה נצלול קצת יותר לעבודה אמיתית עם קונטיינרים שכבר רצים – נלמד איך לבדוק עליהם מידע, להסתכל על הלוגים שלהם, לשנות להם שם, להעביר קבצים פנימה והחוצה, ולהריץ בתוכם פקודות.
נמשיך גם לדברים סופר חשובים כמו חיבור תיקיות מהמחשב שלנו עם Volumes, פתיחה של פורטים לעולם החיצון, מחיקת Volumes שלא בשימוש, ניקוי Imageים מיותרים – ולסיום, נראה איך בודקים כמה משאבים כל קונטיינר באמת לוקח.
¿?רגע - לפני שאתם ממשיכים קראתם את שתי החלקים הראשונים!!!¿?
שימו לב ! לפני שאתם ממשיכים לעבור על החלק השלישי, תעברו על שתי החלקים הראשונים כדי שתבינו על מה מדובר מאחר ובמקרה של דוקר, חשוב מאוד להבין את המושגים ומה בדיוק אנחנו עושים כי הדברים יכולים להיות מבלבלים.
ניתן לעבור על כל החלקים בעמוד המיועד לדוקר בבלוג: מדריך דוקר למתחילים בעברית - כל החלקים
להלן הסעיפים שנעבור עליהם היום:
1) איך לקבל מידע על קונטיינר בדוקר? - docker inspect
2) איך לבדוק לוגים בקונטיינר של דוקר? - docker logs
3) איך לשנות שם של קונטיינר בדוקר? - docker rename
4) איך להריץ פקודות בתוך קונטיינר שכבר רץ בדוקר? - docker exec
5) איך להעתיק קבצים מהמחשב לקונטיינר וההפך בדוקר? - docker cp
6) עבודה עם Volumes - איך לחבר תיקייה\כונן\אלפקה במחשב שלנו לקונטיינר בדוקר - docker run -v
7) להציג Volumes בדוקר? - docker volume ls
8) איך למחוק Volume בדוקר? - docker volume rm
9) איך עושים "סדר פסח" בדוקר ומנקים Imageים שלא בשימוש כבר בדוקר - docker image prune
10) איך לבדוק כמה משאבים צורך כל קונטיינר בדוקר - docker stats
11) תקשורת בדוקר – איך לחבר בין קונטיינרים ולפתוח פורטים בדוקר?
1. איך לקבל מידע על קונטיינר בדוקר? - docker inspect container_name
מידע על קונטיינר מסוים זה מאוד חשוב, לפעמים אנחנו רוצים לדעת מה הנפח שלו, או לדוגמא אם אתם לא זוכרים מה הפקודה שהוא מריץ?
אם אנחנו נריץ את הפקודה docker inspect test1 נקבל המון מידע בפורמט "json"
לידע כללי, מה זה json? - זה פורמט פשוט וקריא לאחסון ולהעברת מידע. מאוד נפוץ בשפות תכנות ובעיקר בשימוש עם APIs.
ובעצם נקבל את המידע שלנו ככה (יש המון מידע, הכל לא נכנס בתצלום מסך אחד אז חילקתי):
יש כאן המון המון מידע מאוד חשוב לדוגמא:
שם הקונטיינר:
test1
מצב:
running (פועל)
תאריך יצירה:
2025-04-17T18:58:50Z
פקודה שרצה בקונטיינר:
tail -f /dev/null
תמונה (Image):
alpine
ID של הקונטיינר:
024ab10866e065d9b9c04ddd28f669df4a580e98d43047bb97df905250c5b7bd
IP פנימי:
172.17.0.2
Gateway:
172.17.0.1
PID של התהליך הראשי:
33705
נתיב הלוג:
/var/lib/docker/containers/024ab10866e065d9b9c04ddd28f669df4a580e98d43047bb97df905250c5b7bd/024ab10866e065d9b9c04ddd28f669df4a580e98d43047bb97df905250c5b7bd-json.log
רשת:
bridge
אם אנחנו רוצים לדוגמא לבצע חיפוש בתוך כל המידע הענק הזה, ניתן להריץ את הפקודה בצורה הבאה:
docker inspect test1 |less
במצב הזה, נקבל בסוף המסך למטה סימן של נקודותיים ":" -
לאחר מכן, נלחץ על סלאש שמראה לצד ימין "/", ונוכל להתחיל לחפש את מה שאנחנו נרצה בתוך הקובץ הענק הזה, כותבים את מה שצריך ולוחצים על ENTER, החלק הכי חשוב שצריך לשים לב - אנחנו עובדים על לינוקס אז לשים לב ל - אותיות גדולות וקטנות חובה !
אם תנסו לכתוב משהו באות קטנה כאשר בפועל הוא מתחיל באות גדולה, לא תמצאו את מה שאתם צריכים ותקבלו הודעת שגיאה כזאת: Pattern not found (press RETURN)
בשביל לצאת מהחיפוש ולחזור לשורת הפקודה שלנו, נלחץ על "q":
נגיד ואני רוצה להציג רק משהו ספציפי מכל הקובץ הזה, נשתמש בפרמטר format, ניתן להשתמש גם במילה עצמה וגם באות הראשנה מתוך הפרמטר "format--" או "f-".
דוגמאות של סינטקס:
- docker inspect -f '{{.State.Status}}' test1
- docker inspect --format '{{.State.Status}}' test1
מאחר וקונטיינר בשם test1 אצלי רץ, אני אקבל את התגובה הרלוונטית: "Running"
1.א. איך להציג שדה ספציפי עם docker inspect?
בשביל להציג שדה ספציפי צריך להבין איך בעצם לשלוף את המידע, נשתמש בסיטקס הזה:
docker inspect --format '{{.State.Status}}' test1
איך בעצם נדע כיצד לגשת ל Status?
לכל "סעיף" בקובץ יש "כותרת" שהיא נמצאת בתוך "" ולאחר מכן יש סימן של נקודתיים ":", לאחר מכן סוגר מסולסל "{" ובפנים יש כל מיני תתי סעיפים, והראשון שמופיע הוא: "State"
נגיד ואני רוצה לגשת ל Pid, אני אכתוב:
docker inspect --format '{{.State.Pid}}' test1:
בשביל להראות את זה קצת יותר טוב, אני אגש ל Links שהוא הרביעי בנתיב:
הפקודה תראה כך: docker inspect --format '{{.NetworkSettings.Networks.bridge.Links}}' test1
1. NetworkSettings
2.Networks
3.bridge
4.Links
תשימו לב שאחרי "NetworkSettings", "Networks" , "bridge" יש סוגר מסולסל, זאת אומרת הוא "סעיף" שיש לו תתי סעיפים, ניתן לראות את זה על ידי דוגמא של "Name":
לכן גם הגישה אליו תהיה מאוד פשוטה: docker inspect --format '{{.Name}}' test1
כל הפרמטרים (בדוקר הם נקראים Flags אבל אני רגיל לפרמטרים) של docker inspect:
--format - מאפשר לשלוף רק שדות מסוימים מתוך הפלט, בעזרת (כמו {{.Name}}).
--type - קובע את סוג האובייקט שנרצה לבדוק container, image, network, volume, node.
--size - מציג (רק לקונטיינרים) מוסיף מידע על גודל התוכן של הקונטיינר.
--help - קבלת עזרה לפקודה docker inspect.
2. איך לבדוק לוגים בקונטיינר של דוקר? - docker logs
לוגים זה דבר מאוד מאוד חשוב, בחלק הזה אנחנו נלמד כיצד לקרוא לוגים, לשמור אותם בצד ואפילו לשמור אותם בלייב.
חשוב להבהיר משהו אחד: אנחנו לא מדברים כאן על לוגים של מערכת ההפעלה — כמו ה־Events שאתם אולי מכירים מ־Windows.
מה ש־docker logs מציג זה לא שגיאות מערכת, אלא יותר כמו רישום של פלט שהאפליקציה בתוך הקונטיינר הדפיסה,
זה יכול להיות טקסט שהצגנו למשתמש, שגיאות שהופיעו כשהאפליקציה קרסה, הודעות echo, print, או לוגים שהאפליקציה בחרה להציג החוצה למסך.
אם בדרך כלל אנחנו מבצעים פקודה ושמים בסוף את השם של הקונטיינר, במקרה הזה ניתן לשים גם את ה id של הקונטיינר, נתחיל בלהבין איפה אנחנו בכלל מוצאים את ה ID של הקונטיינר או השם שלו?, אז ניתן למצוא את השם וה ID בעזרת הפקודה docker ps או docker ps -a (אם אתם לא יודעים מה זה או מה ההבדל, תעברו על החלק הראשון דחוף : כאן).
לראות לוגים במקרה הזה לא כל כך פשוט וצריך לשים לב שבשביל באמת לקבל לוגים אנחנו נצטרך להריץ את הקונטיינר מההתחלה בצורה כזאת שהוא ישמור לוגים, אחרת הוא לא ישמור אותם ולא תראו כלום.
במידה ואתם יוצרים עכשיו קונטיינר חדש ואתם רוצים שהוא ירשום הכל ללוג, הינה פקודה לדוגמא:
docker run -d --name wtf_name alpine sh -c 'echo "container_started" && tail -f /dev/null'
להלן הפירוש של הפקודה (יש כאן דגלים שלמדנו עליהם כבר בפרקים הקודמים):
- docker run - מריץ קונטיינר חדש
- -d - מריץ את הקונטיינר ברקע (detached mode)
- --name mylogger - נותן לקונטיינר שם קבוע: mylogger
- alpine - זה האימג' שממנה הקונטיינר נבנה – פה Alpine Linux
- sh -c '...' - מריץ פקודה אחת בתוך shell (שֶל) בתוך הקונטיינר
- echo "קונטיינר התחיל" - כותב טקסט למסך – וזה נכנס ללוג
- && - אם הפקודה הראשונה הצליחה → ממשיכים הלאה
- tail -f /dev/null - פקודה שלא עושה כלום אבל שומרת את הקונטיינר חי
מה ירשם בלוגים?
- echo- "משהו" בתוך הפקודה הראשית - מדפיס למסך (פלט של תוכנה) ונשמר בלוג של הקונטיינר
- שגיאה מתוך התהליך הראשי, שגיאות שנכתבות למסך הראשי – גם הן נשמרות בלוג
- print() בתוך תוכנה שרצה בקונטיינר - כל הדפסה למסך (מה שנקרא Output) תיכנס ללוג, כל עוד לא נכתבת לקובץ
- תוכנה שמוגדרת להדפיס למסך (כלומר לא רצה ברקע) - הלוגים שלה יופיעו ב־docker logs, כי היא מדפיסה פלט רגיל
- כתיבה ל־/proc/1/fd/1 - כתיבה ישירה למסך של התהליך הראשי – נשמרת בלוג
פרוש של - /proc/1/fd/1:
- /proc/ - תקיית מידע פנימית של לינוקס
- "1" - זה ה- PID של התהליך הראשי בקונטיינר (מה שהרצנו כשייצרנו אותו)
- fd/1 - קובץ שמייצג את "המסך" (OutPut) של אותו התהליך
- לכן יש סדר פעולות שצריך לבצע במידה ולא הפעלתם את הקונטיינר עם לוגים
מה לא ירשם בלוגים?
- docker exec echo "משהו" - לא נכנס ללוגים – זה תהליך צדדי, לא חלק מהתהליך הראשי
- כתיבה לקובץ בתוך הקונטיינר - לא יופיע בלוגים – כי זה נכתב לקובץ ולא למסך
- תוכנה שרצה ברקע בלי פלט - אם היא לא מדפיסה למסך – אין מה שייכנס ללוגים
מה עושים אם כבר יצרנו קונטיינר ואנחנו רוצים שהוא ירשום לוגים? ניתן לבצע שינוי אבל הוא לא "נוח" ומאוד מעצבן לכן אני לא רוצה לסבך אתכם כאן, הרבה יותר קל לעצור את הקונטיינר, למחוק אותו (לא למחוק את ה IMAGE) ולהריץ אותו מחדש בצורה כזאת שהוא כן ירשום לוגים:
1) לעצור את הקונטיינר - docker stop container_name
2) למחוק את הקונטיינר - docker rm continer name
3) להריץ מחדש את הקונטיינר שאנחנו רוצים:
'docker run -d --name test1 alpine sh -c 'echo "LeiderTech.co.il" && tail -f /dev/null
הפרוש של הפקודה:
- docker run - יוצר ומריץ קונטיינר חדש
- -d - מריץ את הקונטיינר ברקע (detached) — אתה לא תראה את הפלט במסך
- --name test1 - נותן לקונטיינר את השם test1
- alpine - ה Image שמשמשת להרצת הקונטיינר – Alpine היא לינוקס קליל
- sh -c '...' ה" C" הוא בעצם קיצור של "command", ה "SH" הוא בעצם קיצור של "SHELL" בתוך הקונטיינר
- echo "LeiderTech.co.il" - מדפיס את הטקסט למסך (Output) — ונשמר בלוג
- && - (כמו שכבר למדנו בפרקים הקודמים) מפעיל את הפקודה הבאה רק אם הקודמת הצליחה
- tail -f /dev/null - שומר את הקונטיינר חי בלי לעשות כלום (מונע ממנו להיסגר)
3.איך לשנות שם של קונטיינר בדוקר? - docker rename old_name new_name
נגיד והחלטתם לשנות את השם שלקונטיינר כלשהו, אין צורך בלעצור את הקונטיינר ניתן פשוט לבצע שינוי בצורה הבאה:
docker rename test3 test9
לאחר מכן נריץ את docker ps ונראה שבוצע השינוי:
שימו לב :אין אפשרות לעשות שינוי שם לקונטיינר שנמצא במצב "הקפאה" (Paused).
4.איך להריץ פקודות בתוך קונטיינר שכבר רץ בדוקר? - docker exec
מטבע הדברים נרצה לבצע פעולות בתוך הקונטיינר, וכל זה נעשה בעזרת פקודות כאלה ואחרות, לא בכל פעם צריך להתחבר לתוך הקונטיינר ולעבוד, ניתן לבצע פעולות מבחוץ ולקבל תגובה, לדוגמא, אם אנחנו רוצים להציג תוכן של תיקייה או לבדוק כתובת IP, לא צריך להתחבר לתוך הקונטיינר, ניתן "לשלוח" פקודה לתוך הקונטיינר ולקבל את הפלט של הפקודה נגיד ואנחנו רוצים לבדוק כתובת IP של קונטיינר מסויים, נריץ את הפקודה הבאה: docker exec command continaner_name
בלינוקס בודקים כתובות IP עם הפקודה "ip a" ומה שיקרה, זה שלאחר שנריץ את הפקודה נקבל את הפלט שלה, אני אבצע בדיקה בקונטיינר בשם test83 בצורה הזאת: docker exec test83 ip a
נגיד ואני רוצה לראות מה יש בתוך תקיית "var" בתוך הקונטיינר "LeiderTech", אני אריץ את הפקודה הבאה:
docker exec leidertech ls -l /var
ונקבל את התוכן בלי הצורך להתחבר לקונטיינר עצמו:
5.איך להעתיק קבצים מהמחשב לקונטיינר וההפך בדוקר? - docker cp
יש פעמים שאנחנו רוצים להוסיף דברים לקונטיינר שלנו, להעביר משם דברים למחשב שלנו וכד', בשביל לבצע העתקה אל קונטיינר או מתוך קונטיינר, התנאי היחיד שצריך להיות, זה שהקונטיינר יהיה קיים גם אם הוא Exited, כן כן כמו ששמעתם, הוא לא חייב לרוץ בכלל.
5.א נתחיל עם העתקה מהמחשב לקונטיינר.
להלן הסינטקס: docker cp host_path container_name:container_path
יש לי במחשב קובץ בשם test1.txt ואני רוצה להעתיק אותו לאיזשהי תיקייה בתוך הקונטיינר LeiderTech לתיקיית tmp:
/docker cp ~/Desktop/test1.txt leidertech:/tmp
ניתן לראות שההעתקה בוצעה בהצלחה, עכשיו נבדוק שהקובץ באמת שם:
בדוגמאות כאן כתבתי נתיב יחסי ולא נתיב מלא, כמובן שאפשר גם וגם (אם אתם לא יודעים מה זה, תצטרכו לעבור על המדריך ללינוקס).
5.ב העתקה של קבצים מהקונטיינר למחשב
להלן הסינטקס: docker cp container_name:path_inside_container path_on_host
את הקובץ שהעתקתי בסעיף הקודם בשם test1.txt אני רוצה להעתיק מהקונטיינר LeiderTech לתקיית lev1 במחשב שלי:
docker cp leidertech:/tmp/test1.txt ~/Desktop/lev1
נבדוק שהקובץ נמצא בתיקייה Lev1:
5.ג האם אפשר לבצע העתקה של כמה קבצים\תיקיות בדוקר?
לצערי הרב, לא, הפקודה לא תומכת בהעתקה של כמה קבצים\תיקיות ביחד, בדקתי באינטרנט והדבר היחיד שניתן לעשות זה לשים את כל מה שרוצים לתוך "תקיית אב" ואז להעתיק אותה לתוך הקונטיינר, וההפך אגב, אין אפשרות להעתיק כמה קבצים\תיקיות מתוך הקונטיינר למחשב שלנו.
5.ד האם אפשר לבצע "גזירה" (CUT) לקבצים\תיקיות בדוקר?
התשובה היא לא - אין אפשרות לבצע פעולה כזאת.
6.עבודה עם Volumes - איך לחבר תיקייה\כונן\אלפקה במחשב שלנו לקונטיינר בדוקר - docker run -v
לפעמים אנחנו נצטרך לתת לקונטיינר גישה לתיקייה במחשב שלנו במקום לבצע העתקה כל פעם, לכן נצטרך לחבר תיקייה מהמחשב לתוך הקונטיינר, ככה הקונטיינר יוכל לשמור\ליצור\לשנות קבצים\תיקיות וכד' (לפי הצורך שלכם).
יש שתי סינטקסים שונים לבצע את אותה הפעולה, בכל דוגמא אני אתן את הסינטקס ה"חדש" וה"ישן", אני יכול לספר כאן למה יצרו חדש בנוסף לישן (שתיהם עושים את אותו הדבר אגב), אבל אני מעדיף שאתם תשפטו בעצמכם ובמה בה לכם לעבוד ומה זורם לכם יותר.
יש כמה צורות של עבודה עם תיקיות:
1) חיבור תיקייה במחשב שלנו לתוך הקונטיינר - ובעצם אנחנו עובדים רגיל כמו שאנחנו מכירים - צורת Bind
2) חיבור סוג של "דיסק חיצוני" לקונטיינר - ובעצם מי שמנהל אותו זה הדוקר - צורת Volume
3) חיבור תיקייה מהמחשב שלנו "לקריאה בלבד".
6.א איך לבצע BIND לקונטיינר בדוקר?
אז כפי שאמרנו, אם אנחנו רוצים לחבר כל תיקייה מהמחשב שלנו לתוך הקונטיינר כי יש עליו חומר שהקונטיינר צריך,
נבצע "bind" (חיבור) של תיקייה במחשב לתוך קונטיינר בשם leidertech.
חשוב לזכור - אין אפשרות לבצע חיבור בזמן שהקונטיינר רץ, לכן קודם צריך "למחוק" את הקונטיינר ולאחר מכן להריץ פקודה שבה אנחנו נגיד לקונטיינר שאנחנו רוצים לחבר תיקייה כזאת או אחרת לתוך הקונטיינר, במקרה שלי אני אחבר תיקייה בשם sharedfolder שיש לי במחשב על שולחן העבודה לתוך הקונטיינר leidertech:
1) נעצור ונמחק את הקונטיינר docker rm -f leidertech
2) נריץ את הפקודה לחיבור התיקייה לתוך הקונטיינר leidertech שניצור מחדש, בסינטקס הישן ואז בחדש:
סינטקס ישן - docker run --name leidertech -v ~/Desktop/sharefolder:/data alpine
(מאחר ואני לא רוצה לעבוד בתוך הקונטיינר, לא השתמשתי ב "it-" מה שקרה, זה שמערכת פשוט יצרה קונטיינר וחיברה לו את התיקייה sharefolder).
סינטקס חדש -
docker run --name leidertech --mount type=bind,source=$HOME/Desktop/sharefolder,target=/data alpine
(הוא יותר ארוך אבל יש בו גם יותר פרטים כמו type (סוג חיבור) ובעצם מוסבר מי המקור ומי היעד)
חיברנו את sharefolder מהמחשב לתוך תיקיית data ועכשיו נציג אותה ונראה מה יש בה, נריץ את הפקודה:
docker exec -t leidertech ls -l /data
ועכשיו נכנס לתוך sharefolder במחשב עצמו בשביל לראות מה יש שם:
ניתן לראות בבירור שמדובר על תוכן זהה.
בשביל הנסיון, אצור תיקייה בשם lev3 בתוך sharedfolder במחשב, ואז את התיקייה lev3 שיצרתי במחשב, נוכל לראות גם בקונטיינר:
6.ב איך לבצע ניתוק של תיקייה מתוך קונטיינר בדוקר או UnBind?
התשובה מאוד פשוטה - אין אפשרות לבצע את זה, צריך למחוק את הקונטיינר וליצור אחד חדש בלי Bind.
6.ג איך לבצע חיבור Volume לקונטיינר בדוקר?
נתחיל מההסבר הפשוט, מה זה בכלל Volume בדוקר ומה המטרה שלו?, אז בעצם מדובר במצב שבו אתם כאילו מחברים "דיסק חיצוני" לתוך הקונטיינר, מאחורי הקלעים, ברגע שתבצעו את הפקודה המתאימה, דוקר יצור תיקייה ריקה במחשב שלכם (בנתיב הזה /var/lib/docker/volumes/) ויקשר אותה לתיקייה שאתם תגידו לו בתוך הקונטיינר ואז תוכלו לשמור שם דברים, אם מוחקים את הקונטיינר, ה-Volume לא נמחק, וניתן להשתמש בו בקונטיינר אחר, דיי מזכיר עבודה עם דיסק וירטואלי שאפשר להעביר ממחשב למחשב.
למה זה טוב?
אז בעצם המטרה של Volume מיועדת לעבודה עם דברים שאתם צריכים לשמור ואין לכם צורך לנהל אותם, כמו לדוגמא עבודה עם מסד נתונים, הוא נשמר איפשהו, ואתם לא באמת עושים משהו עם הקובץ, אלה עובדים על שרת שמנהל את מסד הנתונים, לאחר מכן, מחקתם את הקונטיינר, יצרתם קונטיינר אחר ואת מסד הנתונים חיברת לקונטיינר החדש, זאת בעצם המטרה של הדבר הזה שנקרא Volume
גם במקרה הזה אין אפשרות ליצור Volume על קונטיינר פעיל, צריך למחוק אותו וליצור מחדש עם חיבור של ה-Volume.
1) נעצור ונמחק את הקונטיינר leidertech עם הפקודה docker rm -f leidertech
2) ניצור קונטיינר חדש עם ה Volume הרצוי, כמו פעם קודמת נראה סינטקס ישן ואז חדש.
סינטקס ישן - docker run -d --name leidertech -v levs:/data alpine tail -f /dev/null
(השתמשתי ב "d-" בשביל שלאחר הפקודה, הקונטיינר פשוט ירוץ ולא יחבר אותי לסשן של הקונטיינר שנוצר)
נבדוק שנוצר ה Volume בעזרת הפקודה docker volume ls:
סינטקס חדש:
docker run -d --name leidertech --mount type=volume,source=levs,target=/data alpine tail -f /dev/null
(כמו פעם קדמת, יותר ארוך, אך עם הרבה יותר פרטים)
1) מחקתי את הקונטיינר הקיים עם docker rm -f leidertech
2) יצרתי את הקונטיינר וחיברתי את ה Volume
3) אני מציג את ה Volume שנוצר עם docker volumes ls
6.ד איך לבצע ניתוק של Volume מקונטיינר?
אין ממש פקודה לבצע את הפעולה הזאת, צריך למחוק את הקונטיינר ולייצר אחד חדש בלי Volume.
6.ה איך לייצר חיבור לתיקייה במצב "קריאה בלבד"?
למה זה טוב?
נגיד ובמחשב יש לכם כל מיני קבצים שאתם רוצים "לקרוא" אותם על ידי מערכת כזאת או אחרת מתוך הקונטיינר, אז בשביל שלא יקרו טעויות, ניתן לחבר אותם במצב "קריאה בלבד" וכך הקונטיינר יוכל לגשת לשם אבל לא יוכל לבצע שום דבר בתיקייה או בקובץ ששמתם שם.
לידע כללי - ניתן לבצע BIND או VOLUME במצב של "קריאה בלבד".
גם במקרה הזה אין אפשרות לבצע חיבור בקונטיינר קיים, יש צורך ליצור קונטיינר חדש, כמו בסעיפים הקודמים:
1) נעצור ונמחק את הקונטייר הקיים docker rm -f leidertech.
2) ניצור קונטיינר חדש ונחבר לו תיקייה (בעזרת BIND) במצב RO (קיצור של READ ONLY).
סינטקס ישן - docker run -d --name leidertech -v ~/Desktop/sharefolder:/data:ro alpine tail -f /dev/null
סינטקס חדש - docker run -d --name leidertech --mount type=bind,source=$HOME/Desktop/sharefolder,target=/data,readonly alpine tail -f /dev/null
(ארוך אבל יותר ברור)
בשיטה החדשה, הרבה יותר ברור איפה לשנות את מה שאנחנו רוצים, זאת אומרת צריך לשנות את "bind" ל "Volume" וזה ברור מה אנחנו רוצים לחבר, בנוסף במקום "read only" אפשר לרשום "rw" (קיצור של Read\Write) וזה יחבר כבר בצורה של קריאה\כתיבה, בעיקרון אם לא כותבים "ro", בתור ברירת מחדל, החיבור יתבצע במצב "rw".
יש עוד פרמטרים בשימוש עם Bind, שב 99% לא תשתמשו בהם אבל בשביל שתדעו שהם קיימים להלן, חלק מאופציות מתקדמות של Bind-propagation (הפקודות בשיטה החדשה מאוד מאוד ארוכות, אז תסלחו לי 😅)
rprivate - (ברירת מחדל) — שינויים לא מופצים לשום כיוון
docker run -d --name mycontainer --mount type=bind,source=$HOME/Desktop/sharefolder,target=/data,bind-propagation=rprivate alpine tail -f /dev/null
private - כמו rprivate, אבל לא עובד על תת־mountים
docker run -d --name mycontainer --mount type=bind,source=$HOME/Desktop/sharefolder,target=/data,bind-propagation=private alpine tail -f /dev/null
rshared - שינויים מופצים לשני הצדדים
docker run -d --name mycontainer --mount type=bind,source=$HOME/Desktop/sharefolder,target=/data,bind-propagation=rshared alpine tail -f /dev/null
shared - שינויים מהקונטיינר מופצים החוצה
docker run -d --name mycontainer --mount type=bind,source=$HOME/Desktop/sharefolder,target=/data,bind-propagation=shared alpine tail -f /dev/null
slave - רק שינויים מהמחשב עוברים לקונטיינר
docker run -d --name mycontainer --mount type=bind,source=$HOME/Desktop/sharefolder,target=/data,bind-propagation=slave alpine tail -f /dev/null
rslave - כמו slave, אבל גם עם תת־mountים
docker run -d --name mycontainer --mount type=bind,source=$HOME/Desktop/sharefolder,target=/data,bind-propagation=rslave alpine tail -f /dev/null
7. להציג Volumes בדוקר? - docker volume ls
אם אני רוצה להציג את כל ה VOLUMES שיש לי בדוקר (זאת אומרת את כל מה שחיברתי בכל קונטיינר), אשתמש בפקודה docker volume ls
להלן כל הפרמטרים עם דוגמאות:
- --format - עיצוב מותאם אישית לפלט (Go Templates)
הצגת שם ודרייבר:
"docker volume ls --format "{{.Name}} - {{.Driver}}
הצגת רק שמות:
'""docker volume ls --format '"{{.Name}}
- -q או --quiet - מציג רק את שמות ה־Volumes בלי מידע נוסף (טוב לשימוש בסקריפטים)
docker volume ls -q
8.איך למחוק Volume בדוקר? - docker volume rm
למה בעצם למחוק VOLUME? אז יש לזה כמה תשובות, קודם כל אם מחקתם קונטיינר ואתם לא צריכים אותו, אז ה VOLUME לא נמחק, צריך למחוק אותו בנפרד, דבר שני, לפעמים מצטברים קבצים ישנים, לוגים דברים שלא רלוונטיים יותר וניתן למחוק אותם, או VOLUME שיצרתם בטעות, שגם אין מה לעשות איתו, ניתן למחוק אותם בלי שום בעיה.
¿?חשוב לזכור - אין אפשרות למחוק VOLUME כשהקונטיינר רץ, לכן קודם צריך למחוק אותו
ורק לאחר מכן תוכלו למחוק את ה VOLUME¿?
בשביל למחוק VOLUME, נריץ את הפקודה docker volume rm volume_name.
לצורך דוגמא יש לי VOLUME בשם: lev_mount_2 ואני רוצה למחוק אותו, סדר הפעולות יהיה:
1) לעצור ולמחוק את הקונטיינר עם הפקודה docker rm -f contianer_name
2) לאחר מכן נמחק את ה VOLUME הרלוונטי:
3) נבדוק שה VOLUME לא מופיע יותר:
8.א האם אפשר למחוק כמה VOLUME ביחד בפעם אחת?
התשובה היא כן, בעזרת הפקודה (הפקודה תעבוד רק אם הקונטיינרים מחוקים):
docker volume rm vol1 vol2
8.ב איך למחוק הרבה VOLUME ביחד שלא צריך?
למקרה כזה יש שתי פקודות, האחת תשאל האם אתם בטוחים ובלה בלה בלה, השניה לא תשאל כלום פשוט תבצע את מה שאתם רוצים:
1) פקודה שתשאל "האם אתם בטוחים?" - docker volume prune
2) פקודה "שגר ושכח" - docker volume prune -f
שימו לב - לאחר מחיקת VOLUME אין שום אפשרות לשחזר !!
9. איך עושים "סדר פסח" בדוקר ומנקים Imageים שלא בשימוש כבר בדוקר - docker image prune
אז כמו בסעיף הקודם, אותו דבר יש עם IMAGEים, ניתן למחוק את כולם עם הפקודה prune.
לידע כללי - ב IMAGEים יש הבדל בין IMAGE רגיל לבין IMAGE שהוא "dangling", אימג' שהוא dangling נוצר במידה ויצרו אימג' חדש על אימג' ישן (דרסו אותו), אימג' שיצרו בלי TAG (זאת אומרת בלי לתת לו שם), או אם בונים אימג' ועצרנו באמצע את התהליך (אנחנו נלמד בחלק 5 על Docker build).
לצורך דוגמא, יש לי IMAGE אחד כזה שהוא Dangling, ניתן לראות אותו ברשימה כאן,
הוא מופיע ללא TAG וללא Repository, נריץ את docker images בשביל להציג את כל ה IMAGEים שיש לי:
כמו למחיקה של VOLUME, גם כאן יש שתי פקודות, אחת שואלת האם למחוק והשניה היא "שגר ושכח":
1) פקודה בטוחה יותר ששואלת שאלה - docker image prune
להלן דוגמא, המערכת שואלת האם אנחנו בטוחים:
לחצתי על "y" וקיבלתי הודעה שה IMAGE נמחק:
2) פקודה "שגר ושכח" - docker image prune - f
להלן דוגמא עם הפקודה שהיא "שגר ושכח" והאימג' פשוט נמחק:
יש עוד שתי פקודות, שמוחקות את כלל האימג'ים באותו סגנון, אחת שואלת "האם אתה בטוח בלה בלה בלה?" והשניה היא "שגר ושכח":
1) פקודה בטוחה - docker image prune -a:
והמערכת מחקה לי המון אימג'ים והחזירה לי 279 מגה:
2) עכשיו ננסה את הפקודה שהיא שגר ושכח - docker image prune -a -f:
בלי שאלות, בלי שום דבר, ישר מחק:
9.איך לבדוק כמה משאבים צורך כל קונטיינר בדוקר - docker stats
כמו בכל דבר, גם בדוקר צריך לבדוק צריכת משאבים של קונטיינרים, בדיוק את זה עושה הפקודה docker starts, אבל ברגע שתריצו אותה, תקבלו טבלה מאוד נחמדה עם מידע שבעצם מראה לכם ניצול משאבים בזמן אמיתי:
בשביל לצאת מהמצב הזה נלחץ על CTRL+C.
לכן ניתן להשתמש בכמה וכמה פרמטרים בשביל לקבל מידע בצורה יותר נוחה, בעזרת הפרמטרים הבאים:
- --no-stream - מציג את הנתונים פעם אחת בלבד, בלי המשכיות: docker stats --no-stream
- --format - מאפשר להציג את הנתונים בפורמט מותאם אישית עם תבניות:
"docker stats --format "table {{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}} - בצורה הזאת המידע שוב
ירוץ בזמן אמת ו"יתקע" לכם בסשן, לכן צריך לשלב את זה עם הפרמטר מהסעיף הקודם:
docker stats --no-stream --format "table {{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}"
- --no-trunc - מציג את המידע המלא בלי לקצר ערכים כמו מזהי קונטיינרים:
11. תקשורת בדוקר – איך לחבר בין קונטיינרים ולפתוח פורטים?
לפני שנמשיך חשוב להכיר כמה פרמטרים רלוונטיים לפקודה docker network ומתאימה לכלל סוגי הרשתות:
- docker network ls - הצגת כל הרשתות הקיימות
- <docker network inspect <network_name - הצגת מידע מפורט על רשת
- <docker network create <network_name - יצירת רשת חדשה (ברירת מחדל היא Bridge)
- <docker network rm <network_name - מחיקת רשת קיימת
- docker network prune - מחיקת כל הרשתות שאינן בשימוש
כמו בכל סביבה וירטואלית גם כאן יש כמה סוגי רשתות, 4 עיקריות שמוגדרות מראש ואחת שהמשתמש יכול להגדיר לבד:
1. רשת מסוג "Bridge" (ברירת מחדל):
- הרשת הסטנדרטית של דוקר.
- כל קונטיינר מקבל IP פנימי משלו.
- מאפשרת תקשורת בין קונטיינרים.
2. רשת מסוג "Host":
- הקונטיינר משתמש ישירות ברשת של המחשב המארח.
- אין בידוד רשת בין הקונטיינר למארח.
3. רשת מסוג "None" - קונטיינר ריק ללא חיבור לרשת בכלל:
- הקונטיינר ללא חיבור רשת בכלל.
- מבודד לגמרי מבחינה רשתית.
4. רשת מסוג "User-defined" - רשת שהיא "מותאמת אישית":
- רשת שנוצרת ידנית לפי דרישות המשתמש.
- מאפשרת שליטה ובידוד מוגברים בתקשורת בין קונטיינרים.
אלו הן ארבעת סוגי הרשתות העיקריים בדוקר.
לידע כללי יש גם: Overlay, Macvlan ,IPVlan -ניתן לקרוא עליהן ברשת - הן פשוט פחות נפוצות.
11.א - רשת מסוג "Bridge"
את סוג הרשת הזאת, דוקר יוצר בתור ברירת מחדל כשלא אומרים לו משהו אחר, ברת הזאת הקונטיינרים מתקשרים ביניהם במידה וצריך, כל קונטיינר מקבל כתובת IP פנימית משלו ויש לו אפשרות לגשת לכל קונטיינר אחר לפי שם או לפי IP.
למה זה טוב? במידה ואתם רוצים לשלוט על הקונטיינר ולא לתת לו לצאת לאינטרנט סתם ככה, אלה רק אם בחרתם לפתוח לו פורט ספציפי לדוגמא.
11.א.א. איך יוצרים רשת מסוג Bridge בדוקר?
בתור ברירת מחדל, רק אם נרצה ליצור רשת מותאמת אישית (עם שם שאנחנו נרצה וכד') נצטרך לציין שאנחנו רוצים ליצור רשת מסוג Bridge, במצב אחר, מספיק להריץ פקודה רגילה להרצת\יצירת קונטיינר והרשת שתיווצר היא Bridge.
כיצד ליצור רשת מותאמת אישית, אני אסביר בסעיף שמדבר על רשתות מותאמות אישית :)
11.א.ב. איך פותחים פורטים לקונטיינר בדוקר - שילבתי כאן גם את BRIDGE וגם את נושא פתיחת הפורטים.
מאחר ויש שירותים שמצריכים פתיחת פורטים, יש צורך בביצוע הפעולה על מנת שנוכל לגשת לשירות כזה או אחר מבחוץ, לצורך כך נשתמש בפרמטר מאוד חשוב p-, הסינטקס הוא כזה:
docker run -d -p [your_computer_port]:[container_port] --name ubuntu sleep infinity
( במקרה הזה sleep infinity מורה לקונטיינר להפסיק כל פעילות אחרת ולהישאר פעיל למשך זמן בלתי מוגבל.)
לצורך הדגמה, ניצור קונטיינר קטן עם שרת דואר ונפתח את פורט 80 בקונטיינר, ואצלינו במחשב נחבר אותו ל 8080:
docker run -d --name leidertechs_ports_test -p 8080:80 nginx
ועכשיו אחרי שפתחנו פורט עם p-, מה שקורה הוא שהפורט שבקונטיינר מחובר לפורט במחשב שעליו רץ Docker.
לכן – אם אנחנו רוצים לגשת לשירות (במקרה הזה שרת nginx) שבקונטיינר ממחשב אחר ברשת, אנחנו לא ניגשים לקונטיינר, אלא לכתובת ה־IP של המחשב שמריץ את הסביבה של הדוקר.
נבצע בדיקה של הכתובת:
לאחר מכן, מאחר והרצנו NGINX (שהוא שרת WEB, יש לו עמוד של "ברוכים הבאים) ואנחנו נוכל לראות אותו:
וכפי שניתן לראות הכל עובד, סימן שפתחנו פורטים נכון.
כמו כן, במידה ונריץ עכשיו docker ps, נוכל לראות את הפורט שפתחנו:
פרמטרים נוספים שהם יחודים אך ורק לרשת Bridge:
- --driver bridge - יוצר רשת מסוג - דוגמא:
bridge | docker network create --driver bridge my-bridge
- --subnet - קובע את טווח כתובות ה IP דוגמא:
docker network create --subnet 192.168.100.0/24 my-subnet-net
- --gateway - מגדיר כתובת gateway דוגמא:
docker network create --subnet 192.168.100.0/24 --gateway 192.168.100.1 my-gateway-net
- --ip-range - תחום IP לקונטיינרים בתוך הרשת דוגמא:
docker network create --subnet 192.168.100.0/24 --ip-range 192.168.100.128/25 my-range-net
- -o com.docker.network.bridge.name=br0 - (אופציונלי) שם רשת פנימי בלינוקס דוגמא:
docker network create -o com.docker.network.bridge.name=br0 my-custom-bridge
11.א.ג רשת מסוג "Host"
למה שנרצה לחבר קונטיינר כזה? בעיקרון נגיד ויש לנו שרת אינטרנט ואנחנו לא רוצים להתחיל להתעסק עם פורטים כי אנחנו יודעים ישר שהשירות\אפליקציה הולכים לעבוד באינטרנט ואנחנו נצטרך לגשת אליו, כאן אין פרמטר p- ואנחנו נראה את זה עכשיו בהדגמה, אני אמחק את הקונטיינר האחרון שיצרתי ואצור אחד חדש בלי הפניית פורט וזה יעבוד, במקרה הזה אני כן אציין שאני רוצה לפתוח רשת מסוג Host:
docker run -d --name leidertech_host_network_test --network host nginx
11.א.ד רשת מסוג "None":
למה בעצם צריך רשת מסוג "None"? , המטרה של חיבור רשת כזה, הוא מאוד פשוט, נגיד ואתם רוצים לבצע בדיקות של תוכנה בלי "הפרעות" מהרשת, או להשתמש במחשב שהוא עם אפליקציה אחת שלא צריכה לגשת לרשת, יש המון תסריטים לנושא הזה, קונטיינר שהמטרה שלו להיות "מכונה" או משהו כזה שלא מצריך רשת.
לצורך דוגמא ניצור קונטיינר כזה ללא חיבור לרשת:
docker run -d --network none --name leidertech-no-net-container ubuntu sleep infinity
ועכשיו אתחבר לתוך הקונטיינר עם הפקודה: docker exec -it no_network_container bash,
ואנסה לבצע בתוכו את apt update:
וניתן לראות שלא מצליחים לעשות כלום כי אין תקשורת:
11.א.ה.רשת מסוג "User-defined"
לפני שאני מתחיל לחפור לכם, חשוב לי להבהיר, לא מדובר על עוד סוג רשת, אלה על צורת הגדרה, במקרה הזה אנחנו יוצרים צורה שהיא מותאמת אישית לנו, בה ניתן להתאים את שם הרשת, תווך הכתובות ועוד המון דברים, אני לא אעבור על כולם, אבל אעבור על העיקריים.
- --driver - מגדיר את סוג הרשת (לרוב bridge) - --driver bridge לדוגמא:
docker network create --driver bridge my-net
- --subnet - קובע את טווח כתובות ה־IP ברשת - --subnet 172.16.0.0/16 לדוגמא:
docker network create --subnet 172.16.0.0/16 my-subnet-net
- --gateway - מגדיר את כתובת השער ברירת מחדל(gateway) ברשת - --gateway 172.16.0.1 לדוגמא:
docker network create --subnet 172.16.0.0/16 --gateway 172.16.0.1 my-gateway-net
- --ip-range - תחום כתובות IP שיחולקו לקונטיינרים על ידי המערכת (דוקר)- --ip-range 172.16.1.0/24 לדוגמא:
docker network create --subnet 172.16.0.0/16 --ip-range 172.16.1.0/24 my-range-net
- --ipv6 - מפעיל תמיכה ב־IPv6 ברשת - --ipv6 לדוגמא:
docker network create --ipv6 --subnet 172.16.0.0/16 my-ipv6-net
- --label - מוסיף תגית (metadata) לזיהוי הרשת - --label env=dev לדוגמא:
docker network create --label env=dev my-labeled-net
נריץ פקודה לדוגמא שתייצר לנו רשת בשם leider_net:
docker network create --driver bridge --subnet 172.16.0.0/24 --gateway 172.16.0.1 --ip-range 172.16.0.128/28 leider_net
עכשיו נריץ את docker network ls בשביל לבדוק את כל השרתות שיש לנו ונוכל לראות שם את הרשת שיצרנו:
עכשיו אחרי שיצרנו רשת, צריך לחבר אליה מחשבים, או במקרה שלנו קונטיינרים ולבדוק ביניהם תקשורת.
מטבה הדברים עכשיו נשאלת השאלה: האם אפשר לחבר קונטיינר קיים לרשת שיצרנו? והתשובה היא כן ! ניתן לחבר קונטיינרים קיימים לרשת חדשה, פשוט צריך לעצור את הקונטיינר לפני כן, ובדיוק עכשיו אנחנו נחבר שתי קונטיינרים קיימים לרשת leider_net:
הינה רשימת הקונטיינרים שיש לי :
אנחנו נקח את Leidertech1 ואת leidertech2 ונחבר אותם ל leider_net (מקורי לא? 😅), אז קודם כל צריך לעצור את הקונטיינרים בעזרת הפקודה: docker stop leidertech1 leidertech2
השלב הבא יהיה לחבר אותם לרשת החדשה leider_net, רק שבמקרה הזה, אין אפשרות לשרשר כמה קונטיינרים ביחד, ניתן לחבר כל פעם רק קונטיינר אחד (לא יודע למה לא איפשרו את זה עדיין, זה די מעיק האמת), אבל אפשר לשרשר את הפקודה בעזרת סימן "
;" בין הפקודות בצורה הזאת:
docker network connect leider_net leidertech1; docker network connect leider_net leidertech2
ומאחר ולא קיבלנו שום הודעת שגיאה, זה אומר שזה עבד:
האם זה עבד או לא, אפשר לראות עם docker inspect, הבעיה היא שהפקודה הזאת דיי מסורבלת אז צריך לעשות קצת "סלטות באוויר" בשביל לקבל מידע, כי במקרה הזה נצטרך להשתמש בלולאה של לינוקס (כן כן, דיי מעצבן), אני לא הולך להכנס לסינטקס של זה כרגע, אלה רק לכתוב לכם אותה כדי שסתם תראו איך זה נראה (כי לולאות ב BASH, שזאת סביבת שורת הפקודה של לינוקס, זה נושא אחר לגמרי):
docker inspect -f '{{range $k, $v := .NetworkSettings.Networks}}{{println $k}}{{end}}' leidertech1
?¿לידע כללי?¿:
אם יצא לכם לכתוב סקריפטים או לתכנת, אז בעצם Range היא לולאת "For" מתוך שפת Go Lang.
בפלט ונוכל לראות את סוג הרשת והשם של הרשת שאליה מחובר הקונטיינר:
במצב אחר, עם docker inspect leidertech2 |less נוכל לראות את הרשת בצורה אחרת (כפי שלמדנו בסעיף הראשון)
וכמו תמיד אני מצרף לכם את כל הפרטמרים הקיימים שקשורים ברשת מותאמת אישית:
- --driver
- --subnet
- --gateway
- --ip-range
- --ipv6
- --attachable
- --internal
- --label
- -o com.docker.network.bridge.name
- -o com.docker.network.bridge.enable_icc
- -o com.docker.network.bridge.enable_ip_masquerade
- -o com.docker.network.driver.mtu
זה הכל להפעם
המייל שלי לכל שאלה levl@leidertech.co.il.
מדריך לינוקס למתחילים:
כאן
להלן מדריך מצולם:
