Hadoop
פרויקט קוד פתוח של Java עבור איחסון מבוזר ועיבוד מבוזר. הוא נועד לרוץ על cluster של מאות ואפילו אלפי מחשבים בשביל
כמויות נתונים גדולות – big data. הפרויקט התחיל ע"י Doug Cutting שעבד עבור yahoo (בהמשך הוא עבר
להיות ה-Chief
Architect ב-Cloudera, והיום – אני לא יודע מתי אתם קוראים את זה... אז חפשו בגוגל אם זה
מעניין אתכם). הפרויקט הוא תחת Apache license 2.0 והוא קיבל השראה מ-MapReduce ו-Google File System.
Apache
Hadoop framework מורכב מהחלקים הבאים:
- Hadoop common – מכיל ספריות ופונקציות עבור שימוש שאר המודלים של Hadoop
- Hadoop Distributed File System (HDFS) – מערכת קבצים מבוזרת, בעלת ביצועים מהירים בתוך ה-cluster.
- Hadoop MapReduce – המודל שאחראי על large-scale data processing
- Hadoop YARN – המודל שאחראי על ניהול המשאבים בתוך ה-cluster.
HDFS
מערכת קבצים (file system) שפותחה ב-Java ודומה למערכת הקבצים של Linux, אבל מאחורי הקלעים הקבצים
מבוזרים. המערכת בנויה כך שתהיה עמידה בפני תקלות (fault-tolerant). כך שאם יש תקלה בשרת מסוים
המערכת יודעת לזהות את התקלה ולהתגבר עליה בצורה מהירה ואוטומטית.
המערכת בנויה לתמיכה במאות מליוני קבצים ע"י scaling של המערכת
לעוד ועוד מכונות (נקראות גם Nodes) ב-cluster. המערכת משתמשת בשיטה של write once read multiple times כדי לשמור
על קוהרנטיות המידע וכדי להשיג גישה מהירה למידע.
המערכת בנויה לתת יותר תפוקה מאשר תגובה מהירה (optimized for throughput rather than
latency). משמעות הדבר היא שהמערכת יותר טובה בהרצה של עיבוד ארוך על הרבה
מידע מאשר לעשות אנליזות אינטרקטיביות על מידע שזורם ומגיע עכשיו.
עיבוד הנתונים "זז" כדי להיות קרוב לנתונים. משמעות הדבר היא שהמערכת תנסה
להריץ את העיבוד על אותה מכונה ששם נמצאים הנתונים כדי להקטין את השפעת מהירות הרשת.
ארכיטקטורה של HDFS
מהאתר הרישמי: https://hadoop.apache.org/docs/current/hadoop-project-dist/hadoop-hdfs/HdfsDesign.html
הארכיטקטורה
בנויה בצורה של Master-slaves. כאשר ה-master נקרא Namenode וה-slaves נקראים Datanodes (הריבועים
הצהובים). בד"כ יש רק master אחד ב-cluster.
הקבצים מחולקים ל-blocks (הריבועים
הירוקים) שמאוחסנים על Datanodes. בכל מכונה (node) יש בד"כ Datanode אחד. ה- Datanode אחראי על
ניהול האיחסון באותו node שבו הוא מותקן, וה- Namenode אחראי על ניהול
כל ה-metadata, שכולל איזה
blocks נמצאים על כל
Datanode, ואיזה קבצים
יש על כל block.
ברגע שיש פקודה ל-file system כמו פתיחת קובץ, סגירת קובץ, או שינוי שם של
קובץ או ספריה, ה- Namenode שולח את
הפקודה אל ה-
Datanode הרלוונטי, ואותו
Datanode מבצע את
הפקודה. ה-
Datanode אחראי גם על
יצירת blocks, מחיקת blocks והכפלה של blocks (שנועדה
בשביל fault-tolerance ו-resilience) לפי
הפקודות שהוא מקבל מה-Namenode.
כל קובץ נשמר על מספר blocks לצורך fault-tolerance. גודל כל block וכמה פעמים
יוכפל כל block (replication factor) ניתן לקינפוג
במערכת.
המילה Rack בד"כ
מייצגת קבוצה של Datanodes שנמצאים
במיקום גיאוגרפי מסוים.
ה-
Namenodeמקבל כל כמה
זמן heartbeat ו-BlockReport מכל Datanode ב-cluster כדי לדעת מה המצב של כל Datanode והאם הוא פועל
כראוי.
Hadoop MapReduce
תוכנה שמאפשרת עיבוד כמויות גדולות של מידע בסדרי גודל של multi-terabyte. התוכנה
מאפשרת עיבוד מבוזר על cluster שמכיל אלפי nodes (שרתים). התוכנה יכולה לרוץ על מערכות רגילות יחסית (commodity hardware) שידוע מראש
שמדי פעם יהיו Nodes שייפלו,
ועדיין לספק מערכת שהיא מאוד אמינה ועמידה בפני תקלות (reliable and fault tolerant).
המערכת נכתבה ב-Java ובנויה משני מרכיבים:
- API שמאפשר כתיבה של MapReduce workflows ב-Java
- סט של services לצורך ניהול ה-workflows כמו למשל scheduling, distribution and parallelizing.
שלבים ב-Hadoop
MapReduce job
1. מחלקים את ה-data לחלקים בלתי תלויים
2. כל חלק מעובד בצורה מקבילית ע"י map task אחר ב-node אחר
3. לאחר מכן מערכת ה-MapReduce ממיינת את הפלט של ה-map tasks ושולחת את
הפלט ל-reduce
task
4. הקלט והפלט של ה-map tasks ושל ה-reduce tasks נשמרים ב-file system
5. מערכת ה-MapReduce אחראית על תזמון
המשימות, מנטרת אותן ומריצה מחדש משימות שניכשלו
6. ה-MapReduce שאחראי על
העיבוד וה-HDFS שאחראי על
ה-file system רצים על
אותם Nodes. וכך העיבוד
רץ על אותו Node שבו נמצא ה-data ורוחב הפס
של התקשורת בין ה-nodes לא משפיע
ולא מתבזבז
ה-MapReduce מחלק את ה-data לזוגות של key, value. לאחר מכן בתהליך
ה-map ה-data מעורבב, ממויין, מסודר בקבוצות
ומועבר לתהליכי ה-reduce. פעולת ה-reduce מתבצעת לפי key, value כך שכל reduce מבוצע על זוגות בעלות אותו key.
חשוב לדעת, שבגלל אופן הפעילות הזאת לא ניתן להשתמש ב-MapReduce על נתונים שנתון
אחד תלוי בנתון הקודם, כמו סידרת פיבונאצ'י לדוגמה.
קונפיגורציה של job כוללת מיקומי קלט ופלט ב-HDFS, פונקציית map ופונקציית reduce ע"י
הממשק של MapReduce או בדרכים
אחרות שקיימות ופרמטרים נוספים על ה-job. לאחר מכן ה-hadoop job client שולח את ה-job (כ-jar או executable אחר) יחד עם הקונפיגורציה ל-ResourceManager ב-YARN שאחראי להפיץ אותם ל-nodes ולנהל את המשימה
ע"י תיזמון, ניטור, ודיאגנוסטיקה של הריצה.
איור מויקיפדיה שמדגים את פעולת MapReduce עבור משימה של ספירת מילים זהות
בטקסט:
YARN
מנהל משאבים גנרי שהוצג לראשונה ב-Hadoop 2.0. YARN זה ראשי תיבות של Yet Another Resource Negotiator. YARN הוא כלי
עיקרי ב-hadoop כיון שהוא
מנהל משאבים רבים במערכת ולא רק את ה-MapReduce.
הארכיטקטורה של YARN נראית כך (מתוך האתר הרישמי):
ב-YARN
יש ResourceManager אחד שאחראי
על חלוקת המשאבים בין האפליקציות במערכת. בכל node יש NodeManager שאחראי על
ה-containers שיש בכל Node. המושג container ב-YARN מייצג אוסף של
משאבי חומרה (CPU
cores, memory, disk, network) שעליהם רצה האפליקציה בפועל.
ה-NodeManager מנטר את
ניצול המשאבים ומדווח ל-ResourceManager כדי שיוכל להחליט על תזמון המשאבים למשימות
השונות.
ה-ResourceManager מורכב משני
חלקים: Scheduler
and ApplicationsManager.
ה-Scheduler אחראי על
הקצאת המשאבים לאפליקציות השונות. ואילו ה-
ApplicationsManager אחראי על
קבלת משימות חדשות (job submissions) ועל ההחלטה איפה המשימות האלו ירוצו. הוא
מתקשר עם ה-NodeManager שנמצא ב-node שעליו הוא
רוצה להריץ וכך מחליט אם להריץ על ה-node הזה או על node אחר.
רכיב נוסף נקרא ApplicationMaster והוא קיים לכל אפליקציה. ה-ApplicationsManager מריץ את ה-ApplicationMaster של כל
אפליקציה ושולט על כל ה-ApplicationMasters. כמו כן הוא מספק service שנועד להריץ
מחדש את האפליקציה במקרה של נפילה.
ה-ApplicationMaster אחראי לנטר
את מצב האפליקציה ואת ההתקדמות שלה. כמו כן הוא מתקשר עם ה- Scheduler לצורך קבלת הקצאות של משאבים
לפי הצורך.
נסכם את סדר הפעולות:
- ה-ResourceManager מקבל בקשה מה-client להריץ אפליקציה
- ה-ResourceManager מקבל את מצב ה-node מכל NodeManager ומחליט איפה להריץ את האפליקציה
- ה-ResourceManager מריץ את ה-ApplicationMaster של אותה אפליקציה (לאו דווקא על אותו node שעליו ירוץ ה-container של האפליקציה, כפי שניתן לראות באיור של הארכיטקטורה)
- ה-ApplicationMaster מנטר את ה-container שעליו רצה האפליקציה ומבקש משאבים מה- ResourceManager לפי הצורך
Hadoop Ecosystem
עד כאן עסקנו בחלקים העיקריים של Hadoop. בפוסטים הבאים נעסוק בחלקים
נוספים ב-ecosystem של Hadoop. חלקם נועדו להוסיף יכולות
וחלקם לפשט את העבודה.
אפשר לחלק את תפקיד החלקים הנוספים הללו ל-5 נושאים עיקריים:
1. Data
management – כולל איפה פיזית ה-data מאוחסן פלוס
ניהול ה-Nodes שעליהם
מאוחסן המידע. בנושא הזה יש את HDFS ו-YARN שהם חלק מה-core של Hadoop אבל יש גם
את HBase שהוא no-SQL DB.
2. Data
access – מדובר על פעולות כמו נירמול המידע, פעולות סטטיסטיות, פעולות
SQL כמו join או filter ועוד. הכלים שיעזרו לנו בזה הם
MapReduce
Hive עבור שאילתות SQL, ו-Pig עבור סקריפטינג.
3. Data
ingestion and integration – בביטוי ingestion הכוונה
לתהליך לקיחת ה-data. יכול להיות
עבור שימוש מיידי או עבור שמירה ב-DB. בד"כ לא כולל תהליך של המרה ועיבוד
המידע. בביטוי integration הכוונה להכנת
המידע עבור השימוש שלו הוא מיועד. הכלים לתחומים האלה הם Flume, Sqoop, Kafka, Storm. הם עוזרים
בקליטת המידע ממגוון מקורות כמו רשתות חברתיות, שרתי רשת, SQL DB, no-SQL DB, מערכות messaging, Queues, ועוד.
4. Data
Monitoring – בקטגוריה הזו יש כלים שנועדו לנטר את המידע
בצורה מרוכזת. הכלים בתחום הזה הם Ambari, Zookeeper, Oozie.
5. Data
governance and Security – מדובר על תהליכים שאחראים על ניהול המידע
כך שיהיה זמין, שלם ומאובטח (authentication, Authorization, Encryption). כמו כן ניתן לקבוע סט של כללים
על המידע לפי הצורך ולאכוף אותו. הכלים בתחום הזה הם Falcon, Ranger, Knox.
אם אהבתם, תכתבו משהו למטה...
פעם ראשונה שאני מצליחה להבין את התמונה של עיבוד ביג-דאטה (וזאת לאחר שיטוטים לא מעטים באינטרנט). שאפו!
השבמחקמוסבר פשוט ועושה הרבה סדר בין הכלים והמושגים.
מכאן קל להבין אח"כ את הכלים המתקדמים יותר SPARK וכו
יישר כח !