המטרה היא לטעון במהירות ובקלות כמויות מידע גדולות מערוצי מידע מגוונים.
האתגרים עם טעינת מידע ב-big data הם:
1. כמויות מידע גדולות מערוצי מידע מגוונים
2. וידוא שהמידע מגיע בשלמותו
3. ניצול אפקטיבי של המשאבים
שיטות פשוטות באמצעות סקריפטים בד"כ לא כל כך יעילות ולוקחות זמן
רב. ולכן פותחו עבור כך מספר כלים:
Apache Flume – מאפשר
טעינת מידע רב של לוגים ממקורות רבים ל-hadoop.
Apache Sqoop – מאפשר
העברת מידע ממסדי נתונים רלציונים (RDBMS) ולא רלציונים (NoSQL) ל-hadoop.
Apache Kafka – מערכת
הודעות publish-subscribe עבור עיבוד
מידע בזמן אמת. מערכת בעלת יציבות גבוהה, יכולת scaling ועמידות
בפני תקלות (fault-tolerance).
Apache Storm – מערכת זמן
אמת לעיבוד מהיר של הודעות בכמויות מידע גדולות.
Apache Sqoop (SQL to Hadoop)
המילה sqoop היא כעין
ראשי תיבות של SQL
to Hadoop כיון שזו המטרה של המערכת. היא מיועדת להעברת מידע מובנה ממסדי
נתונים רלציונים ולא רלציונים ל-hadoop. המערכת גם יודעת להעביר מידע
בכיוון ההפוך, מ-hadoop למסדי
נתונים.
Sqoop import - ביבוא
נתונים ממסדי נתונים רלציונים ל-Hadoop כל שורה בטבלה נשמרת כיחידת
מידע ב-hadoop. כל הנתונים
נשמרים כקבצי טקסט, או כמידע בינארי בקבצי Avro ו-Sequence.
Sqoop export – ביצוא
נתונים הכלי מייצא קבצים מ-HDFS למסדי נתונים רלציונים. הקבצים שנשלחים ל-Sqoop מכילים מידע
שיהפוך לשורות בטבלאות.
היכולת של Sqoop לעבוד מול מקורות
מידע מגוונים היא בזכות ארכיטקטורת ה-connectors של Sqoop. ל-Sqoop יש connectors שמאפשרים התחברות למגוון מסדי
נתונים (MySQL,
PostgreSQL, Oracle, SQL Server and DB2). בנוסף ישנו JDBC connector שמאפשר
התחברות לכל מסד נתונים שתומך בפרוטוקול JDBC. יש גם third party connectors שניתן
להתקין ב-Sqoop והם מאפשרים
עבודה עם סוגים אחרים של מסדי נתונים, החל מ-enterprise data warehouse ועד NoSQL.
Apache Flume
כלי שמאפשר איסוף מידע רב כמו למשל log files או events שמגיעים
ממקורות שונים ושולח אותם ל-Hadoop (לקבצי HDFS או HBase). Flume מעביר כל מידע ע"י 2 טרנזקציות. אחת עבור השולח ואחת עבור המקבל
והוא מבטיח שליחה אמינה של המידע. כאשר קצב המידע גבוה יותר מקצב כתיבת המידע ליעד,
Flume משמש כמתווך
בין השולח למקבל ומספק קצב שליחה יציב.
הארכיטקטורה של Flume נראית כך (מהאתר הרישמי):
ה-events נשלחים אל
ה-Flume source בפורמט
שהיעד מצפה לו. ה-Flume
source שומר את ה-event ב-Flume channel. ה-channel משמש כמקום אחסון לשמירה של ה-events עד שה- Flume sink מושך אותם. ה-channel ישתמש ב-file system המקומי כדי
לשמור את ה-events. ה- Flume sink מוחק את ה-event מה-channel ושומר אותו
ביעד (HDFS או HBase). ניתן לשרשר מספר Flume agent כך שהמידע
יעבור מאחד לשני ורק לבסוף ישלח ליעד.
Apache Kafka
בדומה ל-Flume גם Kafka הוא כלי
לאיסוף מידע רב ממגוון מקורות ליעד מסוים. הכלי פותח בלינקדאין במטרה להתגבר על
חסרונות שהיו ב-Flume. לאחר מכן
הכלי עבר להיות קוד פתוח תחת Apache.
Kafka מאפשר לשלוח
stream של מידע
ולהירשם ל-stream. הוא מאפשר
לשמור stream של מידע
בצורה שהיא fault-tolerant והוא מאפשר
עיבוד של המידע תוך כדי שליחתו.
Kafka יכול לרוץ
על מכונה אחת או על כמה מכונות כ-cluster. Kafka שומר streams של מידע בקטגוריות שנקראות topics. כל מידע כולל key, value, timestamp.
ארכיטקטרה של Kafka מהאתר הרשמי:
כפי שניתן לראות מהתרשים הזה, ה-Producers הן אפליקציות ששולחות מידע ל-Kafka. ה-Consumers הן אפליקציות שנרשמות ל-Kafka כצרכניות של מידע מסוים. ה-Connectors הם רכיבים
שמתחברים ל-Kafka לצורך אחסון
המידע. וה-Stream
Processors הם רכיבים שמעבדים את המידע שעובר ב-Kafka.
כדי לאפשר את כל הפונקציות הללו יש ל-Kafka חמישה APIs עיקריים:
1. Producer
API – מאפשר לאפליקציות להפיץ stream של מידע ל-topics.
2. Consumer
API – מאפשר לאפליקציות להירשם כצרכני מידע מ-topics מסוימים.
3. Streams
API – מאפשר לאפליקציות לצרוך מידע מ-topics מסוימים לעבד אותו ולשלוח את
המידע החדש ל-topics מסוימים.
4. Connector
API – מאפשר ליצור אפליקציות שצורכות את המידע מ-topics מסוימים, ושולחות את המידע לאחסון או לאפליקציות אחרות.
5. Admin
API – מאפשר ניהול וניטור topics ושאר אובייקטים של kafka.
Apache Storm
זוהי מערכת לעיבוד מהיר של כמויות גדולות של נתונים. היא מאפשרת צריכה של
נתונים ועיבודם בדרכים מגוונות. המערכת הזו יכולה להתחבר לכל סוגי ה-DB וה-queueing.
ב-storm יש כמה
מושגים תיאורטיים שמתארים מבנה של מערכת.
Topology – מתאר את
הלוגיקה של מערכת storm. זה בעצם
תרשים של spouts ו-bolts שמקושרים
ע"י stream.
Stream – מתאר רצף
של נתונים שמעובדים ונוצרים בצורה מקבילית ומבוזרת. ה-stream מתואר ע"י סכימה שמתארת
את השדות שה-stream מכיל.
Spout – מתאר מקור
של stream ב-topology. spout יקרא את הנתונים
ממקור חיצוני וישלח אותם לתוך ה-topology. ה-spout יכול להיות reliable (נתון שעיבודו
ב-storm נכשל ישלח
שוב) או unreliable (שגר ושכח,
אין שליחה חוזרת). Spout יכול לשלוח נתונים ממספר מקומות.
Bolt – מתאר את
היחידה שמעבדת את המידע. העיבוד יכול להיות פשוט או מורכב. בעיבוד מורכב יש
בד"כ צורך בכמה צעדים ולכן יש צורך בכמה bolts. Bolt יכול לטפל בנתונים ממספר streams ויכול לשלוח מידע למספר streams.
להלן איור מהאתר הרשמי שמתאר topology של מערכת:
עד כאן להפעם.
אם אהבתם, תכתבו משהו למטה...
אין תגובות:
הוסף רשומת תגובה