מדריך דוקר למתחילים בעברית – חלק 2 - פקודות בסיסיות לעבודה עם קונטיינרים ואימג'ים

 

ברוכים הבאים לחלק 2 של המדריך לדוקר למתחילים בעברית, במדריך זה נעבור על פקודות בסיסיות לניהול קונטיינרים (במידה ואתם לא יודעים מה זה "קונטיינר" בהקשר של דוקר, נא לקרוא את החלק הראשון: כאן)

לפני שנרוץ להריץ פקודות, אני רוצה להזכיר לכם שתי מושגים חשובים, מה זה "Image" ומה זה "Container"?

"Image" = קובץ תבנית שמכיל מערכת + קבצים מוכנים להרצה, אפשר לקרוא לזה "מתכון" למערכת ההפעלה (מה צריך, כמה צריך איך צריך ומזה נוצרת מערכת הפעלה.

"Container" - הוא בעצם ה"מחשב" שנוצר מתוך ה"מתכון" שהוא ה Image, מדובר על מערכת הפעלה עם הדברים שצריך בשביל להריץ את השירות שאנחנו צריכים בלי כל מיני תוספות מלמעלה.

להלן הסעיפים שנעבור עליהם במדריך זה:

1) בדיקת מידע כללי על המערכת - docker info

2) יצירה, הרצה של קונטיינר, התחברות לתוך קונטיינר (עם הפרמטרים it- ו ai- ו d-) - docker run 

3) הצגת מידע על קונטיינרים רצים כרגע במערכת - docker ps

4) הצגת מידע על כל הקונטיינרים שיש כולל אלה שלא רצים - docker ps -a

5) איך לעצור קונטיינר? - docker stop

6) איך "להקפיא" קונטיינר בדוקר? - docker pause

7) איך להפעיל קונטיינר שכבר עצרנו? - docker start

8) איך למחוק קונטיינר? - docker rm

9) איך למחוק  "docker rmi  - ?"Image

10) איך להציג את כל ה Imagים הקיימים לנו במערכת? - docker images

11) איך להוריד Image למחשב בלי להפעיל אותו? - docker pull

1. בדיקת מידע כללי על המערכת - docker info

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

2. יצירה והרצה של קונטיינר - docker run

במידה ואנחנו נרצה להריץ איזשהו קונטיינר, נריץ את הפקודה docker run, במידה ואין IMAGE של מה שאנחנו צריכים במערכת שלנו, Docker ילך ל "Docker hub" (מאגר עולמי של אימג'ים), ויוריד אותו (יבצע פעולת Pull)  למחשב, לאחר מכן יבנה מזה קונטיינר, ויריץ את מה שצריך (סרוויס, סקריפט, פקודה וכד') ולאחר מכן "יכבה" ובעצם יצא מהקונטיינר, לכן חשוב להבין מה בדיוק אתם מבצעים, לצורך הדגמה אנחנו נעבוד עם קונטיינר ששמו Alpine (קונטיינר קטן מאוד שמעולה לתרגולים).

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

ניתן להריץ את הקונטיינר בשתי צורות:

2.א סתם להוריד ולהריץ אותו בלי שנוכל לעשות משהו - שזה בדיוק מה שתעשה הפקודה docker run alpine ובעצם לאחר שנריץ את הפקודה, הדוקר יוריד את ה IMAGE למחשב שלנו, יפעיל ויכבה אותו ואז הוא יהיה בסטטוס Exited.

2.ב בשביל שנוכל לראות שהוא עשה משהו -  אנחנו ניתן לו פקודה לבצע, לדוגמא להגיד "Hello from Alpine".

נעשה את זה בעזרת הפקודה: "docker run alpine echo "Hello from Alpine.

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

במקרה שלנו בשביל שנקבל לאחר ההרצה שורת פקודה שנוכל לבצע משהו בתוך הקונטיינר, נוסיף את הפרמטרים it- (יש גם ia-, עליו נפרט בהמשך, כאן רק נפרש את המשמעות שלו) שאלו בעצם שתי פרמטרים שכל אחד מהם עושה משהו אחר, אך בשילוב מתקבלת תוצאה מאוד חשובה, הפרמטרים האלה בעצם יתנו לנו שורת פקודה שנוכל לעבוד בתוך הקונטיינר.

docker run -it alpine sh

(בתוך alpine אין BASH (סביבת פקודה של לינוקס) יש שם SH, לכן כתבתי SH בסוף)

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

להלן הפרמטרים שאפשר להשתמש במקרה הזה והפרוש שלהם:

• "i" - שהוא בעצם "Interactive" ובעצם בצורה הזאת ניתן להקליד דברים לתוך הקונטיינר - הבעיה שלא רואים תגובה.
• "t" - שהוא בעצם "Terminal" - יפתח לכם מסך עם שורת פקודה בלי שתוכלו להקליד שום דבר, לכן צריך לשלב את שתיהם.
• "a" - שהוא בעצם "Attach" - ברגע שהרצתם פקודה והקונטיינר במצב Exited (שזה בעצם "כבוי"), אין אפשרות להתחבר אליו עם it-, ולכן צריך להתחבר עם ai- (אנחנו נראה את זה בהמשך)

2.ג איך לגרום לקונטיינר להעלות לבד לאחר הפעלה מחדש?

במידה ובוצע הפעלה מחדש למחשב, נרצה שהקונטיינר שלנו יעלה לבד, לצורך כך נשתמש בפרמטר "restart":

docker run -d --name alpaka_restart --restart=always alpine

בפרמטר הזה צריך להשתמש בתהליך הרצת הקונטיינר, בנוסף אם לא תתנו לקונטיינר שום פקודה או פעולה שהוא צריך לעשות ללא הפסקה, בסוף הפעולה הזאת הקונטיינר פשוט "יכבה" לכן ניתן להוסיף משהו בסגנון הזה "tail -f /dev/null" הפקודה הזאת לא עושה שום דבר מיוחד, רק גורמת לקונטיינר להישאר חי, אם מחברים את הכל זה נראה כך:

docker run -d --name alpaka_restart --restart=always alpine tail -f /dev/null

להלן כל הפרמטרים:

• `no` - (ברירת מחדל) – לא מנסה להפעיל מחדש 
• `always`  - תמיד מנסה להפעיל מחדש – גם אחרי ריבוט 
• `on-failure` - יפעיל מחדש רק אם הקונטיינר נפל (Exited עם קוד שגיאה) 
• `unless-stopped` - יפעיל מחדש כל עוד לא עצרת אותו בעצמך 

במידה ונרצה לשנות את "מדניות" ההפעלה מחדש נשתמש ב docker update:

docker update --restart no container_name

(Docker update - יודע לעשות עוד הרבה דברים, אנחנו נלמד עליו בהרחבה בחלק 4)

2.ד האם אפשר לקרוא לקונטיינר בכל שם שבא לנו?

התשובה היא כן, בעזרת הפרמטר name-- ואני אשתמש בו כאן

אני אריץ את זה בכל הצורות בשביל שתוכלו לראות את ההבדלים, נתחיל: docker run --name alpaka_its_cool alpine:

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

מה שקורה מאחורי הקלעים, ביקשנו מדוקר להוריד את הקונטיינר Alpine לקרוא לו בשם "Alpaka_its_cool" (כן יש לי קטע עם אלפקות, לא יודע למה), להפעיל בתוך הקונטיינר שורת פקודה ולהציג לנו במסך את המשפט:
"!LeiderTech.co.il are the best" (כמובן שאני אובייקטיבי לחלוטין כן... 🤣).

2.ה איך לעבוד על קונטיינר בדוקר?

במצב הזה יש שתי סיטואציות, הראשונה, הרצנו docker run ואז אנחנו רוצים להתחבר ישר ולעבוד, השניה זה אחרי שכבר הורדנו את הקונטיינר ואני רוצים להתחבר אליו לעבוד, אני אראה את שתי הדוגמאות:

2.ו נריץ את הפקודה: docker run -it --name alpaka_its_cool alpine sh (ה SH בסוף זאת שורת פקודה "מצומצמת" בתוך Alpine).

נוכל לראות שאנחנו בתוך שורת פקודה, בתוך הקונטיינר:

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

בשביל לצאת, נריץ את exit ונחזור למכונה הרגילה שלנו:

2.א.א) איך להתחבר לקונטיינר אחרי שכבר הורדנו אותו בדוקר?

במקרה שלנו בעצם ביצענו פקודה ויצאנו מהדוקר, אם נבדוק את הסטטוס שלו (אנחנו נלמד לעשות את זה בהמשך), נקבל שהוא במצב Exited, שזה בעצם סוג של "מכובה" (במקרה הזה, כי לא נתנו לו לרוץ ולבצע פעולות כאלה ואחרות), לכן בשביל להתחבר אליו, צריך להתחיל אותו שוב, נעשה את זה בעזרת הפקודה הזאת: 

docker start -ai alpaka_its_cool

ונוכל לראות שאנחנו שוב בתוך שורת הפקודה בקונטיינר:

2.א.ב) איך יוצרים קונטיינר שירוץ ברקע?

במידה ואנחנו יוצרים קונטיינר ורוצים שהוא פשוט יעבוד לנו ברקע, אנחנו נשתמש בפרמטר שנקרא "מנותק" d- שהפרוש שלו הוא "Detached", מה שהוא עושה בעצם זה להריץ את הפקודה שאנחנו רוצים בתור הקונטיינר ולנתק אותנו מהסשן, מהחיבור לקונטיינר, ואז הקונטיינר רץ לו ברקע ומבצע את מה שאנחנו צריכים, ניתן כאן פקודה לדוגמא שתגרום לדוקר שלנו להריץ סתם ככה משהו ברקע:

 docker run -d --name leidertech alpine tail -f /dev/null

הפעולה בוצעה, ובעצם הקונטיינר רץ ברקע:

עכשיו ננסה להריץ את אותה הפקודה בלי d-:

ובעצם עכשיו אנחנו "תקועים" עם פקודת הרצה של הקונטיינר ולא יכולים לעשות כלום

בשביל לצאת מהמצב הזה נלחץ על ctrl+c (לפעמים צריך כמה פעמים ברצף) ואז נחזור לשורת הפקודה שלנו:

הקונטיינר עצמו ימשיך לרוץ ברקע

3.הצגת מידע על קונטיינרים רצים כרגע במערכת בדוקר

בשביל להציג מידע על הקונטיינרים הרצים לנו במערכת נריץ את docker ps:

הפרוש של העמודות: 

• CONTAINER ID - המזהה של הקונטיינר
• IMAGE - מה שם האימג' שירד מדוקר האב (במקרה שלנו זה משם)
• COMMAND  - מה בעצם כרגע מבצע הקונטיינר - במקרה הזה הוא הפקודה שרצה עכשיו
• CREATED - מתי נוצר הקונטיינר?
• STATUS - מה המצב שלו? רץ, לא רץ?
• PORTS - האם יש הפניית פורטים (נלמד על זה בחלק 4)
• NAMES - מה השם של הקונטיינר? (האם ניתן לתת שם שאנחנו רוצים? כן אני אראה בהמשך)

3.א איך להציג רק עמודות ספציפיות עם docker ps?

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

"docker ps --format "table {{.Image}}\t{{.Command}}\t{{.Status}}\t{{.Names}}

כפי שניתן לראות העמודות הן בהתאם, להלן כלל העמודות שניתן להציג:

{{.ID}}	מזהה הקונטיינר
{{.Image}}	שם ה־image
{{.Command}}	הפקודה שהורצה
{{.CreatedAt}}	מתי נוצר הקונטיינר
{{.RunningFor}}	כמה זמן הוא רץ
{{.Status}}	סטטוס נוכחי (Up/Exited)
{{.Ports}}	הפורטים שנפתחו
{{.Names}}	השם של הקונטיינר

4. הצגת מידע על כל הקונטיינרים שיש כולל אלה שלא רצים בדוקר

להבדיל מהפקודה הקודמת, בפקודה הזאת נוכל להציג את כלל הקונטיינרים שיש לנו, גם כאלה שלא רצים (Exited):

לצורך דוגמא נציג רק את אלה שהם בסטטוס EXITED, הפקודה: "docker ps -a --filter "status=exited

ניתן להשתמש בכל הפרמטרים הללו:

--all, -a        מציג את כל הקונטיינרים, גם כאלה שכבר נעצרו  

--filter, -f     מסנן תוצאות לפי תנאי (למשל לפי סטטוס או שם)  

--format         מציג רק את העמודות שאתה רוצה, בעיצוב שאתה מגדיר  

--last, -n       מציג רק את הקונטיינרים האחרונים, לפי מספר  

--latest, -l     מציג רק את הקונטיינר האחרון שנוצר  

--no-trunc       מונע קיצוץ של טקסטים ארוכים (כמו מזהים)  

--quiet, -q      מציג רק את מזהי הקונטיינרים (Container IDs) בלי מידע נוסף  

--size, -s       מציג מידע על גודל הדיסק שכל קונטיינר תופס  

5. איך לעצור קונטיינר בדוקר?

לצורך עצירת קונטיינר נשתמש בפקודה docker stop, לצורך דוגמא, אני מריץ כרגע 5 קונטיינרים:

אני אעצור את test1, הפקודה: docker stop test1, נקבל תגובה "test1" , שזה אומר שהקונטיינר נעצר:

לאחר מכן נריץ את docker ps -a בשביל לראות את כל הקונטיינרים שלנו, ונראה ש test1 הוא Exited:

5.א האם אפשר לעצור כמה קונטיינרים ביחד בדוקר?

התשובה היא כן, בצורה הבאה: docker stop test2 test3 test4, קיבלנו שוב את שמות הקונטיינרים שעצרנו, זאת אומרת שהכל בסדר:

שוב נריץ את docker ps -a, ונראה שהם כולם במצב Exited:

5.ב איך לתזמן כיבוי של קונטיינר בדוקר?

ניתן לשלב את הפרמטר t- ולאחר מכן כמה שניות ואת שם הקונטיינר שאנחנו רוצים לעצור בצורה הבא:

docker stop -t 3 container_name

מה שיקרה, זה שלאחר 3 שניות הקונטיינר יקבל פקודת כיבוי.

5.ג איך לעצור ולמחוק קונטיינר בפקודה אחת בדוקר?

נגיד ויש לנו קונטיינר שאנחנו לא נצטרך אותו, יש אפשרות לבצע עצירה ואז מחיקה, בעזרת הדגל f- (בכוח - force)

לצורך דוגמא יצרתי קונטיינר בשם test83 שאני לא צריך אותו יותר, אריץ פקודה שתעצור ותמחק את הקונטיינר:

נריץ את הפקודה: docker rm -f test83

קיבלנו תגובה מדוקר וניתן לראות שהוא לא מופיע יותר ברשימה:

6. איך "להקפיא" קונטיינר בדוקר או בעצם לעשות לו Pause?

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

במצב של Pause, מה שקורה בעצם זה "סוגר" את התוכנה, אבל המערכת הפעלה עצמה (המחשב) ממשיך לרוץ.

ביצוע "הקפאה" מתבצע בעזרת הפקודה  docker pause container_name:

ניתן לראות שהוא עצר:

בשביל "להוציא" אותו מהקפאה נריץ את הפקודה : docker unpause container_name

ונראה שהקונטיינר חזר לפעול:

ניתן לעצור כמה קונטיינרים ביחד על ידי הפקודה הזאת:

docker pause cont1 cont2 cont3

ו"להפשיר" על ידי docker unpause cont1 cont2 cont3

7. איך להריץ קונטיינר שעצרנו (שעשינו לו Stop) בדוקר?

 

בשביל להפעיל קונטיינר נשתמש בפקודה docker start  ושם הקונטיינר בסוף - docker start test1:

נריץ את docker ps -a (אפשר גם בלי a-) ונראה שהוא רץ:

7.א האם אפשר להפעיל כמה קונטיינרים ביחד בדוקר?

כן, ניתן להפעיל כמה קונטיינרים ביחד, בדומה לפקודה הקודמת עם STOP, נשתמש הפעם ב START:

docker start test1 test2 test3

נריץ את docker ps -a (ניתן גם בלי a-) בשביל לבדוק את המצב:

ניתן לראות שכולם למעלה.

לידע כללי מה קורה מאחורי הקלעים ברגע שמריצים את -  docker start, הוא לא יבצע שום דבר חדש, אלה ימשיך להריץ את הדבר האחרון שנתנו לו, פקודה, שירות תוכנה וכד', בעמודה "Command" ניתן לראות מה אנחנו מריצים, כאן נתתי לו סתם דוגמא שתרוץ בשביל שהוא לא יפסיק.

8. איך למחוק קונטיינר בדוקר?

מחיקת קונטיינר מתבצע בעזרת הפקודה docker rm continer_name, אבל אי אפשר סתם למחוק אותו,

כי אי אפשר סתם ככה למחוק קונטיינר, צריך קודם לעצור אותו ורק לאחר מכן למחוק אותו, אבל מאחר ואנחנו אנשי מחשוב ואני לא אוהב לבצע כל דבר 50 פעם, אנחנו נשלב שתי פקודות בתוך פקודה אחת בעזרת הסימן "&" אם אנחנו נכתוב את הסימן הזה פעמיים "&&", המשמעות של הסימן הזה בלינוקס, הוא "רק אם הצלחת להריץ את הפקודה הראשונה ולא התפוצץ המחשב והכל בסדר, תריץ את השניה", אז נריץ את הפקודה בצורה הזאת: docker stop test1 && docker rm test1

לא קיבלתי שום שגיאה, אלה פלט תקין:

ונבדוק מה רץ לנו עכשיו עם docker ps -a (אפשר גם בלי a-):

ניתן לראות שאין את test1 יותר (בעמודה מצד ימין).

9. איך למחוק Image בדוקר?

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

להלן סדר הפעולות שצריך לבצע בשביל למחוק את ה Image:

1) לעצור את הקונטיינר במידה והוא רץ, 2) למחוק את הקונטיינר, 3) למחוק את ה IMAGE, ניתן לבצע את זה בשלוש 

פקודות שניתן להריץ אחת אחרי השניה:

1) לעצור את הקונטיינר -  docker stop container_name

2) למחוק את הקונטיינר- docker rm container_name

3) למחוק את האימג' - docker rmi image_name

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

docker stop test1 && docker rm test1 && docker rmi alpine

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

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

docker stop $(docker ps -q) && docker rm $(docker ps -a -q) && docker rmi $(docker images -q)

❗ לא להריץ את הפקודה הזאת בשרת בסביבה אמיתית– היא מוחקת הכל ❗

ועכשיו אפשר לראות שהכל נמחק:

להלן פירוש של הפקודה:

• docker stop $(docker ps -q) - עצר את כל הקונטיינרים.
• docker rm $(docker ps -a -q) - מחק את כל הקונטיינרים כולל אלה שכבר היו במצב EXITED.
• docker rmi $(docker images -q) - מחק את כל האימג'ים.

10. איך לקבל מידע על Image בדוקר?

בשביל לקבל מידע ולהבין אילו Imagים יש לנו במערכת נריץ את הפקודה docker images:

ניתן להשתמש בפרמטרים הללו:

• --all, -a  - מציג גם תמונות ביניים (intermediate images) שלא מוצגות כברירת מחדל

• --digests  - מציג גם את ה־digest של ה־image (מזהה ייחודי נוסף)

• --filter, -f  - מסנן לפי תנאי מסוים (כמו לפי שם או גודל) - פה הסינטקס קצת קשה, אז הינה דוגמא:
  
  סינטקס לדוגמא: "*docker images -f "reference=alpine
  
  
• -- format  -  מציג את הפלט לפי תבנית מותאמת אישית (כמו ב־docker ps) - גם פה הסינטקס קצת קשה,
  אז הינה דוגמא:"docker images --format "{{.Repository}}:{{.Tag}} ({{.Size}})
  
  
• --no-trunc  - מציג את כל המזהים (image ID, command...) במלואם, בלי קיצורים
  
  
• --quiet, -q  -  מציג רק את מזהי ה־image (IMAGE ID), בלי טבלה

11. איך להוריד Image של דוקר למחשב בלי להפעיל אותו?

הורדה של Image מתבצעת בעזרת הפקודה docker pull what_to_pull, מה שיקרה בפועל, זה שהמערכת פשוט תוריד להם אימג' הכי עדכני שיש למערכת שהציינתם למחשב וזהו, ורק אם תרצו לעשות איתו משהו תצטרכו להריץ אותו עם docker run כפי שלמדנו בסעיף על docker run.

תשימו לב לזה שכתוב "Latest" - המערכת משכה את הגירסה האחרונה שיש לאובונטו במאגר של דוקר, ורק שמרה לנו אותו במחשב בלי לעשות כלום.

שימו לב, נריץ את docker images ונקבל חמישה אימג'ים:

ורצים לנו 4 קונטיינרים:

11.א איך לבחור איזו גירסת Image להוריד?

בדוקר יש פרמטר שנקרא tag שהוא בעצם אחראי על להגיד למערכת, איזו גירסה אנחנו רוצים להוריד, ואנחנו עכשיו נשתמש בו בשביל להוריד 3 גרסאות שונות של Image, הסינטקס: docker pull image:tag:

כאן ניתן לראות את ההבדלים בין הגרסאות השונות של האימג'ים:

להלן פרמטרים של הפקודה:

-a, --all-tags - מושך את כל ה־tags (כל הגרסאות) של ה־image

--platform - מושך גרסה לארכיטקטורה מסוימת (למשל linux/amd64)

-q, --quiet - הורדה בלי להציג התקדמות במסך

--disable-content-trust - מבטל אימות חתימות דיגיטליות (ברירת מחדל: true)

עד כאן להפעם,

המייל שלי לכל שאלה: levl@leidertech.co.il

מדריך לינוקס למתחילים: כאן

חלק 3 במדריך דוקר: כאן

כל החלקים של המדריך על דוקר: כאן

מדריך PowerShell למתחילים: כאן

להלן מדריך מצולם:

מדריך לינוקס למתחילים בעברית – חלק 2: תיקיות מערכת, ניווט ופקודות בסיסיות.

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

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

1) לנווט בין תיקיות.

2) לקרוא תוכן של קבצים כדוגמת טקסט\קונפיגורציה וכד'.

3) איך לדעת באיזו תיקייה אני נמצא?

4) להציג תוכן של תיקיות.

משמעות של צבעים ברשימת תיקיות

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

צבע כחול - תיקייה 

צבע ירוק - קובץ שניתן להפעיל

צבע צהוב עם רקע שחור - התקן

צבע ורוד - קובץ תמונה

צבע אדום - קובץ ארכיון

צבע אדום עם רקע שחור - קיצור דרך לא תקין

רשימת תיקיות ומבנה תיקיות מערכת בלינוקס

מבנה התיקיות בלינוקס שונה ממה שאנחנו מכירים בווינדוס, אין דבר כזה "כונן :C" שבו יושבות כל התיקיות, כלל התיקיות נמצאות בדיסק הקשיח תחת התיקיה הראשית שהיא תיקיית ה-ROOT ומסומנת ב"סלאש" - "/" בתוך התיקה הזאת ישנן כל התיקיות שהמערכת והמשתמשים צריכים.

מבנה התיקיות נראה ככה:

(אם אתם בלינוקס ומנסים להריץ את אותה הפקודה שאני מריץ, לא תצליחו כי צריך להתקין את Tree)

/ - התיקייה הראשונה בעץ התיקיות, רק משתמש מסוג ROOT עם סיסמת מערכת יכול לכתוב או למחוק בה דברים.

"." (ROOT) - תיקיית הבית של משתמש מסוג ROOT, משתמש רגיל יכול רק לצפות בה, כתיבה ומחיקה בתיקייה רק על ידי סיסמא של ROOT.

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

Sbin - כמו Bin רגיל רק שפה יש קבצים של פקודות שמשתמשים בהן לתחזוקת המערכת כמו ifconfig.

lib - תיקייה שיש בה את כל הדרייברים הנדרשים לאתחול מערכת ההפעלה.

usr - תיקייה שמכילה קבצים ספציפיים שהתקין המשתמש, בתוך התיקייה הזאת יש עוד תיקיות חשובות (נלקח מויקפדיה):

• ‎/usr/bin = מכילה קבצים בינאריים של תוכניות משתמש
• ‎/usr/sbin = מכילה קבצים בינאריים של תוכניות משתמש לשימוש על ידי מנהל המערכת.
• ‎/usr/lib =מכילה ספריות בשימוש התוכניות הנמצאות ב־‎/usr/bin וב־‎/usr/sbin.
• ‎/usr/local = מכילה תוכניות שהותקנו ממקורות שונים, שאינם כלולים בהפצה הרשמית. בנוסף עשויה לאחסן מידע ותוכניות אישיות במצב שקיימת רשת משותפת בה גם התיקייה ‎/usr משותפת.
• ‎/usr/share = מכיל קובצי הגדרות כולל הגדרות גרפיות של תוכניות המשתמש.
• ‎/usr/src = מכיל את קוד המקור לתוכניות המערכת כולל הקוד של הליבה.
• ‎/usr/include = מכיל קובצי כותר הנדרשים בעת הידור תוכנית.

Boot - תיקייה שבה יש את הקבצים שצריך בשביל להעלות את מערכת ההפעלה.

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

Etc - כל קבצי ההגדרות של תוכנות המערכת, בנוסף יש גם כל מיני סקריפטים כיצד להפעיל ולכבות תוכנות או לאן למפות התקן חיצוני (בלינוקס ניתן למפות דיסק או קי לדוגמא, לתיקייה על שולחן העבודה, לכן הכל כתוב מראש.)

Home - תיקיית הבית של המשתמש תיקיית "שולחן עבודה", "המסמכים שלי" וכד', מיוצגת גם על ידי הסימן "~" בטרמינל.

lost+found - תקיית לוגים מה שנקרא בשפת Windows - קבצי DUMP, קבצים שנוצרים ברגע שבוצע ניתוק לא נכון של התקן USB לדוגמא או במצב שבו קרסה המערכת.

Tmp- תיקייה של קבצים זמניים

Var - בתיקייה זאת נמצאים קבצים שהם קבצים "משתנים" לוגים שנרשמים בזמן עבודת המערכת, קובץ תור הדפסה (Spooler), קובץ בדוגמת PST.

Mnt - מיפוי של התקן במחשבים נקרא Mount (עיגון\לעגן) בעיקרון אפשר לעשות Mount לכל תיקייה בלינוקס אבל מקובל להשתמש בתיקייה בשם mnt זה מיועד למצב שבו אתם רוצים לחבר דיסק עם מערכת קבצים אחרת (לא משהו שהוא "לינוקסי")

Media - תיקייה זאת מיועדת ל"עגינה" של התקנים כמו כונן USB חיצוני, ברוב המקרים המערכת תחבר אותם בצורה אוט' לתיקייה הזאת.

Opt - קיצור של "Optional" לכאן מותקנות תוכנות שהן לא מגיעות מובנות בתוך מערכת ההפעלה.

Proc - בתיקיה זאת יש תיקיות רבות כאשר כל אחת מהתיקיות היא Process ID שמכילה מידע אודות תהליך ספציפי, כמו כן מכילה מידע אודות כמה זמן המערכת הפעילה Up time.

SRV - תיקייה של הסרוויסים (שירותים של מערכת ההפעלה)

איך נציג את תוכן התיקיה שבה אנחנו נמצאים?

לצורך הצגה של תוכן בתיקייה אנחנו נשתמש בפקודה ls שהיא קיצור של "List Storage" ובעצם נקבל את כל רשימת התיקיות שיש לנו בתיקיית השורש שלנו שהיא מיוצגת על ידי "~", זאת התיקיה הראשונה שאנחנו מגיעים אליה ברגע שאנחנו מתחברים ללינוקס שלנו, היא תהיה כתובה בסוף $~:lev@ubuntu-vm הסימן של ה"דולר" מסמן שאנחנו מחוברים עם משתמש "רגיל" ולא משתמש "ROOT" שהוא מנהל מערכת.

אם נקיש את הפקודה ls נוכל לראות את כל התיקיות שיש לנו בתוך תיקיית הבית:

מאחר ואין שום קבצים בתיקייה "~" אנחנו רואים רק את התיקיות (הכל בצבע כחול), יכול להיות שאצלכם יופיע משהו אחר כמו שבמקרה שלי מופיעה התיקייה Share-drives.

איך מנווטים ביו תיקיות בלינוקס?

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

נגיד ואנחנו רוצים להכנס לתיקייה Desktop, תנסו לכתוב cd desktop ותנסו לכתוב cd Desktop תראו שזה לא יעבוד לכם ואתם תקבלו שגיאה שאין תיקייה בשם "desktop" ובאמת אין.. כי יש Desktop.

אבל אם נכתוב cd Desktop נוכל להכנס לתוך התיקייה:

עכשיו נציג את תוכן התיקייה "Desktop" בעזרת הפקודה שלמדנו למעלה ls ומהשיעור הקודם נקבל את התיקייה שיצרתי בשם lev1:

בשביל "לחזור" תיקייה אחת אחורה, נכתוב .."רווח" cd כמו בדוגמא הבאה:

נגיד אני רוצה להכנס ישר לתיקייה lev1 בלי להכנס לתוך תיקיית Desktop ניתן לכתוב ישר את הנתיב ולהשלים את הפקודה בעזרת כתור ה TAB במקלדת:

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

נתיב אבסולוטי "Absolute path" \ נתיב יחסי "Relative Path"

נתיב אבסולוטי - הנתיב המלא של התיקייה זאת אומר במקרה של Downloads זה יהיה: home/lev/Downloads/

ונתיב אבסולוטי תמיד מתחיל עם "/" זאת אומרת מתחילת עץ התיקיות.

נתיב יחסי - הנתיב מהתיקיה שאתה נמצא בה כרגע עד לתיקייה שאתה צריך להגיע אליה.

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

ניתן להשתמש בנתיב היחסי: cd ../Downloads:

או להשתמש בנתיב האבסולוטי: cd ~/Downloads:

איך חוזרים תיקייה אחת אחורה?
ישנן שתי דרכים האחת: בעזרת הפקודה .. cd

השניה בעזרת פקודה קצת יותר מתוחכמת שמחזירה אותנו אחורה גם מראה את התיקייה האחרונה שהיינו בה - cd

נגיד ומסיבה שאינה ברורה לאף אחד, אתם לא ממש יודעים מה הנתיב של התיקייה שאתם נמצאים בה, ניתן להשתמש בפקודה מסוימת אשר תראה את הנתיב המלא של התיקייה שבה אתם נמצאים, בעזרת הפקודה pwd:

כמו שאמרנו לפני כן, כל דבר בלינוקס הוא קובץ ולכן ניתן לקרוא את התוכן שלו, נגיד ואנחנו רוצים לקרוא תוכן של קובץ מסוים לצורך כך ננווט לתיקיה bin בעזרת cd /bin ונריץ את הפקודה ls בשביל שנקבל את התוכן של כל התיקייה:

(¿? לידע כללי - לפקודה "ls" יש המון פרמטרים ואפשרויות שימוש, בחלק הזה נראה רק את הבסיס¿?)

אם אני אריץ ls בתיקייה הזאת אני אקבל רשימה ענקית של קבצים 

ובשביל להראות לי שאכן יש את הקובץ "ls" אני פשוט אבקש מהמערכת להראות לי את כל הקבצים שמתחילים מהצירוף של השם שאני צריך שזה ls בצורה הבאה ls *ls

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

הצגת תוכן של קבצים (כל מה שיש בו טקסט, קבצי סקריפט, קונפיגורציה, וכד')

עכשיו בואו נראה מה יש בפנים, אז לצורך כך נלמד פקודה בשם cat ואז את הקובץ שאותו נרצה להציג, במקרה הזה אנחנו לא נכנס לשום תוכנה או נפתח איזשהו עורך, סך הכל נציג את התוכן שלו, אז בואו נראה בעצם מה יש בתוך הקובץ "ls" שהוא ה"תוכנה" שאנחנו מריצים בשביל להציג את התוכן של התיקיות:

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

לכל שאלה כמו תמיד ניתן לפנות אלי במייל levl@leidertech.co.il

כמו תמיד - מדריך מצולם: