מודל OSI - שבע שכבות - הסבר נוסף
פרקי ההרצאה: מודל OSI - שבע שכבות - הסבר נוסף
תמלול ההרצאה: מודל OSI - שבע שכבות - הסבר נוסף
הטקסט המלא של הדקות הראשונות בהרצאה «מודל OSI - שבע שכבות - הסבר נוסף» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.
שלום לכם, מה טוב יותר מלהתחיל את סדרת ההרצאות הזו בחזרה זריזה על מודל OSI והקשר שלו ל-TCPIP? נדבר על למה בכלל משתמשים במודל OSI ולמה מחלקים את תהליך התקשורת לשכבות, נדבר על השכבות השונות מה הן, מה השמות שלהן ומה התפקיד שלהן, נדבר על איך OSI ממומש באמצעות אסופת פרוטוקולי
TCP/IP, ונסיים באמצעות הדגמה של איך מידע עובר בין מחשבים באמצעות השכבות. השכבות השונות. אני מקווה שתיהנו, הבה נתחיל.
אז למה בכלל משתמשים בשכבות? ובכן, הסיבה הראשונה היא פשטות בפיתוח. לא כל חברה צריכה להמציא מחדש את הגלגל כאשר היא רוצה להעביר מידע ממחשב אחד למחשב שני.
אתן לכם דוגמה. נגיד שיש לנו חברה כמו פוטושופ, פוטושופ, תסלחו לי על הכתב המאוד יפה שלי, ומשתמש בפוטושופ יוצר תמונה, הנה, של איש שוכב על שפת הים ומשתזף.
ואת התמונה הזאת הוא רוצה להעביר למשתמש אחר שיושב אולי בצד השני של העולם. ובכן, תוכנת פוטושופ היא לא עסוקה בהעברת מידע, היא עסוקה ביצירת תמונות.
וכאשר תוכנה כמו פוטושופ או כל תוכנה אחרת רוצה להעביר מידע למחשב אחר במקום אחר, היא משתמשת בשירות תקשורת, ושירות התקשורת הזה מחולק לשכבות, וכל שכבה אחראית על חלק אחר בתהליך.
אז בואו נסתכל, בשכבה העליונה ביותר יש לנו את המשתמש עם התוכנת פוטושופ שלו. אחר כך יש לנו שכבות למיניהן, וכל שכבה עסוקה ועוסקת בחלק אחר של תהליך התקשורת.
למשל, את המידע הזה, את התמונה הזאת, צריך יהיה לארוז איכשהו. יהיה צריך לקחת את זה ואולי לחלק את זה לחלקים.
אריזה, אריזה, או איזה כתב, אריזה. וכל אחת מהחבילות האלה צריך יהיה לציין מאיזה תוכנה היא באה ולאיזה תוכנה היא מיועדת ובאיזה סדר יש להרכיב אותן וכולי.
עכשיו, את האריזות האלה אנחנו נרצה למשל להעביר לאיזושהי מכונה, לאיזושהי כתובת, אז אנחנו צריכים מנגנון של כתובות. כתובות שהוא לגמרי שונה ממנגנון האריזות שהן לגמרי שונות מהמידע עצמו.
למשל, מנגנון כמו כתובות IP. היתרון בכך שיש לנו מנגנון מוכן הוא שחברת פוטושופ לא צריכה להתעסק בלפתח את פרוטוקול IP. היא לא צריכה לכתוב את פרוטוקול IP, לוודא שכולם יודעים לדבר אותו, להשתמש בו, היא פשוט משתמשת בו.
ובהמשך של התהליך יהיה לנו איזה שהם פרוטוקולים ואיזה שהם שירותים שיידעו לקחת את כתובות ה-IP עם החומר שארוז בתוכן וכל המידע שאני רוצה להעביר ולהפוך אותם לסדרה של אפסים ואחדים ובסופו של דבר לאיזשהו אות חשמלי או אופטי או רדיו או משהו כזה ולהסיע אותו על פני מדיות שונות,
כבלים שונים ותשתיות שונות עד שהוא יגיע לצד השני. סיבה נוספת לשימוש בשכבות זה כדי ליצור אחידות בתקינה או תקן אחד לחומרה ולתוכנה שכל היצרנים יכולים להשתמש בו.
מה זאת אומרת? בואו נגיד שיש לי כאן מחשב שהוא מקינטוש ויש לי כאן מחשב שהוא PC של איזשהו יצרן, נגיד Lenovo, וכאן יש לי ראוטר של סיסקו כמובן ויש לי סוויט של HP לצורך העניין.
כל אלה חברות שונות וכל החברות האלה צריכות שתהיה להן איזושהי דרך אחת לדבר אחת עם השנייה, דרך שמוסכמת על כולם. החלוקה לשכבות ויצירת מודל אחיד מאפשרת לכל חברה לדבר עם כל חברה אחרת בלי קשר להאם אני מריץ פה מערכת הפעלה של אפל או אם אני מריץ פה מערכת הפעלה של Windows או של מייקרוסופט או מערכת ההפעלה של סיסקו לצורך העניין.
אז הנה השכבות העליונות שלנו, אלה שכבות האפליקציה, הן מקבלות מידע ממערכת ההפעלה, ממה שלא יהיה. מודל ה-OSI מטפל באריזה, לא משנה של איזה מידע, לא משנה מאיזה מערכת הפעלה, לא משנה מאיזה תוכנה.
מודל ה-OSI ידע לתת כתובות IP ללא קשר האם מדובר בכתובת IP של נתב או האם מדובר בכתובת IP של PC או כתובת IP של Mac. כולם משתמשים באותה שפה ולבסוף אנחנו נשתמש בתשתיות פיזיות, פיזיות של כבלים וגלי רדיו, אולי לפעמים יש גלי רדיו, דברים בשידור, שגם להן אין שום קשר לחברה שמייצרת מערכות הפעלה או חומרה.
היתרון בשכבות הוא שכל יצרן, כל מי שמייצר איזושהי חומרה שמתעסק בחלק מהתהליך, למשל סיסקו מתעסקים בעיקר ב-IP ובניתוב, טוב, אולי זה לא מדויק, מתעסקים גם ב-IP ובניתוב והם יכולים להתעסק עם שכבה שלוש, עם השכבה של ה-IP, בלי להתעסק בשום דבר שקשור בשכבה שמעל או בשכבה שמתחת.
ואם יש לנו יצרן שמייצר סוויצ'ים, למשל HP, מייצרים מתגים, אז הם יכולים להתעסק בשכבה שתיים, בשכבה של המיתוג, בלי שום קשר למה שקורה בשכבות שמעל.
כל שכבה היא אוטונומית לגמרי. וכיוון שיש לנו אחידות בתקינה, כל יצרן יכול לייצר את הטכנולוגיה שלו לפי ההתמחות שלו, ולהשתמש בה בשכבה שבה הוא פעיל.
סיבה נוספת לשימוש בשכבות היא שקל מאוד לבצע שינויים. אם היינו צריכים, נגיד, נחזור לדוגמה שלנו, שאולי לא הכי טובה, אבל נניח, פוטושופ, אוקיי?
הייתה אחראית על ייצור כל תהליך התקשורת מתחילתו ועד סופו, נגיד שהסוף שלו הוא כאן, של לקחת מידע ולהפוך אותו בסופו של יום לאיזשהו סיגנל, והיה לנו צורך לשנות משהו.
אם הכל היה עשוי בחתיכה אחת, זה היה מאוד מאוד קשה לעשות. היה מאוד מאוד קשה להפריד פעולה כמו מיתוג מפעולה כמו ניתוב, שאלה דברים מאוד מאוד שונים.
אני אמחק רגע. בואו נגיד שכאן יש לי מט"ג שהמהירות שלו היא 100 מגה בי פי אס. הוא יודע להעביר 100 מגה ביטים בשנייה. ואנחנו רוצים להחליף אותו בטכנולוגיה חדשה של 1000 מגה פי אס.
רוצים להחליף תשתית? אז מה? עכשיו נתחיל לשנות את כל תהליך התקשורת בשביל לעשות את ההחלפה הזאת?
לא. כיוון שאנחנו מוחלוקים לשכבות וכיוון שמיתוג יושב איפשהו שם בשכבה מספר 2, כל מה שאני צריך לעשות זה על השכבה הזאת להחליף מתגים או להחליף את הטכנולוגיה של ה-100 מגה ביט בטכנולוגיה של ה-1,000 מגה ביט.
ואני לא נוגע בשום דבר שקשור לניתוב ניתוב בשכבה 3 או שום דבר שקשור לתשתית, וופס, תשתית שנמצא בשכבה מספר 1. וכמובן שאני לא נוגע בשום דבר בשכבות העליונות של האריזה, של האפליקציה.
סיבה נוספת שאנו מחלקים את תהליך התקשורת לשכבות ולחלקים היא שקל הרבה יותר להתמודד עם תקלות. כאשר יש לנו שכבות, הנה, והשכבות שלנו נגיד, שכבות של תהליך התקשורת, ומתחיל מכאן, ומידע נכנס לכאן ויוצא מכאן כאיזשהו סיגנל, ונניח שיש לנו איזושהי תקלה, אז הרבה יותר קל להתמודד איתה כאשר הדברים מחולקים לשכבות, ואני לא צריך להתייחס לכל המכלול הזה כאל מקשה אחת.
אז בואו נגיד שיש לנו תקלה בניתוב, נגיד שיש לי בעיה בראוטר הזה. אז במקום להתחיל ולטפל בכל התהליך, כל מה שאני צריך לעשות זה ללכת לשכבה המתאימה, במקרה זו שכבה 3, ולחפש שם את התקלה ולהחליף ראוטר או לפתור את בעיית הניתוב של הראוטר.
או בוא נגיד שיש לי בעיה בכבל, זה קורה. נקרע כבל, ניטע כבל, יש בו קצר. אז שוב, במקום להתייחס לכל המכלול הזה כשלם, כל שאני צריך לעשות הוא ללכת לשכבה הפיזית, שכבה מספר 1 ולטפל בתקלה של הכבל.
העניינים כאן הם מודולריים, זאת אומרת, כשאני עושה שינויים בשכבה מספר 1, מחליף כבל, אני לא משפיע על שכבה מספר 2, אני לא משפיע על הניתוב, אני לא משפיע על אריזה בשכבה מספר 4, ואני לא משפיע על האפליקציה שהמשתמש יושב בה כאן ומנסה לעשות איתה איזושהי פעולה.
אני בסך הכל הולך למקום שבו יש לי את התקלה ומטפל רק בה נקודתית, במקום להתייחס לכל תהליך התקשורת כמכלול. עכשיו, כשסיימנו להסביר מדוע יש לחלק את תהליך התקשורת לשכבות ומה היתרונות של החלוקה לשכבות, בואו נדבר על מודל OSI ועל השכבות שלו.
אנחנו נתחיל מלמעלה למטה. השכבה העליונה, שכבה מספר 7, נקראת שכבת האפליקציה או שכבת היישום. מתחתיה תבוא שכבה מספר 6, שנקראת שכבת הפרזנטציה או שכבת ההצגה.
שכבה מספר 5 נקראת שכבת השיח או השיחה. שכבה מספר 4 נקראת שכבת העברה. שכבה מספר 3 נקראת שכבת הרשת, שכבה מספר 2 יש לה מספר שמות בעברית עורק, קו, מקשר הנתונים ויש עוד, ומתחתיה תבוא שכבה מספר 1, הלוא היא השכבה הפיזית.
בשלב זה אני רוצה לציין שמאוד חשוב ללמוד ולזכור בעל פה את שמות השכבות ואת הסדר שלהן, וגם, מה שיבוא בהמשך, את תפקידיהן.
אז ככה. מודל הווסאי לרוב מחולק לשני חלקים. לחלק אחד נקרא שכבות העליונות ואלה שכבות 4 עד 7, והחלק השני יהיה השכבות התחתונות, תכף נדבר עליו.
בואו נראה מה כל שכבה עושה. נתחיל משכבת היישום, שכבת האפליקציה, הלוא היא שכבה מספר 7, ונדבר עליה. אז בשכבה מספר 7 יש לנו את כל מה שקשור למידע.
כאן יהיו לנו שרתים, אלה שנותנים מידע, ולקוחות שצורכים מידע, והמידע שעובר בין שרתים לבין לקוחות, נמצא כאן בשכבה מספר 7. למשל, אם יש לנו לקוח, נגיד לקוח HTTP, לקוח של ווב, אז יהיה לנו דפדפן, ובצד השני יהיה לנו שרת ווב,
שהוא זה שיעביר ללקוח את המידע. בשכבה מספר 6, הלוא היא שכבת ההצגה, המידע שמגיע משכבה מספר 7 מיוצג. כאן בוחרים את הפורמט.
למשל, אסקי, שזו דרך לייצג מידע, או JPEG, שזה גם דרך לייצג מידע. כאן נמצא דברים כמו SSL, שהוא פרוטוקול של הצפנה, גם דרך לייצג מידע.
שכבה מספר 5, שכבת השיח, עסוקה בכל מה שקשור ליצירת שיחה בין שתי מחשבים. כאן ייווצר כל מה שקשור לאופן שבו מידע מועבר מצד לצד, איך הוא מועבר, מתי הוא מועבר, באיזה קצב הוא מועבר, כל מה שמנהל את השיחה, או באנגלית את הששן של שני המחשבים האלה.
שכבה מספר 4, שכבת העברה, הנה היא כאן, היא השכבה שאחראית על אריזת מידע ועל שירות המשלוח. פירוש הדבר הוא שמידע שמגיע משכבה 7, כאשר הוא יורד לשכבה 4, לרוב צריך להיות מחולק לחלקים.
החלקים האלה נקראים סגמנטים. בחלקים האלה אנחנו נמצא מידע כגון מאיזה תוכנה המידע הזה הגיע, לאיזה תוכנה הוא מיועד, וגם באיזה שירות משלוח המידע הזה משתמש, או באיזה שירות משלוח אנחנו משתמשים כדי לשלוח את המידע הזה.
שני שירותים עיקריים הם אלה: אחד מאפשר תעבורה אמינה, כלומר כל החבילות שעוברות לצד השני מגיעות, ויש לנו בצד השני גם מישהו ששולח לנו אישורים שהכל הגיע.
והאפשרות השנייה היא להעביר דברים בצורה מהירה או בזמן אמת. ויש אפליקציות שעבורן זה מאוד מאוד חשוב, כמו למשל voice over IP. עכשיו אנחנו יורדים לשכבות התחתונות, השכבות שבדרך כלל מתעסקות יותר ברשת עצמה ובאופן שבו המידע שמרע מלמעלה מועבר או מובל דרך רשתות
עד שהוא מגיע ללקוח בצד השני. אז בואו נדבר שנייה על שכבה מספר 3, שכבת הרשת. אה, אני אעשה 3 יותר יפה. שכבה מספר 3, שכבת הרשת.
בשכבה זו נמצא דברים כגון כתובות לוגיות, שאנו מכירים ככתובות IP, בשכבה זו נתעסק עם דברים כגון ניתוב, איך להעביר מידע מרשת אחת לרשת שנייה. בשכבה מספר 2, שכבת הקו או העורק, אנו נמצא דברים כגון כתובות פיזיות.
כפי שאתם זוכרים בוודאי, למחשבים יש כרטיסי רשת וכרטיס רשת לרוב מגיע עם כתובת פיזית שצרובה עליו. שלא כמו כתובות לוגיות שמשתנות בהתאם לרשת שאליה המחשב מחובר, כתובות פיזיות לא משתנות, הן צרובות ונשארות תמיד באותו מקום.
בשכבה 2, שכבת הקו, אנו נמצא גם דברים כגון מיתוג, אנו נמצא דברים כגון שימוש בתשתיות רשת שונות, ופרוטוקולים שיודעים לדבר עם תשתיות פיזיות שונות.
וזה מוביל אותנו לשכבה האחרונה, שכבה מספר 1, הלוא היא השכבה הפיזית. בשכבה זו נמצא את כל מה שקשור לכבלים, גלי רדיו, סיבים אופטיים ותשתיות רשת שעליהן המידע שלנו נוסע כאשר הוא עובר ממחשב אחד למחשב אחר.
כפי שאמרתי קודם, חשוב מאוד לזכור את שמות השכבות בעל-פה, וכמובן חשוב מאוד להכיר גם את שמותיהן באנגלית. אז הבה נסתכל על זה בזריזות.
שכבה מספר 7 נקראת באנגלית Application, שכבה מספר 6 נקראת Presentation, שכבה מספר 5 נקראת Session, שכבה מספר 4 נקראת Transport, שכבה מספר 3 נקראת Network, שכבה מספר 2 נקראת DataLink, ושכבה מספר 1 נקראת Physical.
איך זוכרים בעל פה? ובכן, זה משתנה מאדם לאדם וכל אחד עם מה שנוח לו. לי היה נוח לבנות משפט שבו כל מילה מייצגת את האות הראשונה של כל אחת מהשכבות.
הנה הוא כאן: All people seem to need data processing. וקל לי לזכור את המשפט הזה בעל פה יותר מאשר קל לי לזכור את שמות השכבות, ולכן כשאני רוצה להיזכר בשמות אני אומר לעצמי All people seem to need data processing, אני יודע ש-a מייצג את אפליקיישן ו-p את פרזנטיישן וכולי.
ואיך עושים את זה בעברית? ובכן, כאן פשוט צריך להיות יצירתיים. למשל, אלף פילים שחורים היו רוצים עולם פורח. והנה משפט שיכול לעזור לכם לזכור את שבע השכבות לפי הסדר.
מימוש מודל OSI באמצעות אסופת פרוטוקולי TCP/IP. ובכן, חשוב להבין ש-OSI הוא מודל תאורטי. אין לו שום פרוטוקול אמיתי משלו. הוא מודל שמהווה המלצה לאיך בכלל לנהל שירות של תקשורת.
ואנשים שפיתחו את ה-OSI אומרים, תשמעו, כשאתם מנהלים שירות של תקשורת, היינו רוצים שתחלקו את העניין לשבע שכבות. נראה לנו שזה דרך הכי טובה לבצע את הפעולה.
אבל כשבאו לממש שירות תקשורת בצבא האמריקאי בשנות ה-60, ישבו החבר'ה ואמרו, אוקיי, אנחנו צריכים לכתוב פרוטוקולים, פרוטוקולים לאפליקציה ופרוטוקולים לפרזנטציה ופרוטוקולים של רשת וכתובות ופרוטוקולים שמדברים עם השכבות הפיזיות, ונראה לנו שהחלוקה הזאת לשבע שכבות היא קצת מוגזמת לנו.
אנחנו נפתח אסופת פרוטוקולים שנקראת TCP/IP ונחלק אותה במקום לשבע שכבות לארבע שכבות. נאחד קצת את הפעולות. והם עשו את הדבר הבא, הם לקחו את שלושת השכבות העליונות של OSI ואיחדו אותן לכדי שכבה אחת שנקראת שכבת האפליקציה.
שכבת העברה נשארה שכבת העברה. שכבת הרשת הפכה להיות שכבה שנקראת שכבת אינטרנט או אינטרנטוורק. שכבה מספר 2 ושכבה מספר 1 אוחדו לידי שכבה אחת שנקראת גישה למדיה.
למעשה איחדו את הפעולות של שלושת השכבות העליונות האלה ואיחדו את הפעולות של שתי השכבות התחתונות לידי שכבה בודדת.
באנגלית השמות של השכבות הן כאלה Application, Transport, Internet ו-Media Access. עכשיו בואו נראה איזה פרוטוקולים בעצם נמצאים בכל אחת מהשכבות ונכיר קצת את העניינים טיפה יותר לעומק.
אז בשכבה העליונה, בשכבת היישום, יש לנו את כל מה שקשור ללקוחות ושרתים. למשל, פרוטוקול HTTP או פרוטוקול HTTPS שמאפשר תקשורת אינטרנט בין אתר אינטרנט ללקוח אינטרנט.
יש לנו את פרוטוקול DNS שמאפשר ללקוח לברר כתובת IP של אתר מסוים באמצעות שרת DNS. יש לנו FTP שזה פרוטוקול שמשמש שרת קבצים. יש לנו את SSH שמאפשר לנו טרמינל מרוחק לשליטה על מחשב מרחוק.
יש לנו את Telnet שעושה אותו דבר רק באופן לא מוצפן. יש לנו את POP3 ו-IMAP4 שהם פרוטוקולים של קבלת דואר. ה-SMTP הוא פרוטוקול של שליחת דואר, ה-TFTP הוא עוד פרוטוקול להעברת קבצים פשוט יותר מ-TFTP, ויש לנו DHCP שאתם בוודאי זוכרים שמחלק כתובות IP, יש לנו שרת DHCP ולקוח DHCP ו-SNMP שזה
פרוטוקול לשליטה בהתקני רשת ויש עוד רבים רבים רבים אחרים. מה שמאפיין את כל הפרוטוקולים האלה שהם פרוטוקולים שמייצרים וצורכים מידע.
מתחת לזה את המידע הזה אנחנו צריכים לארוז באחד משני הפרוטוקולים של שכבה 4 ב-OSI, שכבת ההעברה. זאת אומרת שאם למשל יש לנו DNS, בקשת DNS, אז אנחנו נארוז אותה, המחשב יארוז אותה בסגמנט של TCP. וכאן יתווספו לנו גם דברים כמו מספרי פורטים.
אז בשכבה 4 יש לנו מקטע או סגמנט באנגלית, ולסגמנט הזה יש מספרי פורטים שמציינים מאיזה תוכנה הוא בא ולאיזה תוכנה הוא מיועד. למשל, אם זה סגמנט של DNS אז הוא מיועד לתוכנה מספר 53 או לפורט מספר 53. כשהוא יגיע למחשב היעד הוא יצטרך להיות מופנה לתוכנה מספר 53 וכך הוא ידע שהוא מגיע לשרת ה-DNS.
ויהיה פה גם מספר, נגיד 1027, שמייצג את התוכנה השולחת, את הלקוח. והמספר הזה עולה בגורל ממה שפנוי במחשב השולח החל ממספר 1024 ומעלה ועד 65,536, שזה כל טווח מספרי הפורטים.
בנוסף, TCP ו- UDP אחראים גם על איכות השירות. TCP, Transmission Control Protocol, מוודא שכל המידע המשודר יגיע ליעדו, באופן שבו אם איזשהו מידע הלך לאיבוד בדרך, TCP ישלח אותו שוב.
ואילו UDP עובד בשיטת שגר ושכח, הוא פשוט שולח, לא אכפת לו בכלל אם יש משהו בצד השני הגיע, לא הגיע, UDP לא עוסק בזה.
אז TCP מתאים לתקשורת אמינה שבה כל המידע חייב לעבור, אם אתם מורידים משחק או סרט מהאינטרנט ואתם רוצים שכל המידע יגיע אליכם, מן הסתם תשתמשו ב-TCP או המחשב שלכם ישתמש ב-TCP, ו- UDP מתאים יותר לאפליקציות זמן אמת כמו סקייפ או כמו משחקי רשת שבהם אנחנו יורים אחד בשני ואנחנו צריכים שהמידע יגיע עכשיו,
ואם פספסנו איזושהי חבילת מידע בדרך אז אולי נראה איזה לאג קטן, איזו קפיצה קטנה, לא נשמע משהו, אבל זה לא ישפיע באופן משמעותי על כל התקשורת.
בשכבה מספר 3, שכבת האינטרנט או הנטוורק של OSI, נמצא דברים כמו כתובות IP מגרסה 4, גרסה 6, נמצא את פרוטוקול ICMP, Internet Control Message Protocol, שאחראי על אפשרויות של בדיקת תקלות ובדיקות קישוריות עם תוכנות כמו PIN ו-Tracer T, נמצא כאן גם כל מה שקשור לניתוב עם פרוטוקולים
כמו RIP ו-EIGRP ועוד פרוטוקולים רבים וטובים שעוסקים בניתוב. ובשכבה שלוש המידע שלנו שנארז בסגמנט הופך להיות פאקט או מנת מידע בעברית והוא כולל כתובות IP וכאן גם נמצא את קנה רשת מסוג נתבים.
נתבים יושבים בשכבה שלוש כיוון שהם עוסקים בעיקר בכתובות IP ובניתוב ולכן הם נחשבים התקנים של שכבה 3. למטה בפרוטוקולים שקשורים לגישה למדיה נמצא דברים כמו dsl ואתרנט וframe relay ו l2tp וppp ויש פה הרבה מאוד פרוטוקולים ביניהם גם wireless וזה החלק שעוסק בלקחת את הפאקטים שלנו ובסופו של דבר להלביש
אותם על המדיה הפיזית על הכבל כאן נמצא דברים כמו מסגרת נתונים כלומר המידע שמגיע הפאקט שיורד משכבה 3 לשכבה 2 הופך בשכבה 2 ל-frame במסגרת נתונים.
הוא מקבל תוספת של כתובות פיזיות, כתובות Mac אם יש לנו אתרנט או כתובות Delseat אם מדובר ב-frame relay או כתובות פיזיות אחרות בהתאם למדיה. נמצא כאן התקני רשת כגון סוויצ'ים, מתגים מתעסקים בכתובות פיזיות ולכן הם נחשבים להתקנים של שכבה 2. ולבסוף, השכבה של TCP IP שנקראת גישה למדיה מממשת גם את כל מה שקשור לאותות,
לחשמל, לרדיו, לאור, לכל מה שקשור לכבלים ולתקנים של כבלים, סיבים ואנטנות וכאן נמצא תקנים כגון האבים, כזאת זה האב, ומודמים שעוסקים בהפיכת המידע שלנו, בהפיכת האפסים והאחדים שלנו, כל הדאטה שלנו, בסופו של דבר, לאיזשהו סיגנל חשמלי שיכול לנסוע על כבל.
עכשיו, כשסיימנו עם התיאוריה, בואו נראה איך מידע עובר בין שני מחשבים דרך כל השכבות של OSI ו-TCPIP. אז לצורך העניין בחרתי בהדגמה של מידע מסוג HTTP, מה שאומר שבצד הזה יש לנו מחשב, ונגיד שיש לו שרת Web, הוא גם מחזיק שרת Web, ולצורך העניין בואו נגיד שיש לו גם שרת FT, שרת Web מקשיב בפורט 80 ו-FTP מקשיב בפורט
21. ובצד הזה יש לנו לקוח עם דפדפן, נגיד Chrome כמובן, והוא רוצה לבקש מהמחשב הזה מכאן את דף האינטרנט של המחשב הזה.
אז הדבר הראשון שיתבצע זה שנפתח את הדפדפן ונכניס לתוכו את כתובת ה-IP של היעד שלנו, ונלחץ Enter, ותיווצר לנו בקשת HTTP מסוג GET, שאומרת למחשב בצד השני, שאמורה להגיד למחשב בצד השני, תן לי בבקשה קובץ שנקרא index.html.
את הקובץ הזה תשלח אליי, זה מה שאני רוצה. הרעיון הוא שהבקשה הזאת, המידע הזה שבא מהדפדפן הזה צריך להגיע לצד השני ולהגיע לשרת הזה. זה מה שאנחנו רוצים לעשות.
בואו נראה איך זה קורה. אז יצרנו את הבקשה שלנו ועכשיו הבקשה שלנו יורדת במורד השכבות, מגיעה לשכבה 4, פה היא הופכת לסגמנט של TCP. למקום הזה מתווספים מספרי הפורטים.
אמרנו שפה יש לנו פורט 80 שמקשיב, אז פה מתווסף מספר 80, שאומר שהמידע הזה יהיה מיועד לתוכנה הזאת שיושבת כאן, לשרת ווב, והתווסף לנו כאן מספר פורט, נגיד 1027, שהוא הפורט הפנוי של הדפדפן שלנו כאן, של הכרום, שזה מה שהכרום הגריל מהמספרים הפנויים.
כך שכשהשרת פה יוצא להחזיר תשובה, הוא ידע לשלוח את זה ל-1027, שזה מה שמחכה לנו כאן, 1027. זה הסגמנט שלנו ב-TCP. עכשיו, סיימנו עם הדבר הזה, אנחנו נרד לשכבה שמתחת, שכבת האינטרנט או שכבת הרשת, ומה שהתווסף לנו כאן הם כתובות ה-IP.
לתוך הפאקט שלנו, עכשיו למידע שלנו קוראים פאקט, המחשב יוסיף את כתובת השולח, את IP השולח, זה יופיע כאן, המידע הזה, וגם את IP של היעד.
המידע הזה גם כן יופיע כאן. ולכל הדבר הזה עכשיו קוראים פאקט, והפאקט הזה מכיל את הסגמנט שלנו עם מספרי הפורטים, ומכיל את הדאטה שלנו עם הפקודה get, שאומרת תן לי בבקשה את הדף אינטרנט שלך.
עכשיו אנחנו בשכבה 3, והתווספו לנו מספרי, התווספו לנו טובות IP. מכאן המידע שלנו ימשיך במסע שלו על פני הרשת, ירד לשכבה מספר 2, ובשכבה מספר 2 הוא יהפוך להיות פריים, במקרה זה של אתרנט, והמידע שיתווסף לנו יהיו כתובות ה-MAC.
יהיה לנו את ה-Source Mac, שזה כתובת ה-MAC של המחשב השולח, הנה, אבל ב-Destination Mac עדיין לא נכניס את כתובת ה-MAC של המחשב המקבל, כיוון שהוא נמצא ברשת אחרת.
וכידוע, כדי להעביר מידע בין רשתות אנחנו קודם כל צריכים לשלוח את כל הפריים הזה לראוטר. איך נשלח אותו לראוטר?
ובכן, נעשה את זה באמצעות כתובת ה-MAC של הראוטר כאן. מה שהמחשב יעשה זה הוא יבדוק בכרטיס הרשת שלו את הכתובת של ה-Default Gateway שלו, יבצע בקשת ARP, ייקח את כתובת ה-MAC של הראוטר ויכניס אותה לתוך הפריים, ויבנה פריים שמאפשר לקחת את הפאקט הזה ולהוביל אותו לראוטר.
זה כל היתרון של שכבה מספר 2 שמאפשרת לנו להעביר נתונים מנקודה לנקודה כשהם בדרך ליעד הסופי שלנו. בואו נראה את זה קורה. עכשיו המידע שלנו הופך לסיגנל, לאות חשמלי, ויוצא למסע שלו.
והנה הוא נוסע ומגיע לראוטר. וכשהוא מגיע לראוטר, הראוטר מסתכל לתוך הפאקט, הראוטר מסתכל לבדוק לאיזה IP הוא צריך להגיע.
והראוטר יפרק את הפריים הקודם, מפרק את הפריים הקודמים ויבנה פריים חדש שמכיל את כתובת המאק של היעד. את זה הוא יכניס לכאן ויכניס את כתובת המאק של עצמו בממשק הזה לכאן כדי שהמחשב ההוא ידע לחזור אליו ואת הפריים הזה הוא ישלח דרך הרשת לכרטיס הרשת של היעד.
בואו נראה את זה קורה. והנה הסיגנל שלנו נוסע ברשת ומגיע למחשב היעד שלנו. מחשב היעד שלנו לוקח את המידע הזה ומתחיל להעלות אותו במעלה השכבות.
הדבר הראשון שהוא יבדוק יהיה את כתובות המאק. הוא יבדוק האם בפריים של האנטרנט מופיעה כתובת מאק שזהה לכתובת המאק שלו.
במידה וכן, הוא יפרק את הפריים הזה, ישלוף מתוכו את הפאקט, ואת הפאקט הוא יעלה לקומה השנייה, לקומת האינטרנט או לשכבה 3 אם תרצו.
וכאן ייבדקו כתובות ה-IP. ייבדק האם כתובת היעד היא כתובת ה-IP של מחשב היעד. ואם התשובה היא כן, כפי שאנחנו יודעים, אז המחשב ייקח את הסגמנט TCP הזה ויעלה אותו לשכבה מספר 4, ובשכבה מספר 4 מה שייבדק יהיה מספרי הפורטים.
הרי אמרנו שזה מיועד לפורט 80 ובא מ-1027 ואמרנו שכאן יש לנו שרת Web, נכון? שמקשיב בפורט 80 ושרת FTP שמקשיב בפורט 21. אז באמצעות המספר הזה המחשב ידע לקחת את הבקשה הזאת, ה-HTTP הזה ולהעביר אותו לשרת ה-Web ולא לשרת ה-FTP.
בואו נראה את זה קורה. הנה זה עולה, המחשב מפרק את הסגמנט ולוקח את הדאטה, את הגט הזה שהיה לנו קודם, שמבקש מהיישום את קובץ אינדקס HTML. עכשיו, כשהגענו, המחשב המקבל ייקח את המידע שלו, יארוז אותו בתוך פרוטוקול ה-HTTP, יוריד אותו לשכבת העברה, ייצור כאן סיגמנט חדש שמיועד ל-1027 ובא מ-80. כזכור,
הקרום פה, הדפדפן שלנו כאן, יש לו פורט 1027 שעליו הוא מקבל את התשובות. הדבר הזה ירד לשכבה 3 וייווצר פאקט עם כתובת ה-IP 10.0.1 של מחשב היעד וכתובת השולח, כמובן של המחשב השולח.
זה ירד למטה, ייווצר לנו פריים שאמור להיות מיועד לראוטר עם כתובת המאק של הראוטר. זה יהפוך לסיגנל, ייסע ברשת, יגיע לראוטר, הראוטר יבנה לו פריים חדש עם המאק הנכון, זה ייסע ברשת שוב, יגיע למחשב המבקש.
שוב המידע יפורק, הפריים יפורק, הפאקט יועבר לשכבה 3, ושכבה 3 תפרק את הפאקט והסגמנט יועבר לשכבה 4, וייבדק לאיזה יישום במחשב המבקש המידע הזה מיועד, והמידע יעלה הלאה לשכבת האפליקציה ויגיע לדפדפן שלנו בקרום, ובסופו של דבר נציג כאן את האתר אינטרנט שרצינו
לראות. אז זה מסכם את האופן שבו מידע עובר באמצעות TCP/IP ומודל OSI בין שני מחשבים. אז בואו נסכם. דיברנו על מודל OSI ומודל TCP. ראינו למה משתמשים בשכבות, למה כדאי לפרק את תהליך התקשורת לשכבות.
דיברנו על השכבות השונות של מודל OSI, מה השמות שלהן ומה התפקיד שלהן. אחרי זה ראינו איך מודל OSI ממומש באמצעות אסופת פרוטוקולי TCP/IP, ולבסוף ראינו איך מידע עובר בין מחשבים באמצעות השכבות השונות.
אני מקווה שזה היה מועיל עבורכם, תודה, ולהשתמע.