בסיס – הקמת רשתות ושרתים
הקדמה:
מעבדה זו נועדה למתחילים. כאלה שרוצים לרכוש ידע וניסיון ראשוני בתפעול סביבת הענן של גוגל.
המעבדה מיועדת לכאלה שכבר יש להם לכל הפחות ידע בסיסי של Help-Desk בתפעול מחשבים ושרתים, כתובות IP ומבנה רשת.
כדי להתחיל מעבדה זו נדרש להרשם לכל הפחות לתקופת ניסיון בסביבת הענן של GCP. GCP מאפשרת לאנשים תקופת ניסיון של 3 חודשים עבור למידה והתנסות, כאשר לפרק זמן זה הם מקבלים 300$ לחשבון שלהם, ויכולים להשתמש בזה על מנת לבנות סביבת ענן בעלת רכיבים שונים – ללא חשש לזליגת תקציב ומצב שבו פתאום המתלמד מקבל חשבונות.
יהיו דברים שלא יהיו זמינים עבור המתלמד – כמו שרתי ווינדוס למשל, הכרוכים בתשלומי רישיונות למיקרוסופט. אך בכל נסיון לבצע פעולה כזו, תקפוץ הודעה למשתמש לפיה פעולה זו חסומה במצב ההתנסות, וכדי לפתוח פעולות שכאלה, צריך לאפשר תשלומים וחשבונות.
כל עוד המשתמש לא מאפשר תשלומים וחשבונות, הוא יכול לעבוד ללא חשש עד תום התקופה או עד שמיצה את אותם 300$ שהוקצבו לתקופת הניסיון.
במעבדה זו ניתן לרכוש את הידע ולהתאמן בנושאים הבאים:
1. הקמת פרוייקט בסביבת GCP.
2. הקמת רשתות תקשורת פנימיות בסביבת הענן.
3. שיתוף וניתוב בין הרשתות.
4. חוקי פיירוואל.
5. הקמת שרתים ועריכת הגדרות שרת.
6. התחברות למערכות ומפתחות SSH.
7. יצירת Image של מכונה עם תכונות מסוימות.
8. יצירת מכונות מתוך אותו Image.
יצירת פרוייקטים:
בלוח הניהול של GCP, ליד איפה שכתוב Google Cloud (למעלה משמאל), יש לחצן-תפריט-נפתח שבוחר באיזה פרוייקט נמצא המשתמש. לחיצה עליו פותחת חלון, ושם לבחור בפינה הימנית העליונה "NEW PROJECT". לבחור שם, ואז להוסיף את המס' 1. לדוגמה – yos-project-1.
ליצור פרוייקט שני עם המס' 2.
יצירת VPC:
לבחור בפרוייקט מס' 1.
בתפריט הצדדי (אם זה לא מופיע, ללחוץ על שלושת הפסים שמשמאל ל-Google Cloud) ללחוץ על VPC network. נראה שיש שם רשת Default. להכנס לשם ולמעלה ללחוץ על מחיקה.
ואז בדף שנפתח, ללחוץ למעלה על CREATE VPC NETWORK.
יצירת 3 VPC – VPC-1, VPC-2, VPC-3.
בתוך כל VPC ליצור Subnet בצורה מותאמת אישית – לא אוטומטית (Custom ולא Auto-mode). לבסוף יהיו לנו 3 Subnet – Subnet אחד בכל VPC. אלה יהיו Subnet-1, Subnet-2 ו-Subnet-3, שהטווחים שלהם יהיו 10.0.10.0, 10.0.20.0, 10.0.30.0. כולם ב-Prefix 24. לכולם לאפשר Private Google Access.
לטובת ההדגמה אני בוחר לשים את כולם בישראל, Region me-west1.
למחוק את ה-VPC Default גם בפרוייקט השני.
יצירת שיתוף וניתוב בין הרשתות – תצורת Mesh:
עדיין בתפריט של VPC network, נבחר ב-VPC network peering. שם ללחוץ על CREATE CONNECTION.
לחילופין, אפשר ללכת באותו תפריט ל-VPC networks, לבחור ב-vpc-1, ושם בפנים יש בשליש התחתון של החלון תפריט לשוניות. הלשונית השניה מימין זה VPC NETWORK PEERING. שם אפשר ללחוץ על ADD PEERING.
בחלון שנפתח, ניתן שם לשיתוף. נגיד – vpc1-to-vpc2.
בוחרים ברשת המשתפת – vpc-1.
לוודא שמסומן שהרשת שמקבלת את השיתוף קיימת בפרוייקט הראשון.
לבחור ברשת vpc-2 כזו שמקבלת את השיתוף.
לסמן יבוא ויצוא של Custom routes.
ואז ללחוץ על Create.
מיד נעבור לחלון שבו רואים את השיתוף, אבל הוא במצב Inactive. בגלל שצריך לשתף בחזרה מרשת vpc-2. רק אז השיתוף יהפוך לפעיל – לטנגו צריך שנים.
אז נבצע את אותה הפעולה רק בצורה הפוכה – שיתוף של רשת vpc-2 לרשת vpc-1. ברגע שהפעולה תסתיים, השיתוף יהפוך לפעיל בשתי הרשתות.
את הפעולה הכפולה הזו ניתן לבצע גם בין רשת vpc-1 לרשת vpc-3 וכן בין רשת vpc-2 לרשת vpc-3. כך שיש לנו מבנה Mesh (רשת) שבו כל הרשתות משתפות חיבורים וניתוב.
חשוב לזכור:
עבודה בתצורת Mesh בארגון חי, מורכבת הרבה יותר. במקום שיש בו עשרות רשתות, לחבר כל רשת חדשה לעשרות הקיימות, ואז את העשרות הקיימות לחבר כל אחת לרשת הקיימת, זה מבצע מורכב.
מה גם שברירת המחדל של GCP זה עד 25 Peering Connection עבור VPC בודד.
מה שעושים זה לחלק כל VPC להרבה Subnets. כך יש ניתוב פנימי ברמת ה-VPC.
אם חייבים לחבר הרבה VPC, עושים את זה בצורת כוכב (באחד המעבדות הבאות).
אם מתעקשים על Mesh, אפשר לבצע כל פעם את ה-Peering באמצעות סקריפט (באחת המעבדות הבאות).
יצירת המכונה הראשונה:
הולכים לתפריט שמשמאל (שלושת הפסים) ובוחרים Compute Engine, שם הולכים ל-VM instances ולוחצים למעלה על CREATE INSTANCE.
נותנים למכונה את השם instance-1. נבחר במחוז תל אביב – me-west1, ב-zone me-west1-a.
עכשיו נתעכב קצת על הגדרות מכונה – Machine configureation:
יש ארבע משפחות, כאשר ברירת המחדל היא General purpose, שנוקטת איזון יחסי בין כח העיבוד לזכרון. יש גם משפחות בהן היחס בין המעבדים לזכרון גבוה או נמוך יותר, וכאלה שצריכות GPU.
בכל משפחה יש סוגים שונים, שנוגעים לסוגי ותצורת המעבדים והזכרון. יש סוגים זולים יותר לשימוש סטנדרטי, ויש סוגים אחרים במקרים שבהם נדרשים ביצועים טובים יותר בשדה כזה או אחר.
אנחנו משאירים את סוג המכונה על ברירת מחדל – זו תהיה מסדרת E2, לבחור בסוג e2-micro.
נרד עוד קצת עד שנמצא את ההגדרות של Boot disk.
מבחינת מערכת ההפעלה והדיסק, להשאיר על ברירת מחדל. שרת Debian עם דיסק של 10GB מספיק למה שצריך.
– לשים לב שבהתאם לסוג המכונה, מערכת ההפעלה וגודל הדיסק שנבחרו, יש לנו בצד ימין סיכום של עלות המכונה.
תמיד לקחת בחשבון את העלויות, כאשר בוחרים נתוני מכונה!
לסמן allow http traffic.
לרדת למטה ל-Advanced Options, לפתוח את Networking.
כשיורדים עוד קצת למטה, רואים Network interfaces. כשלוחצים על החץ שפותח את השורה ששם (כנראה יהיה מסומן vpc-1), רואים שאפשר לבחור באיזו רשת ובאיזה subnet להציב את המכונה.
להציב אותה ב-VPC-1 בתוך Subnet-1, ואז מתחת ב-primary internal ipv4 address נראה שברירת המחדל היא Ephemeral (Automatic). שזה אומר כתובת שמתקבלת מה-DHCP של ה-Subnet. אנחנו נרצה לקבוע למכונה כתובת שאנחנו נבחר.
ללחוץ על החץ הקטן שם, ונראה שיש אפשרות של Ephemeral (Custom). כשנבחר בה, תפתח לנו שורה שבה נוכל לכתוב את הכתובת שנבחר – 10.0.10.10.
להשאיר את הכתובת החיצונית כפי שהיא, ולסמן מתחת Network Service Tier – Standard.
אז אפשר ללחוץ על Create.
לנסות להתחבר ב-SSH דרך הלחצן שבקונסולה:
– אי אפשר להתחבר עם SSH בגלל שאין חוקי פיירוואל שמתירים את זה.
יצירת חוקי Firewall:
כברירת מחדל Firewall של VPC חוסם את כל התעבורה הנכנסת ומאפשר את כל התעבורה היוצאת. כדי שנוכל להגיע למכונה כלשהי ב-VPC, נצטרך ליצור חוקי Firewall המאפשרים את אותה צורת תעבורה.
בתור התחלה, נרצה לאפשר התחברות SSH למכונה. בגלל שמכונה שנוצרת מתוך Image של GCP מקבלת רק חיבור SSH המאומת באמצעות מפתח א-סימטרי, נרצה להתחבר בהתחלה דרך הקונסולה של הניהול שמכניסה בעצמה מפתחות שכאלה ומחברת את המשתמש אוטומטית.
צורת החיבור הזו לא מגיעה מהמחשב שדרכו אתה גולש, אלא באמצעות הקונסולה, דרך שרתים של GCP. לכן התעבורה מגיעה מטווח הכתובות 35.235.240.0/20.
חוזרים לתפריט של VPC networks ושם הולכים ל-Firewall.
ניתן לראות שיש שם חוק אחד – vpc-1-allow-http. החוק מאפשר תעבורה הנכנסת לרשת מטווח 0.0.0.0/0 (שזה אומר כל הכתובות) בפורט 80. את זה פותחים כשרוצים לאפשר גישה לשירות Web מכל העולם. אם זה לא מכל העולם, במקום 0.0.0.0/0 מגדירים טווח מצומצם ויעודי שמתאים למה שצריכים.
– חשוב לזכור – ב-Firewall פותחים רק את מה שצריכים, ובדיוק את מה שצריכים. ככל שפותחים יותר פורטים מיותר מקומות, מגדילים את האפשרויות של תוקף לגשת לכתובות שלנו.
בראש העמוד יש לחצן CREATE FIREWALL RULE. לוחצים עליו כדי ליצור חוק חדש.
ניתן לו שם – build-in-ssh.
נקבע את הרשת – VPC-1.
כיוון התעבורה – Ingress. משמע – תעבורה נכנסת. והפעולה שנרצה להחיל בחוק הזה – Allow.
ואז יש Targets. אנחנו יכולים לאפשר את התעבורה הזו לכל הכתובות ברשת, ליעדים הנושאים תגית מסוימת, או עבור חשבון-שירות מסוים.
אנחנו נבחר לפי תגית, והתגית תהיה – external.
כעת נבחר לפי מה לסנן את מקור התעבורה. נבחר בסינון לפי טווח כתובות של IPv4, ונכתוב את הטווח 35.235.240.0/20, שממנו בא החיבור SSH המובנה בקונסולה.
למטה כשבוחרים איזה פרוטוקולים או פורטים לפתוח, לבחור Specified protocols and ports, ושם נסמן את פורט 22 TCP.
עכשיו לוחצים על CREATE והחוק נוצר.
שיוך מכונה לחוק פיירוואל:
עכשיו צריך לחזור ל-Compute Engine, להכנס ל-VM Instances ושם להכנס ל-instance-1. ללחוץ למעלה על EDIT, וכשנפתח חלון העריכה יורדים לאזור של Networking. שם מתחת להגדרות כרטיס הרשת יש Network tags. ניתן לשים לב שבגלל שמסומן Allow HTTP traffic, כבר יש תגית של http-server.
שמים את העכבר בצד ימין של התגית, בשורה, וכותבים external – כפי שכתבנו קודם בחוק של ה-SSH. ללחוץ למטה על SAVE.
לאחר שהשמירה מסתיימת, חוזר לחלון של המכונה. עכשיו אם לוחצים למעלה על SSH, החיבור מצליח.
ואם אני רוצה להתחבר למכונה דרך Putty מהמחשב שלי? – צריך להוסיף עוד חוק Firewall, שמאפשר התחברות מהמחשב הפרטי ל-instance-1.
חוזרים על תהליך יצירת החוק ב-Firewall כמו קודם, בהבדל אחד. במקום סינון המקור שניתן קודם עם טווח הכתובות שמהם גוגל שולח את חיבורי ה-SSH בקונסולה שלו, צריך לשים את הכתובת החיצונית שממנה אנו גולשים.
ניתן לקבל אותה אם מחפשים בגוגל Whatismyip.
כעת יש לנו חוק נוסף שמאפשר תעבורה בפורט 22 מהכתובת החיצונית שלנו למכונה הנושאת את התגית external.
אבל זה עדיין לא מספיק כדי להתחבר מהמחשב בבית דרך Putty.
התאמת תבנית שרת:
עם החיבור לשרת דרך הקונסולה, נראה שאנחנו מחוברים עם המשתמש שאיתו אנחנו מחוברים לקונסולה – המשתמש של גוגל. כעת נרצה ליצור משתמש מקומי בעל הרשאות ניהול, כדי שנוכל באמצעותו להתחבר שלא דרך הקונסולה, ולבצע פעולות.
בחלון הטרמינל של ה-SSH, מבצעים את הפעולות הבאות:
להתחבר ל-instance-1 באמצעות לחצן SSH בלוח הניהול של GCP.
לעבור למצב ניהול באמצעות הפקודה
sudo -iלהוסיף משתמש באמצעות הפקודה
add user <username>(להחליף את '<username>' במשתמש שבו תרצה להשתמש).
לתת סיסמה חזקה ולשמור אותה בצד.
אין צורך למלא אחרי זה את השם וכל הפרטים.
לאחר מכן לערוך את הגדרות שרת SSH בתוך המכונה באמצעות הפקודה:
nano /etc/ssh/sshd_configלגלול למטה עד שרואים שורה שכתוב בה PasswordAuthentication no.
לשנות ל-yes.
לצאת ולשמור (ctrl + x ואז y). לאחר מכן לאתחל את שירות ה-SSH כדי שיעבוד עם ההגדרה החדשה באמצעות הפקודה הבאה:
systemctl restart sshdכעת ניתן להתחבר למכונה באמצעות Putty דרך הכתובת החיצונית שלה, עם המשתמש והסיסמה שנוצרו קודם.
התחברות באמצעות Putty:
פותחים חלון של תוכנת Putty, ומתחברים לכתובת החיצונית של Instance-1. לאחר ההתחברות, ניתן להתקין nginx באמצעות הפקודה:
sudo apt install nginx -yבנוסף, נרצה להתקין telnet לצורך בדיקות תקשורת בהמשך:
apt install telnetלא נותן? צריך לשים sudo לפני הפקודה, או להתחבר כמשתמש root (משתמש הניהול של לינוקס) באמצעות הפקודה sudo -i.
לפתוח לשונית חדשה בדפדפן, ולהכניס כתובת של אתר ה-Nginx החדש שיצרנו זה עתה:
http://instance-1-external-ip
כמובן, את כל מה שבא אחרי הלוכסנים צריך למחוק, ולהחליף באותה כתובת IP חיצונית של המכונה.
כאשר מתחברים לשרת ה-Web באמצעות הזנה בדפדפן את כתובת ה-IP החיצונית של המכונה, מקבלים את הדף הבסיסי עם הכותרת "Welcome to Nginx!".
לאחר מכן חוזרים לקונסולה ועורכים את פרטי המכונה.
עריכת פרטי המכונה:
בקונסולה, ב-Compute Engine, הולכים ל-VM Instances, ושם לוחצים על המכונה instance-1 כדי להכנס לדף של המכונה.
שם למעלה לוחצים EDIT, ואז גוללים למטה, כמעט עד לסוף – באזור של Management יש סעיף של Automation שבו יש תיבת טקסט עבור Startup script. אלה פקודות טרמינל שמופעלות על ידי חשבון המערכת של המכונה עם העליה שלה לאחר הפעלה/אתחול.
שם נוסיף את הפקודה הבאה:
sed -i "14s/nginx/$HOSTNAME/g" /var/www/html/index.nginx-debian.htmlואז שומרים את השינויים במכונה.
פקודה זו עורכת את השורה ה-14 בדף ה-HTML הבסיסי של שרת ה-Web שהותקן עם Nginx.
עם הרצת הפקודה, מי שיתחבר בדפדפן לכתובת של המכונה, יראה בכותרת הדף במקום את המילה Nginx, את שם השרת.
כמובן, הכל בסיסי מאוד. רק הקמנו שרת Web, ואין לנו עניין להכניס לשם איזה אתר או אפליקציה מושקעת. הידיעה לאיזה שרת הגענו, תשרת אותנו בהמשך במעבדות הבאות.
לעת עתה, נאתחל את המכונה, נחכה שתעלה מחדש, ואז נתחבר מחדש בדפדפן לשרת ה-Web שלה.
ניתן לראות שכעת מופיע בדף כל הכיתוב הקודם, רק תחת הכותרת:
"Welcome to instance-1!"
יצירת Image:
עדיין בחלון של Instance-1, לוחצים למעלה "CREATE MACHINE IMAGE".
בדף שנפתח, נותנים שם – basic-nginx.
מכונת המקור היא כמובן – instance-1.
לסמן Regional ולבחור במחוז תל אביב – me-west1.
אז לוחצים CREATE.
לשים לב שאם קודם היינו בדף של המכונה instance-1 מתוך VM instances, עכשיו אנחנו ב-Machine images.
זה לא צריך לקחת הרבה זמן. יכול להיות שבשורה של המכונה הסימון של הסטטוס עדיין יסתובב. אבל אם באזור ההודעות (למעלה משמאל בין סימן השאלה של העזרה לבין הסמל של טרמינל) כבר לא מסתובב העיגול סביב הפעמון, פשוט ללחוץ למעלה על REFRESH ומיד נראה שהסטטוס הפך לירוק.
– את אותה פעולה בדיוק של יצירת Machine Image, אפשר לבצע מתוך הדף של Machine images בתפריט של Compute Engine, כשם שניתן לבצע אותה מתוך הדף של מכונה ספציפית שחיה לה בדף של VM instances.
כרגע נוצרה תבנית קפואה של שרת במצב שבו היה instance-1 כאשר יצרנו ממנו את ה-Image – כולל שרת nginx מותקן, ואותו משתמש וסיסמה שאפשר באמצעותם להתחבר עם Putty.
יצירת מכונות מתוך Image:
לוחצים על ה-Image שהרגע יצרנו, וזה מכניס אותנו לדף ובו פרטי המכונה.
לוחצים למעלה על הלחצן CREATE INSTANCE – נפתח דף ליצירת מכונה על פי אותו Image.
לשים לב לתפריט משמאל – זה תפריט יצירת מכונה ובו 4 אפשרויות. היינו יכולים להגיע לשם גם מ-VM instances אם היינו לוחצים על יצירת מכונה. אז היינו יכולים לעבור לאפשרות של New VM instance from machine image.
לבחור שם למכונה החדשה – נקרא לה instance-2.
גם אותה נשים במחוז תל אביב, ובאותו Zone – zone-a.
– יש לשים לב כי מבחינת מחירים ועלויות בסביבת GCP, אין עלויות על תעבורה באותו Zone בתוך הרשת שלך, אבל יש עלויות על תעבורה בין Zone שונים, וכמובן בין Region שונים.
כעת צריך לרדת למטה ולערוך את הגדרות הרשת:
להוריד את התגית של external.
לרדת טיפה למטה, ולערוך את כרטיס הרשת ב-Network interfaces. יש שם את כרטיס הרשת הקיים, ובו חץ קטן שבלחיצה עליו אפשר לפתוח את האפשרויות ולערוך.
לשנות את הרשת ל-vpc-2, ואז ל-subnet-2.
ואז את הכתובת של IPv4 לשנות מ-Ephemeral (Automatic) ל-Ephemeral(custom). אז תיפתח שורה חדשה ובה לשים את הכתובת שנבחר – אם כי היא חייבת להיות בטווח של ה-subnet שבחרנו למעלה.
נבחר בכתובת 10.0.20.12.
בשדה של הכתובת החיצונית, לשנות ל-None. למכונה הזו לא צריך כתובת חיצונית.
לרדת עוד ל-Management ולהוסיף את הפקודה ל-Startup script:
sed -i "14s/nginx/$HOSTNAME/g" /var/www/html/index.nginx-debian.htmlואז נלחץ על CREATE.
מיד ניצור עוד שתי מכונות בדיוק כמו instance-2. נקרא להן instance-3 ו-instance-4, נציב אותן באותו המחוז אבל ב-Zone-b ו-c, באותה הרשת ובאותו subnet, עם הכתובות 10.0.20.13, 10.0.20.14
יצירת Firewall Policy:
חוזרים לחלון Putty של instance-1 (אם אין כזה, פותחים ומתחברים מחדש), ולאחר התחברות למכונה, מבצעים פינג לאחת המכונות החדשות. נגיד – ping 10.0.20.12. אין פינג.
מבצעים telnet בפורט 80 לאותה המכונה:
telnet 10.0.20.12 80
מיד מודיע לנו שהוא מחובר. עכשיו אפשר לצאת משם באמצעות ctrl + ] ולאחר מכן q.
– לשים לב! בניגוד לגרסאות אחרות של לינוקס, פה (שרת Debian) כותבים את הפקודה כמו בווינדוס – עם רווח בין הכתובת IP לבין הפורט. רווח – לא נקודותיים!
למה telnet בפורט 80 עבד ופינג לא?
נחזור לתפריט של VPC network, ושם נלך ל-Firewall.
נראה שם רשימה של 4 חוקים. לשים לב לעמודות, יש שם עמודה של Network שאומרת לנו לאיזה VPC שייך כל חוק.
אז יש לנו שלושה חוקים עבור vpc-1 – שני חוקים שיצרנו עבור SSH ועוד חוק שנולד כאשר נוצר שרת instance-1 ובתהליך סומנה המשבצת allow HTTP traffic.
ויש עוד חוק כזה עבור HTTP השייך ל-vpc-2. החוק הזה נוצר כאשר נולד instance-2 מתוך התבנית של instance-1. כמו שאמרנו – ב-instance-1 האפשרות הזו סומנה, ולכן זה עובר גם למכונות שנוצרות מאותה התבנית.
לכן telnet עבד בפורט 80 – כי vpc-2 מאפשרת כניסה בפורט 80 מכל כתובת שהיא. אבל אין חוק שמאפשר פינג, לכן פינג לא עבר.
חוץ מ-פינג, יש עוד דברים שנרצה לאפשר ברשת הפנימית שיצרנו פה באמצעות peering. חבל יהיה לטרוח וליצור את אותם החוקים בהתאמה מחדש בכל vpc. בשביל זה יש Firewall Policy.
יצירת הפרופיל:
בראש הדף לוחצים על CREATE FIREWALL POLICY.
בדף שנפתח נותנים את השם general.
לסמן Regional עבור מחוז תל אביב וללחוץ CREATE.
זה מעביר אותנו לדף של ה-Firewall. החוקים הבודדים נמצאים למעלה, וה-Policy נמצאים למטה. אז אנחנו יורדים למטה ל-Network firewall policies ולוחצים על general כדי להכנס ל-policy הזה ולערוך אותו.
נכנסנו לפוליסי, ואנחנו רואים שכבר יש שם כמה חוקים. נעבור שוב על העמודות כדי להבין את המבנה:
Priority
ככל שהמספר גבוה יותר, זה אומר שהחוק בקדימות נמוכה יותר. חוק ב-Priority במספר נמוך יותר, יחול לפני חוק שמספרו גבוה יותר. אם יש התאמה למקור וליעד בחוק שחל קודם, החוק שבקדימות מאוחרת לא יבוא לידי ביטוי.
Direction of traffic
מראה אם החוק חל על תעבורה נכנסת או יוצאת. Ingress זה תעבורה שנכנסת לרשת (או למכונה), ו-Egress זו תעבורה שיוצאת מ-Gateway של רשת, או ממכונה.
– ב-Firewall policy זה נקרא Direction of trafiic. אבל אם נחזור לדף הראשי, נראה שבחוקים זה נקרא בפשטות Type
Targets
קובע על מי החוק חל. אם על כל המכונות ברשת, או רק כאלה עם תגית מסוימת, או כאלה שפועלות על Service Account מסוים.
Source
זה החלק בחוק שקובע על איזו תעבורה הוא חל. החוק יחול רק על תעבורה שבאה מכתובת או מטווח כתובות שנקבעו כ-Source. למשל – אם ב-Source כתוב 10.10.10.1, אז החוק לא יכול על תעבורה שבאה ממכונה שכתובתה 10.10.10.2. אם ב-Source כתוב 10.10.10.0/24, זה יחול על כל התעבורה שבאה מרשת 10.10.10.0. זה כולל גם תעבורה שבאה מהכתובת 10.10.10.2 שנזכרה קודם. אבל לא יכלול תעבורה שבאה מכתובת 10.10.20.2 למשל.
Destination
זה החלק בחוק שמסנן תחולה לפי יעד. כלומר – החוק יחול רק אם התעבורה מיועדת לכתובת שנמצאת ב-Destination. נמצאת ככתובת בודדת, או נכללת בטווח (או טווחים) שהוגדרו כ-Destination.
Protocols and ports
החוק יחול רק על פרוטוקולים ופורטים שמופיעים כאן. אם הוגדר פה פורט TCP 22, החוק לא יכול על RDP שעובד בפורט TCP 3389. גם אם התעבורה בפורט הזה מגיעה מאותה כתובת שמוגדרת כ-Source ומגיעה לאותה כתובת שמוגדרת כ-Destination. כדי שהחוק יחול, כל התנאים וההגדרות צריכים להתקיים ולהתאים.
Action
פעולת החוק.
הגדרה זו קובעת האם החוק יאפשר לתעבורה הזו לעבור, או יחסום אותה. יש גם אפשרות שלישית, נייטרלית – Go to next. אפשרות זו אומרת – אל תעשה כלום. בכל פעם שיש חיבור, החיבור עובר על כל החוקים בפיירוואל לפי סדר. בפיירוואל מסורתי זה מלמעלה למטה, פה ב-GCP זה לפי Priority. אם חוק 1 מתאים, הוא יחול על התעבורה וכל שאר החוקים שלאחר מכן לא רלוונטיים. אם חוק 1 לא מתאים מבחינת סינונים של מקור/יעד/פורט, זה עובר לחוקים הבאים. ברגע שחוק חל, כל מה שאחריו לא רלוונטי.
אז בעצם, Go to next אומר שגם אם החיבור מתאים לכל הקריטריונים המסננים, לעבור לחוקים הבאים בתור, ולחפש שם התאמה – ופעולה הנובעת מן ההתאמה הזו.
ניצור חוק חדש ב-Policy.
ממש מעל רשימת החוקים, צמוד לצד שמאל, יש לחצן CREATE. לחיצה עליו פותחת דף יצירת חוק.
ניתן לחוק את ה-Priority 1000.
כיוון התנועה – Ingress. משמע – תעבורה נכנסת.
הפעולה לביצוע – Allow.
לוגים – להפעיל.
Target – להשאיר את ברירת המחדל – כל הכתובות ברשת.
Source – ניתן לו את הטווח 10.0.0.0/16. שזה אומר רק תעבורה שבאה מכתובות פנימיות שמתחילות ב-10.0. כל הרשתות שיצרנו כבר בטווח הזה, וזה יתאים להן.
– בתור Source אפשר להכניס כמה טווחים שונים. פשוט מכניסים טווח, לוחצים על רווח ורואים שהטווח הראשון סומן כמעין תגית. אז אפשר להכניס עוד טווח או כתובת.
ישנן עוד הגדרות סינון מתקדמות שלא נבחר בהן – כמו סינון לפי Geolocation, לפי קבוצות כתובות שניתן להקים ב-GCP, לפי כתובות DNS מסוימות וכו'.
אנחנו נמשיך לבחור את טווח כתובות היעד שהחוק חל עליו.
נבחר בסוג של IPv4, בטווח שבחרנו קודם – 10.0.0.0/16.
בפורטים, נבחר לפתוח את הפורטים 22 ו-3389 בפרוטוקול TCP, שאלה הפרוטוקולים המשמשים ל-SSH ו-RDP. רושמים אותם בהפרדת פסיק, ככה: 22,3389. כמו כן תחת Other, נוסיף את הפרוטוקול ICMP – כדי לאפשר פינג.
ללחוץ על CREATE.
כעת נוסף לפוליסי חוק שמאפשר בין כל המכונות ברשתות הפנימיות שיצרנו, תקשורת של SSH, RDP, או פינג.
עכשיו נוסיף עוד חוק, שמאפשר לכל המכונות לקבל את ה-SSH המובנה בקונסולה של GCP.
לוחצים שוב על CREATE ובדף שנפתח:
Priority – 1001
כיוון תעבורה – Ingress
פעולה – Allow
Logs – On
Target – הכל.
Source – טווח הכתובות שממנו יוצאים חיבורי ה-SSH המובנים בקונסולה – 35.235.240.0/20.
Destination – לבחור בסוג Ipv4 בטווח של כל הרשתות שלנו – 10.0.0.0/16.
Protocols and ports – לבחור TCP 22.
ואז CREATE.
שיוך רשתות לפרופיל:
קצת מעל הלחצן של CREATE שיוצר חוק חדש, יש את FIREWALL RULES. לידו יש ASSOCIATIONS. מה שאומר שעד עכשיו היינו בחלק שמגדיר את החוקים של הפוליסי, ועכשיו נעבור לחלק שקובע לאיפה הפוליסי קשור ועל מי הוא חל. נלחץ על ASSOCIATIONS.
הרשימה ריקה.
נלחץ ADD ASSOCIATION, בצד יקפוץ חלון-צד כזה שבו ניתן לבחור איזה VPC מתוך אלה שיש לנו בפרוייקט, אנחנו רוצים לשייך לפוליסי.
– חשוב לזכור שבקנה מידה גדול, כשעובדים עם Organization, אפשר ליצור פוליסי שחל על כל ה-Organization. כאן אנחנו עובדים ברמת הפרוייקט, שהיא רמה נמוכה ופרטנית יותר.
נבחר את שלושת ה-VPC שיש ברשימה, ונלחץ על ASSOCIATE.
עכשיו, אם נחזור לחלון הטרמינל של Instance-1 וננסה שוב לבצע פינג לכתובת 10.0.20.12, נראה שיש פינג.
יצירת שרת נוסף לבדיקות:
נחזור ל-VM instances ונלחץ שוב על CREATE INSTANCE.
נבחר בשם instance-5.
מחוז ת"א Zone – a.
מכונה מסוג e2-micro.
ועכשיו נשנה את ההגדרות של ה-Boot disk. נלחץ שם CHANGE.
כעת נראה שקופצת חלונית צד רחבה של Boot disk. יש בה כמה לשוניות שמאפשרות לבחור איך להרים את המכונה.
אפשר להרים מכונה מתוך Snapshot של Boot disk או מתוך Boot disk שנותק ממכונה אחרת וכעת ממתין לחיבור למכונה חדשה. אבל מה שמעניין אותנו זה Images שקיימים אצל GCP – מערכות הפעלה מצויות שבוחרים ומהן עולה מכונה חדשה.
פה נבחר במקום Debian – את האפשרות השלישית מלמטה – Ubuntu. אפשר להשאיר את גרסת ברירת המחדל. זה לא משנה למעבדה.
ב-Boot disk type אפשר לבחור בין האפשרויות הבאות:
– Standard – רמת הביצועים הכי נמוכה, זה דיסק HDD.
– Balanced – רמת ביניים בין Standard ל-SSD.
– SSD – רמת ביצועים טובה.
– Extreme – עבור מכונות הדורשות דיסקים בביצועים גבוהים במיוחד.
לנו כרגע מספיק Balanced.
את גודל הדיסק אין צורך לשנות.
ללחוץ על SELECT.
בדיקה טובה היתה האפשרות להתקין שרת ווינדוס ולנסות ממנו חיבורי RDP, גלישה בדפים של השרתים שיצרנו וחיבורי SSH לשרתים שיצרנו. אבל ביצירת מכונת ווינדוס יתווסף מחיר הרישיון למחיר שעולים משאבי המכונה והאחסון.
בעוד שאת המחיר שגובה גוגל עבור השימוש במשאבים שלה, היא מוכנה לתת בחינם עבור התנסות, זה לא כולל תשלומים עבור מוצרים של ספק צד ג' – כמו מיקרוסופט. ולכן מוצרים שכאלה לא זמינים כ-Free Tier ולא מתאפשרים בלי שמאפשרים בהגדרות לקבל חשבונות לתשלום מגוגל על השימוש.
– חשוב תמיד להסתכל על החישוב ולדעת כמה תעלה מכונה לפני שיוצרים.
בדף ההגדרות של יצירת המכונה, נמשיך מעט יותר למטה, ב- Advanced options, Networking.
נציב את המכונה ב-vpc-3 ב-subnet-3.
ניתן לה כתובת פנימית בתבנית Ephemeral (Custom), ונבחר בכתובת 10.0.30.15.
ללא כתובת חיצונית.
נלחץ על CREATE.
חיבורי SSH:
חיבור SSH באמצעות מפתח א-סימטרי, מאפשר תצורת התחברות חסינה ל-Brute Force.
יצירת מפתח:
חוזרים ל-instance-1. שם מזינים את הפקודה הבאה:
ssh-keygen -t rsa -f ~/.ssh/key-file-name -C username -b 2048פקודה זו יוצרת מפתח א-סימטרי, שזה אומר מפתח פרטי ומפתח ציבורי. המפתח הציבורי יושב במכונה שאליה רוצים להתחבר, ועם המפתח הפרטי מאמתים את הזהות כאשר באים להתחבר.
ניתן לחשוב (במקרה זה בלבד) על המפתח הציבורי כעל המנעול, ועל המפתח הפרטי כעל המפתח.
כאשר משתמש בא להתחבר למכונה ומכניס את המפתח הפרטי – אם המפתח הפרטי מתאים לציבורי, המכונה תיפתח בפני המשתמש ללא צורך בסיסמה. המפתח הוא אמצעי האימות.
לשים לב לתחביר של הפקודה:
החלק הראשון מפעיל יצרן מפתחות. ואז יש את ה-Flag t, שזה Type – סוג ההצפנה שלפיה ניצור את המפתח. לאחר מכן יש את ה-Flag f, שזה File. פה אנו מציינים את הנתיב ואת שם הקובץ לשם יווצר וישמר המפתח – בשני קבצים. המפתח הציבורי ישא את השם הנקוב יחד עם הסיומת .pub, והמפתח הפרטי ישא את השם הנקוב לבד. כך שאם נשתמש בפקודה הזו כפי שהיא ללא שינוי, לקובץ המכיל את המפתח הפרטי יקראו key-file-name והוא ישב בתיקיה מוסתרת (בלינוקס תיקיות שמתחילות בנקודה הן תיקיות מוסתרות) בשם ssh, שנמצאת בתיקיית הבית של המשתמש שהפעיל את הפקודה.
לאחר מכן יש C גדולה שמסמלת Comment. מעין הערה או תווית שמצמידים למפתח. אנו מצמידים שם משתמש כלשהו בתור תווית. ולבסוף יש את ה-Flag b שמסמל bits. כלומר – באורך של כמה ביטים יוצרים את המפתח. במקרה שלנו – 2048.
אז כאשר אתה יוצר מפתח – במעבדה או במציאות, כדאי לשנות את החלק של שם הקובץ (הנתיב די בסדר. בעיקר אם זו תיקיית הבית של root), ואת המשתמש. לשים לב שהמשתמש שתקבע פה, יהיה המשתמש שאיתו תתחבר למכונות בצורה הזו.
…אז הפקודה הוזנה לאחר העריכה, ונוצרו במיקום המבוקש שני קבצים – המפתח הפרטי והציבורי.
הגדרת מפתח ציבורי למכונה:
כעת נרצה לאפשר לעצמנו להתחבר בצורה הזו למכונה ספציפית, או אולי אפילו לאפשר לעצמנו להתחבר לכל המכונות בפרוייקט בצורה הזו.
כדי לאפשר את זה, מוסיפים את המפתח הציבורי ל-Metadata של מכונה מסוימת, או של הפרויקט.
דבר ראשון צריך שיהיה לנו את המפתח בתצורה הנכונה:
שם – ב-instance-1 שבו יצרנו את המפתח, נזין את הפקודה הבאה:
cat ~/.ssh/key-file-name.pubואז יקפוץ לנו בטרמינל כל התוכן של המפתח הציבורי. כולל סוג ההצפנה וכולל ה-Comment שמכיל את שם המשתמש.
להעתיק את הכל ולשמור בצד. לא להשמיט כלום.
הגדרת מפתח ברמת המכונה:
נכנסים לדף של המכונה ולוחצים למעלה על EDIT כדי לערוך את הגדרות המכונה.
מיד אחרי ההגדרות של הדיסקים, יש את Security and access. ושם יש כותרת קטנה – SSH Keys.
אפשר לסמן שם לחסום מפתחות שהוגדרו ברמת הפרוייקט, כך שיהיה אפשר להתחבר למכונה רק באמצעות מפתח שהוגדר לאותה מכונה ספציפית.
אם לא מסמנים, זה פשוט לא סותר. אפשר להוסיף שם מפתח שיהיה ספציפי למכונה, ובאותה מידה יהיה אפשר להשתמש במפתח שהוגדר ברמת הפרוייקט.
לוחצים שם על הלחצן של ADD ITEM, ובשורה שנפתחת מדביקים את התוכן של המפתח הציבורי. כולו. כולל סוג ההצפנה בהתחלה ושם המשתמש בסוף.
אז שומרים את השינויים.
הגדרת מפתח ברמת הפרוייקט:
בתפריט של הקונסולה תחת Compute Engine, החלק הכי תחתון של התפריט הזה נקרא Settings. בראשו יש את ההגדרות של Metadata.
כשנכנסים לשם, יש שתי לשוניות – METADATE ו-SSH KEYS. עוברים ללשונית של SSH KEYS.
אם אין שם כלום, יופיע באמצע הדף לחצן להוספת מפתח. אם כבר יש מפתחות, צריך ללחוץ למעלה על EDIT, ואז יופיע לחצץ של ADD ITEM שלחיצה עליו תפתח תיבה שבה נוכל להדביק את המפתח הציבורי ולשמור את ההגדרות.
כעת ניתן להתחבר בתצורה הזו למכונה שבה הוגדר המפתח, ואם זה הוגדר ברמת הפרוייקט, לכל מכונת לינוקס.
לצורך המעבדה, נגדיר את המפתח ברמת הפרויקט.
חיבור SSH באמצעות מפתח א-סימטרי:
עכשיו נוכל להתחבר למכונה instance-5, שאצלה לא הגדרנו משתמש וסיסמה:
מתוך instance-1 נזין פקודת התחברות ב-SSH:
ssh -i f ~/.ssh/key-file-name username@10.0.30.15נעבור על התחביר:
בתחילה יש את הפקודה שמפעילה חיבור SSH. לאחר מכן יש את ה-Flag i. זה אומר identity-file. אנחנו אומרים לפקודה שאת הזהות שלנו נאמת מתוך קובץ במקום בסיסמה. לבסוף מכניסים את המשתמש ואת המכונה שאליה רוצים להתחבר, כשהשטרודל מחבר ביניהם.
כמובן, במקרה שלנו תחליפו את ה-key-file-name בשם שבחרתם לקבצי המפתח, ואת username בשם המשתמש שבחרתם קודם להכניס בתור Comment.
והנה – הפלא ופלא! התחברנו למכונה מבלי שהיינו צריכים להגדיר בה משתמש. המכונה לקחה את המשתמש מתוך ה-Metadata, וכאשר אימתנו את זהותו באמצעות המפתח הפרטי, קיבלנו גישה פנימה.
– יש לדעת שמשתמש שמתחבר בצורה כזו, מקבל הרשאות sudo.
התחברות באמצעות תוכנת Putty:
אם נרצה להשתמש באותה שיטה כדי להתחבר באמצעות Putty ל-instance-1, נצטרך להמיר את המפתח הפרטי לפורמט ppk שתוכנת Putty מכירה.
בתוך המכונה שבה יצרנו את המפתחות – במקרה שלנו instance-1, מריצים את הפקודה הבאה:
cat ~/.ssh/key-file-nameעל המסך יופיע תוכן הקובץ של המפתח הפרטי. להעתיק את כולו ולשמור בקובץ טקסט בשולחן העבודה.
לפתוח PuTTygen – אפשר לחפש בחיפוש של ווינדוס, למצוא בתפריט האפליקציות בתיקיה של Putty, או ללחוץ קליק ימני על הלשונית שמסמלת את החלון הפתוח של Putty בשורת המשימות, ושם בתפריט יש Run PuTTygen.
בחלון של PuTTygen יש מימין לחצן Load. יפתח סייר קבצים שבו נלך למקום שבו שמרנו את קובץ הטקסט מקודם. כרגע הוא מציג רק קבצי ppk. נגיד לו להציג את כל הקבצים, נבחר בקובץ המכיל את המפתח ונאשר. הוא יבקש לאשר שאנחנו רוצים לייבא מפתח זר, ואז יטען אותו.
מיד נוכל לשמור את המפתח בפורמט ppk בלחצן Save private key שנמצא די למטה מימין בחלון.
עכשיו כשרוצים להתחבר ל-instance-1, פותחים חלון של Putty, ובחלק השמאלי של החלון יש תפריט אפשרויות כזה. בחלק התחתון של Connection יש קטגוריה שניתן להרחיב – SSH. שם צריך להרחיב את Auth ולהכנס ל-Credentials.
ללחוץ Brows בשדה העליון יותר – Private key file for authentication, ולבחור את קובץ ה-ppk שעכשיו יצרנו באמצעות PuTTygen.
עכשיו בחלק השמאלי לוחצים הכי למעלה – על Session, וזה מחזיר אותנו ללשונית ובה פרטי ההתחברות הבסיסיים.
למעלה בחלק של Host Name שמים את הכתובת החיצונית של instance-1, ורואים שאנחנו מתבקשים להזין משתמש. ברגע שמזינים את המשתמש שבחרנו ב-Comment, מצליחים להתחבר למכונה.
כאן תמה מעבדה זו.
אם רוצים להתקדם הלאה, לא למחוק את המשאבים. לכל היותר לכבות את כל השרתים שנוצרו, כדי שלא יורידו מהתקציב על שימוש במשאבי עיבוד (רק על האחסון עבור גדלי הדיסקים שהוגדרו למכונות).
במעבדה הבאה נשתמש בכל מה שהגדרנו כאן.