כמה מילים על - Spark

פרויקט קוד פתוח של Apache חדש יחסית לעומת hadoop, שנועד להתגבר על החסרונות של Hadoop. Spark הוא מנוע גנרי לעיבוד מהיר של big data. 

בדומה ל-hadoop גם ב-Spark עיבוד הנתונים הוא מקבילי ומבוזר על commodity hardware (מערכות רגילות יחסית שידוע מראש שמדי פעם יהיו Nodes שייפלו). Spark נכתב ב-scala ורץ על JVM. כלי ה-debug של Java זמינים גם למתכנת spark.

ל-Spark יש API עשיר שמאפשר להריץ על cluster של הרבה מחשבים שאילתות SQL, מודלים של machine learning, graph processing ועוד כדי לעבד big data במהירות.

בעיבוד מבוזר יש הרבה אתגרים שאין בתכנות רגיל על מכונה יחידה. למשל - 

• טיפול בנפילות של חלק מהמכונות
• data latency 
• סנכרון בין תהליכים 
• scalability 

ועוד אתגרים רבים.

Spark מטפל בכל הדברים הללו מתחת לפני השטח כך שהמתכנת לא צריך להתעסק עם הדברים האלו. Spark גם מציע פרדיגמה שמקלה על כתיבת קוד מקבילי.

אחת הסיבות ש-spark הפך להיות כל כך פופולארי היא מהירות העיבוד שלו. Spark משתמש ב-in-memory caching וב-DAG-based processing engine כדי להגדיל את מהירות העיבוד. הוא מנצל את הזיכרון של ה-Nodes כדי לשמור חישובי ביניים ולהשתמש בהם שוב כשצריך. דבר זה מגדיל את מהירות העיבוד בצורה משמעותית. Spark הצליח להגיע לביצועים שמהירים פי 100 מ-hadoop עבור in-memory computations והוא מהיר פי 10 עבור חישובים על הדיסק. Spark ניצח את Hadoop בתחרות של מיון מידע בגודל של peta-byte (התחרות נקראה Daytona GraySort contest), היה מהיר פי 3 מ-hadoop והשתמש בפי 10 פחות חומרה מ-Hadoop.

Spark גם יודע לעבד בצורה מהירה מודלים איטרטיבים של Machine learning הודות ל-in-memory caching שלו. הוא מספק תגובה ב-real-time עבור שאילתות על כמויות מידע גדולות, ויש לו low latency באנליזות שמבוצעות על live data streams.

ניתן להשתמש ב-spark עם השפות python, Scala ו-java.

Spark מאחד בתוכו את כל הכלים הנצרכים ל-data science pipeline. במקום להשתמש בהרבה כלים נפרדים לצורך כל ה-pipeline. הוא מספק API לצורך:

• data mungling (preprocessing של המידע לפורמט הנדרש)
• ETL (ראשי תיבות של Extract, Transform and Load שזהו תהליך של העברת מידע מ-DB אחד לאחר)
• Machine Learning
• Graph processing
• Streaming
• Interactive and batch processing

וכך ניתן לבצע את כל ה-pipeline על אותו Framework. 

הוא גם מקל בכל תהליך הפיתוח, ה-deployment והתחזוקה. יש לו אינטגרציה עם הרבה כלים ב- ecosystem של Hadoop והוא יכול לקרוא ולכתוב להרבה פורמטים ומקורות מידע כמו HDFS, Cassandra, S3, HBase ועוד.

Spark (בשונה מ-hadoop) הוא לא מערכת של data storage אבל הוא מנוע עם יכולות מגוונות של קריאה וכתיבה. בנוסף הוא מספק DataFrame API לצורך קריאת מידע מובנה ע"י Spark SQL. 

עד כאן להפעם.

אם אהבתם, תכתבו משהו למטה...

כמה מילים על - Data monitoring using Ambari, Oozie and Zookeeper

המטרה של כלים אלו היא לנהל, לנטר ולהפעיל Hadoop clusters.

Apache Ambari – כלי שמאפשר ניהול, ניטור ושליטה על Hadoop clusters.

Apache Oozie – זהו java web application שמשמש לתזמן Apache Hadoop jobs. הוא יודע לאחד מספר jobs ברצף למשימה לוגית אחת.

Apache Zookeeper – כלי שמאפשר תיאום בין תהליכים מבוזרים.

Apache Ambari

כלי זה מקל על ניהול מערכת Hadoop. הוא מספק web UI לניהול המערכת, יחד עם RESTful API. להלן איור מתוך ה-UI:

Ambari מאפשר למפתחי אפליקציות להכניס את יכולות הניהול והניטור לאפליקציות שלהם ע"י שימוש ב-REST API שלו.

Ambari מקל על מנהלי מערכות בדרכים הבאות:

• הוא מספק מדריך של צעד אחרי צעד להתקנת Hadoop services על כמה hosts שצריכים.
• הוא עוזר בקינפוג ה-Hadoop services של ה-cluster.
• הוא מאפשר ניהול של ה-Hadoop services כולל הרצה, עצירה, וקינפוג ה-services בכל ה-cluster.
• הוא מספק dashboard לניטור המצב של ה-cluster (כמו למשל health check).
• הוא משתמש ב-Ambari metrics system לצורך איסוף מדדים של המערכת.
• הוא משתמש ב-Ambari alert framework בשביל להתריע כשיש צורך בתשומת לב מיוחדת.

Apache Oozie

Oozie הוא java web application ליצירת workflow של Hadoop. ניתן בעזרתו לתזמן, להריץ ולנהל jobs של Hadoop. הוא יכול לאחד מספר jobs ולהריץ אותם ברצף ובכך ליצור משימה מורכבת וגדולה. ניתן גם להריץ בעזרתו מספר jobs במקביל.

Oozie יודע לעבוד בצורה טובה עם Hadoop stack כמו למשל MapReduce, Hive, Pig, Sqoop. כמו כן ניתן להריץ בעזרתו תוכנות כלליות כמו Java ו-Shell.

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

ה-workflow כתובים ב-hPDL (שזו XML process definition language). פעולות ב-workflow בעצם מריצות פעולות במערכות מרוחקות (למשל פעולות של Hadoop או Pig), ומעדכנות את Oozie ברגע שהפעולה מסתיימת, ואז Oozie מפעיל את הפעולה הבאה ב-workflow.

Apache Zookeeper

זהו כלי שעוזר לבצע שיתוף פעולה בין תהליכים מבוזרים ב-hadoop cluster. להלן חלק מהאפשרויות שהוא מציע:

• קריאה בשם לכל מכונה ב-cluster
• ניהול הקונפיגורציה כך שיהיה קל לבצע סינכרון של הקונפיגורציה בין מכונות ב-cluster
• סינכרון בין תהליכים. הוא מאפשר הרצה ועצירה של מכונות ובכך עוזר בהרצת תהליכים בסדר הנכון
• הוא יכול למנות מכונה שהיא master שתנהל את כל הבקשות מה-client בשם ה-cluster כולו. אם ה-master נופל מכל סיבה שהיא, הוא ימנה מכונה אחרת שתחליף אותו.
• הוא מאפשר תקשורת בין המכונות ב-cluster. הוא מאפשר תקשורת בסגנון של publish/subscribe, ויצירה של queue שמבטיח שליחה של הודעות גם כשיש מכונות שנפלו.

אם אהבתם, תכתבו משהו למטה...

כמה מילים על - Ingestion and Integration tools: Flume, Sqoop, Kafka, Storm

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

האתגרים עם טעינת מידע ב-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 של מערכת:

עד כאן להפעם.

אם אהבתם, תכתבו משהו למטה...