Ανάλυση Αρχείων Καταγραφής σε Υπολογιστικά Νέφη. Log File Analysis in Cloud Computing

Transcript

1 ΑΡΙΣΤΟΤΕΛΕΙΟ ΠΑΝΕΠΙΣΤΗΜΙΟ ΘΕΣΣΑΛΟΝΙΚΗΣ ΣΧΟΛΗ ΘΕΤΙΚΩΝ ΕΠΙΣΤΗΜΩΝ ΤΜΗΜΑ ΠΛΗΡΟΦΟΡΙΚΗΣ Ανάλυση Αρχείων Καταγραφής σε Υπολογιστικά Νέφη Log File Analysis in Cloud Computing ΜΕΤΑΠΤΥΧΙΑΚΗ ΔΙΑΤΡΙΒΗ του Μαυρίδη Ηλία Πτυχιούχου Πληροφορικής με Εφαρμογές στη Βιοϊατρική, Πανεπιστήμιο Θεσσαλίας Επιβλέπουσα: Ελένη Καρατζά Καθηγήτρια ΘΕΣΣΑΛΟΝΙΚΗ Φεβρουάριος, 2015

2 ΠΕΡΙΛΗΨΗ Αντικείμενο της παρούσας μεταπτυχιακής διατριβής είναι η ανάπτυξη προγραμμάτων ανάλυσης αρχείων καταγραφής, στα δύο υπολογιστικά πλαίσια κατανεμημένης επεξεργασίας Apache Hadoop και Apache Spark. Τα αρχεία καταγραφής αποτελούν σημαντική πηγή πληροφοριών η επεξεργασία των οποίων μπορεί να οδηγήσει σε χρήσιμα συμπεράσματα. Λόγω του υψηλού ρυθμού παραγωγής μηνυμάτων καταγραφής και των πολλών συσκευών που τα παράγουν, ο όγκος των αρχείων καταγραφής είναι πολύ μεγάλος, για αυτό το λόγο η χρήση υπηρεσιών νέφους είναι πολύ χρήσιμη αν όχι αναγκαία. Τα δύο πλαίσια που επιλέχθηκαν να παρουσιαστούν και να συγκριθούν είναι αυτά που παρουσιάζουν το μεγαλύτερο ενδιαφέρον. Το Hadoop αποτελεί τη πιο γνωστή και διαδεδομένη υπολογιστική μηχανή για νέφη, ενώ το Spark είναι ένα σχετικά νέο πλαίσιο που υπόσχεται να καλύψει τις αδυναμίες του Hadoop προσφέροντας καλύτερη απόδοση και νέες δυνατότητες. Σκοπός αυτής της εργασίας είναι να περιγράψει και να συγκρίνει τα δύο υπολογιστικά πλαίσια τονίζοντας τις διαφορές και τις ομοιότητές τους. Για αυτόν τον λόγο υλοποιήθηκαν όμοια προγράμματα και στα δύο πλαίσια ώστε να δειχθεί ο διαφορετικός τρόπος συγγραφής του κώδικα και να αξιολογηθεί η απόδοση του κάθε πλαισίου με συγκεκριμένα παραδείγματα. Επίσης λόγω του δομημένου περιεχομένου των αρχείων καταγραφής, μελετήθηκε η αποθήκευση τους στο κατανεμημένο σύστημα αποθήκευσης αρχείων με τη μορφή πινάκων, όπως θα γινόταν σε μια κοινή σχεσιακή βάση. Ακόμη παρουσιάζεται ο τρόπος με το οποίο η ανάλυση των αρχείων καταγραφής γίνεται με τη χρήση τύπου SQL ερωτημάτων, τα οποία μεταφράζονται αυτόματα σε διεργασίες Hadoop και Spark, χωρίς ο χρήστης να χρειάζεται να γνωρίζει τίποτα για αυτά. Για κάθε πρόγραμμα που αναπτύχθηκε πάρθηκαν διάφορες μετρήσεις με διαφορετικές παραμέτρους, προκειμένου να εξαχθούν ασφαλή συμπεράσματα για την απόδοση των δύο πλαισίων. ii

3 ABSTRACT The Subject of this thesis is the development of log file analysis applications with Apache Hadoop and Apache Spark computing frameworks. The log files are an important source of information that with the proper processing can lead to useful conclusions. Due to the high production rate and the number of devices that create log messages, the use of cloud services for log analysis is very useful. The two frames that were selected to be presented and compared are those with the greatest interest. The Hadoop is the most known and widespread computational engine for cloud computing and the Spark is a relatively new framework, that promises to take care the drawbacks of Hadoop and to offer better performance and new features. The objective of this work is to describe and compare the two computational frameworks, highlighting the differences and similarities. Therefore were implemented similar applications in both frameworks to show the differences on code writing and to evaluate the performance of each frame. Also because the log files have structured content, it was considered appropriate to be saved in distributed file storage system in the form of tables, as it would be in a common relational database. In addition was performed log file analysis with SQL-type queries, which are automatically transformed into Hadoop and Spark tasks. Various measurements were taken for each application, with different parameters in order to extract reliable conclusions about the performance of the two frameworks. iii

4 ΕΥΧΑΡΙΣΤΙΕΣ Αρχικά νιώθω την ανάγκη να ευχαριστήσω την επιβλέπουσα καθηγήτριά κ Καρατζά Ελένη, η οποία όντας καθηγήτριά μου στο μεταπτυχιακό πρόγραμμα σπουδών με ενέπνευσε να ασχοληθώ με τη κατανεμημένη επεξεργασία και τις υπηρεσίες υπολογιστικού νέφους. Η συνεργασία μαζί της ήταν άψογη και η συνεχής βοήθειά της μου επέτρεψε να ξεπεράσω κάθε δυσκολία που συνάντησα. Επιπλέον θα ήθελα να ευχαριστήσω την υπηρεσία ~okeanos, γιατί χωρίς τη διάθεση των πόρων του δεν θα μπορούσε να πραγματοποιηθεί η μεταπτυχιακή διατριβή. Τέλος θέλω να ευχαριστήσω τους γονείς μου για την συμπαράσταση, υποστήριξη και κατανόηση που έδειξαν κατά την εκπόνηση αυτής της εργασίας, αλλά και καθ' όλη τη διάρκεια των σπουδών μου. iv

5 ΠΕΡΙΕΧΟΜΕΝΑ Λίστα Σχημάτων Εισαγωγή Επεξεργασία σε υπολογιστικά νέφη Ανάλυση αρχείων καταγραφής Κίνητρο και περιγραφή της διπλωματικής εργασίας Τα υπολογιστικά πλαίσια Apache Hadoop Η εξέλιξη του Hadoop Το οικοσύστημα του Hadoop Κατανεμημένο σύστημα αρχείων Hadoop MAPREDUCE MAPREDUCE 2 -Yarn Παράδειγμα MAP REDUCE Apache Spark Η εξέλιξη του Spark Το οικοσύστημα του Spark Resilient Distributed Datasets Παράδειγμα Spark Ανάλυση αρχείων καταγραφής Αρχεία καταγραφής Ανάλυση των μηνυμάτων καταγραφής Ανάλυση αρχείων καταγραφής στο νέφος Εγκατάσταση και ρύθμιση νέφους Η υπηρεσία νέφους ~okeanos v

6 4.2 Δημιουργία εικονικών μηχανών στο ~okeanos Εγκατάσταση Hadoop Προϋποθέσεις Εγκατάσταση και ρύθμιση Hadoop Εγκατάσταση Spark Υλοποίηση προγραμμάτων Hadoop MapReduce Τα εργαλεία ανάπτυξης Το αρχείο καταγραφής που χρησιμοποιήθηκε Ανάλυση για την εξαγωγή στατιστικών χρήσης υπηρεσιών Πρόγραμμα εύρεσης κίνησης ανά μέρα Πρόγραμμα εύρεσης δημοφιλέστερων σελίδων Ανάλυση για ανίχνευση και αντιμετώπιση επιθέσεων Πρόγραμμα ανίχνευσης πιθανής επίθεσης DoS Πρόγραμμα εύρεσης ταυτότητας επιτιθέμενου Ανάλυση για την εύρεση και αντιμετώπιση σφαλμάτων Πρόγραμμα εύρεσης και υπολογισμού πλήθους σφαλμάτων Πρόγραμμα εντοπισμού σφαλμάτων Η απόδοση των προγραμμάτων Map/Reduce Υλοποίηση προγραμμάτων Spark Ανάλυση για την εξαγωγή στατιστικών χρήσης υπηρεσιών Πρόγραμμα εύρεσης κίνησης ανά μέρα Πρόγραμμα εύρεσης δημοφιλέστερων σελίδων Ανάλυση για ανίχνευση και αντιμετώπιση επιθέσεων Πρόγραμμα ανίχνευσης πιθανής επίθεσης DoS Πρόγραμμα εύρεσης ταυτότητας επιτιθέμενου Ανάλυση για την εύρεση και αντιμετώπιση σφαλμάτων Πρόγραμμα υπολογισμού πλήθους σφαλμάτων Πρόγραμμα εύρεσης σφαλμάτων vi

7 6.4 Η απόδοση των προγραμμάτων Ανάλυση με τύπου SQL ερωτήματα Εκτέλεση SQL ερωτημάτων στο Hadoop Το Apache Hive Εγκατάσταση Hive Δημιουργία πινάκων Εκτέλεση ερωτημάτων στο Hive Εκτέλεση SQL ερωτημάτων στο Spark Το Spark SQL Εκτέλεση ερωτημάτων στο Spark SQL Συμπεράσματα Σύγκριση απόδοσης προγραμματιστικών πλαισίων Συμπεράσματα, μελλοντική εργασία Αναφορές vii

8 ΛΙΣΤΑ ΣΧΗΜΑΤΩΝ Σχήμα 1: Αρχιτεκτονική HDFS Σχήμα 2: Αντιγραφή του κάθε μπλοκ σε τρεις κόμβους [52] Σχήμα 3: MapReduce στο Hadoop [48] Σχήμα 4: Αναπαράσταση υψηλού επιπέδου MapReduce[49] Σχήμα 5: Από το Hadoop στο Hadoop 2 [50] Σχήμα 6: Σύγκριση αρχιτεκτονικής του Hadoop 1 και Hadoop 2 [57] Σχήμα 7: Οικοσύστημα Spark Σχήμα 8: Μήνυμα καταγραφής Syslog [11] Σχήμα 9: Επίθεση ssh [11] Σχήμα 10: Logging as a Service [11] Σχήμα 11: Τα επιμέρους τμήματα της πλατφόρμας okeanos [67] Σχήμα 12: Δημιουργία δικτύου Σχήμα 13: Δημιουργία νέας εικονικής μηχανής Σχήμα 14: Επιλογή λειτουργικού συστήματος Σχήμα 15: Επιλογή επεξεργαστή, μνήμης και δίσκου Σχήμα 16: Επιλογή δικτύων Σχήμα 17: Επιλογή ονόματος εικονικής μηχανής Σχήμα 18: Έλεγχος και δημιουργία εικονικής μηχανής Σχήμα 19: Οι εικονικές μηχανές του νέφους Σχήμα 20: Δίκτυο του νέφους Σχήμα 21: Δημιουργία κλειδιών ssh Σχήμα 22: Επικοινωνία ssh χωρίς να απαιτείται είσοδος κωδικού Σχήμα 23: Έλεγχος ύπαρξης Java Σχήμα 24: Έλεγχος YARN Σχήμα 25: Εκκίνηση namenode, datanodes, resourcemanager, nodemanagers Σχήμα 26: Διεπαφή Hadoop, προβολή συνδεδεμένων κόμβων slaves Σχήμα 27: Διεπαφή Hadoop, επιτυχής εκτέλεση προγράμματος MapReduce υπολογισμού π Σχήμα 28: Διεπαφή Spark, προβολή συνδεδεμένων κόμβων Σχήμα 29: Διεπαφή Spark, επιτυχής εκτέλεση υπολογισμού π με πρόγραμμα Spark standalone.49 Σχήμα 30: Διεπαφή Hadoop, επιτυχής εκτέλεση προγράμματος Spark on Yarn υπολογισμού π. 49 1

9 Σχήμα 31: Δημιουργία Maven Project Σχήμα 32: Πρόσθεση εξαρτήσεων στο maven java project Σχήμα 33: Πραγματικά μηνύματα καταγραφής Apache web access log Σχήμα 34: Αποστολή αρχείου καταγραφή στο HDFS Σχήμα 35: Διεπαφή HDFS πληροφορίες για το αρχείο καταγραφής Σχήμα 36: Αιτήσεις στο σύστημα ανά ημέρα Σχήμα 37:Οι σελίδες php που δέχονται τα περισσότερα ερωτήματα Σχήμα 38: Κατανεμημένη επίθεση άρνησης παροχής υπηρεσιών [79] Σχήμα 39: Χρονικές στιγμές με ύποπτο αριθμό αιτημάτων Σχήμα 40: Εκτέλεση προγράμματος μέτρησης σφαλμάτων Σχήμα 41: Αποτελέσματα εκτέλεσης προγράμματος μέτρησης σφαλμάτων Σχήμα 42: Ιστόγραμμα εμφάνισης σφαλμάτων Σχήμα 43: Αρχεία που προκαλούν πάνω από 1000 σφάλματα Σχήμα 44: Χρόνοι εκτέλεσης προγραμμάτων MapReduce για αρχείο εισόδου 1.1 GB Σχήμα 45: Χρόνοι εκτέλεσης προγραμμάτων MapReduce για αρχείο εισόδου 4,4 GB Σχήμα 46 Χρόνοι εκτέλεσης προγραμμάτων MapReduce για αρχείο εισόδου 11 GB Σχήμα 47: Αποτελέσματα εκτέλεσης προγράμματος Spark Σχήμα 48: Αποτελέσματα εκτέλεσης προγράμματος εύρεσης δημοφιλέστερων σελίδων σε Spark Σχήμα 49: Αποτελέσματα εκτέλεσης προγράμματος εύρεσης επιθέσεων DoS σε Spark Σχήμα 50: Αποτελέσματα εκτέλεσης προγράμματος εύρεσης επιθέσεων σφαλμάτων σε Spark. 90 Σχήμα 51: Αποτελέσματα εκτέλεσης προγράμματος εύρεσης σφαλμάτων 404 με εμφάνιση πάνω από 1000 φορές σε Spark Σχήμα 52: Χρόνοι εκτέλεσης προγραμμάτων Spark για αρχείο εισόδου 1.1 GB Σχήμα 53: Χρόνοι εκτέλεσης προγραμμάτων Spark για αρχείο εισόδου 4.4 GB Σχήμα 54: Χρόνοι εκτέλεσης προγραμμάτων Spark για αρχείο εισόδου 11 GB Σχήμα 55: Χρόνοι εκτέλεσης προγραμμάτων σε yarn και standalone Σχήμα 56: Εκκίνηση Hive Σχήμα 57: Δημιουργία πίνακα στο Hive Σχήμα 58: Εκτέλεση ερωτήματος SQL επιστροφής 20 πρώτων εγγραφών Σχήμα 59: Εκτέλεση ερωτήματος SQL εύρεσης πλήθους λαθών στο Hive Σχήμα 60: Εκτέλεση ερωτήματος SQL εύρεσης αιτήσεων που προκαλούν πάνω από χίλια σφάλματα 404 σε Hive Σχήμα 61: Μέτρηση σφαλμάτων με Hive και java MapReduce Σχήμα 62: Εκκίνηση Spark SQL Σχήμα 63: Εκτέλεση ερωτημάτων SQL εύρεσης πλήθους σφαλμάτων στο Spark SQL

10 Σχήμα 64: Εκτέλεση ερωτήματος SQL εύρεσης αιτήσεων που προκαλούν πάνω από χίλια σφάλματα 404 σε SQL Σχήμα 65: Σύγκρισης απόδοσης Hadoop Hive και Spark SQL Σχήμα 66: Συγκριτικοί χρόνοι εκτέλεσης προγράμματος μέτρησης σφαλμάτων Σχήμα 67: Συγκριτικοί χρόνοι εκτέλεσης προγράμματος εντοπισμού σφαλμάτων

11 1 ΕΙΣΑΓΩΓΗ 1.1 ΕΠΕΞΕΡΓΑΣΙΑ ΣΕ ΥΠΟΛΟΓΙΣΤΙΚΑ ΝΕΦΗ Μια νέα τεχνολογία που παρουσιάζει ραγδαία ανάπτυξη τα τελευταία χρόνια είναι τα υπολογιστικά νέφη. Ο όρος υπολογιστικά νέφη περιλαμβάνει την ανάπτυξη ομάδων απομακρυσμένων διακομιστών που σε συνδυασμό με το κατάλληλο λογισμικό, επιτρέπει την κατανεμημένη αποθήκευση δεδομένων και απομακρυσμένη πρόσβαση σε υπηρεσίες ή υπολογιστικούς πόρους. Τα υπολογιστικά νέφη μπορεί να είναι δημόσια, ιδιωτικά ή υβριδικά, ενώ επίσης μπορούν να διαχωριστούν με βάση το μοντέλο παροχής υπηρεσιών σε Software as a Service (SaaS), Platform as a Service (PaaS) και Infrastructure as a Service (IaaS) [1] [2]. H Google είναι από τις πρώτες εταιρίες που έχει αναπτύξει ένα σύστημα για την επεξεργασία δεδομένων στο νέφος και έχει δημοσιεύσει σχετικές εργασίες για τον τρόπο λειτουργίας του. Το σύστημα που ανέπτυξε η Google αρχικά είχε τρία κύρια στοιχεία, το μοντέλο προγραμματισμού MapReduce, το σύστημα αρχείων Google (GFS) και το BigTable. Το MapReduce [4], βασίζεται στην δημιουργία μιας συνάρτησης Map που επεξεργάζεται τα δεδομένα εισόδου και παράγει ένα σύνολο ενδιάμεσων ζευγών κλειδιού-τιμής και στη δημιουργία μιας συνάρτησης Reduce, που συγχωνεύει όλες τις ενδιάμεσες τιμές που συνδέονται με το ίδιο ενδιάμεσο κλειδί [4]. Το σύστημα αρχείων της Google είναι ένα επεκτάσιμο, κατανεμημένο σύστημα αρχείων που δεν απαιτεί εξειδικευμένο υλικό, μπορεί να υποστηρίξει 4

12 απαιτητικές εφαρμογές που τρέχουν σε κατανεμημένα συστήματα, διασφαλίζοντας ανοχή σε σφάλματα (fault tolerance) και προσφέροντας υψηλή απόδοση [3]. Στο σύστημα της Google βασίστηκε και το πιο δημοφιλές πλαίσιο ανοιχτού κώδικα για επεξεργασία σε υπολογιστικά νέφη, το Hadoop. To Hadoop [5] ανήκει και αναπτύσσεται από τον οργανισμό ανοιχτού κώδικα Apache [6] με σκοπό την αξιόπιστη, κλιμακούμενη, κατανεμημένη επεξεργασία. Το Apache Hadoop είναι ένα πλαίσιο που επιτρέπει την κατανεμημένη επεξεργασία μεγάλων συνόλων δεδομένων σε συστάδες υπολογιστών με τη χρήση απλών μοντέλων προγραμματισμού [5]. Έχει σχεδιαστεί ώστε να μπορεί να λειτουργεί από λίγους διακομιστές μέχρι χιλιάδες, αξιοποιώντας τις τοπικές δυνατότητες που έχει κάθε μηχάνημα για επεξεργασία και αποθήκευση δεδομένων. Επίσης παρέχει υψηλή διαθεσιμότητα, καθώς μπορεί να ανιχνεύει και να χειρίζεται τις αποτυχίες. Το Hadoop χρησιμοποιούν εταιρίες όπως οι Facebook, Yahoo, Adobe, Twitter, ebay, IBM, Linkedin, Spotify [7] κτλ. Το Hadoop προσφέρει υψηλή επεκτασιμότητα και ανοχή σε σφάλματα, ωστόσο επειδή γράφει και διαβάζει πολλές φορές στο κατανεμημένο σύστημα αρχείων (Hadoop Distributed File System - HDFS) μπορεί να είναι πολύ αργό για ορισμένες διαδικασίες. Για να ξεπεραστεί αυτό το πρόβλημα, προτάθηκε ένα νέο πλαίσιο κατανεμημένης επεξεργασίας που ονομάζεται Apache Spark [8]. To Spark αναπτύχθηκε από το AMPLab [10] του UC Berkeley και σε αντίθεση με το Hadoop, χρησιμοποιεί τη κύρια μνήμη πετυχαίνοντας έως και 100 φορές υψηλότερη απόδοση για ορισμένες εφαρμογές [9]. Δίνοντας τη δυνατότητα αποθήκευσης των δεδομένων στη μνήμη και επιτρέποντας τις επαναλαμβανόμενες ερωτήσεις σε αυτά τα δεδομένα, το Spark είναι κατάλληλο για αλγόριθμους μηχανικής μάθησης [8]. Το Spark μπορεί επίσης να λειτουργήσει πάνω στο κατανεμημένο σύστημα αρχείων του Hadoop και έχει τέσσερα κύρια εργαλεία υψηλού επιπέδου, το Spark SQL για SQL τύπου ερωτήματα, την MLlib για μηχανική μάθηση, το GraphX για γράφους, και το Spark Streaming για επεξεργασία ροής δεδομένων [10]. 5

13 1.2 ΑΝΑΛΥΣΗ ΑΡΧΕΙΩΝ ΚΑΤΑΓΡΑΦΗΣ Κάθε υπολογιστικό σύστημα όταν είναι ενεργό συλλέγει πληροφορίες που αφορούν διάφορες λειτουργίες του συστήματος, αυτές οι πληροφορίες αποθηκεύονται σε ειδικά αρχεία που ονομάζονται αρχεία καταγραφής (log files). Οι πληροφορίες που αποθηκεύονται στα αρχεία καταγραφής περιέχουν στοιχεία για τη κάθε διεργασία που τρέχει στο σύστημα και καταγράφουν τη κατάστασή του, τη χρονική στιγμή που εκτελείται και διάφορες άλλες πληροφορίες που είναι ανάλογες με τη διεργασία που εκτελείται [11]. Επίσης σε ειδικά αρχεία καταγραφής, αποθηκεύονται στοιχεία που αφορούν τη πρόσβαση στο σύστημα, αλλαγές σε υπηρεσίες, καθώς και κάθε συναλλαγή με το σύστημα. Τα δεδομένα που αποθηκεύονται στα αρχεία καταγραφής μπορούν να ρυθμιστούν και να τροποποιηθούν από τον διαχειριστή του συστήματος [12], διαμορφώνοντας έτσι το επιθυμητό επίπεδο καταγραφής. Η ανάλυση των αρχείων καταγραφής μπορεί να είναι εξαιρετικά πολύτιμη για τους διαχειριστές του συστήματος και τους υπεύθυνους ασφαλείας [13], καθώς αποτελούν μια καλή πηγή πληροφοριών για την ανάλυση των σφαλμάτων στο σύστημα και τη διατήρηση της ασφάλειας του [21]. Ωστόσο μπορεί να γίνει εύκολα κατανοητό ότι για κάθε σύγχρονο υπολογιστικό σύστημα λογικού μεγέθους, τα αρχεία καταγραφής μπορεί να αποκτήσουν γρήγορα εξαιρετικά μεγάλο όγκο[15]. Λόγω του μεγάλου όγκου των αρχείων καταγραφής και λόγω του υψηλού ρυθμού παραγωγής τους, είναι δύσκολο να γίνει άμεσα η επεξεργασία και η εξαγωγή πληροφοριών. Χαρακτηριστικό παράδειγμα, αποτελεί μια εταιρεία των ΗΠΑ που χρειάστηκε 18 μήνες για να παρατηρήσει ότι χάκερ είχαν εισέλθει στο συστήματα της [25].Για αυτόν τον λόγο αλλά και λόγω της φύσης των διεργασιών που γίνονται κατά την ανάλυση των αρχείων καταγραφής, έχει μελετηθεί η χρήση υπηρεσιών υπολογιστικού νέφους και έχουν δημοσιευτεί σχετικές εργασίες [16], [17], [18], [19], [20], [21], [22], [23], [24]. 6

14 1.3 ΚΙΝΗΤΡΟ ΚΑΙ ΠΕΡΙΓΡΑΦΗ ΤΗΣ ΔΙΠΛΩΜΑΤΙΚΗΣ ΕΡΓΑΣΙΑΣ Πολλές εταιρίες στον κόσμο βασίζονται στην ανάλυση των αρχείων καταγραφής για την καλύτερη διαχείριση και ασφάλεια των συστημάτων τους, αλλά και για την παροχή υπηρεσιών που ανταποκρίνονται στις σύγχρονες ανάγκες. Επίσης πολλοί [7] έχουν καταφύγει στις υπηρεσίες υπολογιστικού νέφους για να ανταποκριθούν στις ανάγκες επεξεργασίας μεγάλου όγκου δεδομένων. Τα αρχεία καταγραφής είναι και αυτά δεδομένα, που η επεξεργασία τους μπορεί να γίνει αποτελεσματικότερα αξιοποιώντας τις δυνατότητες του υπολογιστικού νέφους. Αυτή η εργασία έχει σκοπό να ερευνήσει τις δυνατότητες του ευρέως χρησιμοποιημένου πλαισίου Hadoop για την ανάλυση αρχείων καταγραφής. Επίσης θα ερευνηθεί το νέο πλαίσιο Spark που έχει εμφανιστεί τα τελευταία δύο χρόνια και υπόσχεται μέχρι εκατό φορές καλύτερη απόδοση (σε ορισμένες περιπτώσεις) σε σχέση με το Hadoop. Θα υλοποιηθούν όμοια προγράμματα και στα δύο πλαίσια που θα εκτελούν βασικές εργασίες για την ανάλυση αρχείων καταγραφής, θα πραγματοποιηθούν μετρήσεις με διάφορες εισόδους και παραμέτρους, προκειμένου να εξαχθούν ασφαλή συμπεράσματα. Επιπλέον θα αξιολογηθεί και η χρήση πρόσθετων εργαλείων που προσφέρουν δυνατότητα δημιουργίας κατανεμημένων βάσεων δεδομένων, σύνταξης και εκτέλεσης τύπου SQL ερωτημάτων και βασίζονται στο Hadoop και στο Spark. 7

15 2 ΤΑ ΥΠΟΛΟΓΙΣΤΙΚΑ ΠΛΑΙΣΙΑ Σε αυτό το κεφάλαιο θα περιγραφούν τα δύο υπολογιστικά πλαίσια τα οποία θα χρησιμοποιηθούν για την εκτέλεση των εργασιών στο νέφος. Για κάθε πλαίσιο θα περιγραφεί η εξελικτική του πορεία και θα παρουσιαστούν οι πρόσθετες εφαρμογές που απαρτίζουν το οικοσύστημα του καθενός. Επιπλέον θα αναλυθεί ο τρόπος που λειτουργεί ο πυρήνας τους, η μέθοδος ανάπτυξης εφαρμογών για το κάθε πλαίσιο και θα δοθεί ένα απλό παράδειγμα προκειμένου να δειχθούν στη πράξη τα όσα περιεγράφηκαν. 2.1 APACHE HADOOP To Apache Hadoop [26] είναι ένα πλαίσιο για την εκτέλεση εφαρμογών σε cluster πολλών κοινών υπολογιστών. To Hadoop εφαρμόζει ένα υπολογιστικό μοντέλο που ονομάζεται Map/Reduce [27], σύμφωνα με το οποίο το πρόγραμμα που θα εκτελεστεί χωρίζεται σε πολλά μικρά μέρη, καθένα από τα οποία θα εκτελεστεί σε κάποιο κόμβο του cluster. Επιπλέον, παρέχει ένα κατανεμημένο σύστημα αποθήκευσης αρχείων όπου τα δεδομένα αποθηκεύονται κατανεμημένα στους κόμβους του cluster. Το Hadoop είναι σχεδιασμένο έτσι ώστε οι βλάβες των κόμβων να αντιμετωπίζονται αυτόματα από το πλαίσιο, προσφέροντας υψηλή διαθεσιμότητα. 8

16 2.1.1 Η εξέλιξη του Hadoop Το Hadoop δημιουργήθηκε από τον Doug Cutting [28], τον δημιουργό της ευρέως χρησιμοποιούμενης βιβλιοθήκης αναζήτησης κειμένου Apache Lucene. Έχει τις ρίζες του στο Apache Nutch, το οποίο είναι μια μηχανή αναζήτησης ανοιχτού κώδικα που αποτελεί μέρος του Lucene. To Nutch ξεκίνησε το 2002, αλλά γρήγορα συνειδητοποίησαν ότι η αρχιτεκτονική του δεν θα μπορούσε να υποστηρίξει τα δισεκατομμύρια των σελίδων του διαδικτύου. Χρήσιμη βοήθεια αποτέλεσε μια εργασία που δημοσιεύτηκε το 2003 και περιέγραφε την αρχιτεκτονική του κατανεμημένου συστήματος αρχείων της Google, το Google Distributed Filesystem - GFS[3]. Έτσι το 2004, ξεκίνησαν την ανάπτυξη ενός συστήματος κατανεμημένων αρχείων ανοικτού κώδικα, το Nutch Distributed Filesystem - NDFS. Το 2004, η Google δημοσίευσε μια νέα εργασία [4], η οποία παρουσίαζε το MapReduce. Στις αρχές του 2005, οι προγραμματιστές του Nutch είχαν γράψει τη πρώτη υλοποίηση του MapReduce που λειτουργούσε, ενώ από τα μέσα του έτους όλοι οι σημαντικοί αλγόριθμοι του Nutch είχαν γραφτεί ώστε να τρέχουν με MapReduce και NDFS. Τον Φεβρουάριο του 2006 ανεξαρτητοποιήθηκε ένα τμήμα του Nutch και δημιουργήθηκε το Hadoop. Την ίδια περίοδο, ο Doug Cutting εντάχθηκε στη Yahoo, η οποία δημιούργησε μια ειδική ομάδα για να μετατρέψει το Hadoop σε ένα σύστημα που μπορούσε να ανταπεξέλθει στον όγκο των δεδομένων που υπάρχουν στο διαδίκτυο. Το Φεβρουάριο του 2008 [30], η Yahoo ανακοίνωσε ότι η αναζήτηση της βασιζόταν σε πυρήνες Hadoop. Τον Ιανουάριο του 2008, το Hadoop έγινε έργο υψηλού επιπέδου στον οργανισμό ανοιχτού κώδικα Apache. Τον Απρίλιο του ίδιου έτους, το Hadoop έσπασε το παγκόσμιο ρεκόρ ταξινόμησης, ταξινομώντας ένα TeraByte δεδομένων σε 209 δευτερόλεπτα. Τον Νοέμβριο, η Google ανέφερε ότι το δικό της MapReduce ταξινόμησε 1 TeraByte σε 68 δευτερόλεπτα [31] και τον επόμενο χρόνο η Yahoo μείωσε το χρόνο ταξινόμησης 1 TeraByte σε 62 δευτερόλεπτα. Από τότε, το Hadoop έχει υιοθετηθεί από πολλές επιχειρήσεις [7]. Ωστόσο για cluster με περισσότερους από κόμβους, το σύστημα MapReduce είχε πρόβλημα επεκτασιμότητας. Έτσι το 2010 μια ομάδα από τη Yahoo άρχισε να σχεδιάζει την επόμενη γενιά του MapReduce [32]. Το αποτέλεσμα ήταν το YARN (Yet Another Resource Negotiator) [33], ή MapReduce 2.0. Το YARN άλλαξε τον τρόπο διαχείρισης των πόρων που έκανε το Hadoop ξεπερνώντας έτσι τα προβλήματα που είχαν προκύψει, ενώ επίσης έκανε το Hadoop ικανό να υποστηρίξει ένα νέο ευρύτερο φάσμα εφαρμογών με νέες δυνατότητες. 9

17 2.1.2 Το οικοσύστημα του Hadoop Αν και το Hadoop είναι περισσότερο γνωστό για το MapReduce και το HDFS, ο όρος χρησιμοποιείται επίσης για μια οικογένεια συναφών προγραμμάτων που αποτελούν μέρος της υποδομής για κατανεμημένη επεξεργασία και επεξεργασία μεγάλης κλίμακας δεδομένων. Τα περισσότερα από αυτά τα προγράμματα που ανήκουν στο οικοσύστημα του Hadoop είναι υπό την αιγίδα της Apache και τα πιο γνωστά από αυτά είναι [5]: Ambari [34]: Ένα web-based εργαλείο για την τροφοδότηση, διαχείριση και παρακολούθηση των κόμβων του Hadoop. Υποστηρίζει τα Hadoop HDFS, Hadoop MapReduce, Hive, HCatalog, HBase, Zookeeper, Oozie, Pig και Sqoop. Avro [35]: Ένα σύστημα σειριοποίησης δεδομένων. Cassandra [36]: Μια επεκτάσιμη (scalable) multi-master βάση δεδομένων χωρίς σημείο αποτυχίας (single point of failure). Chukwa [37]: Ένα σύστημα συλλογής δεδομένων για τη διαχείριση μεγάλων κατανεμημένων συστημάτων. HBase [38]: Μια επεκτάσιμη, κατανεμημένη βάση δεδομένων που υποστηρίζει δομημένη αποθήκευση δεδομένων για μεγάλους πίνακες. Hive [39]: Μια αποθήκη δεδομένων (data warehouse) που παρέχει τη δυνατότητα περιληπτικής παρουσίασης των δεδομένων (data summarization) και δυνατότητα ad hoc ερωτημάτων. Mahout [40]: Μια επεκτάσιμη βιβλιοθήκη μηχανικής μάθησης και εξόρυξης δεδομένων. Pig [41]: Μια υψηλού επιπέδου γλώσσα ροής δεδομένων και πλαίσιο εκτέλεσης παράλληλου προγραμματισμού. Spark [42]: Μια γρήγορη και γενικού σκοπού υπολογιστική μηχανή για το Hadoop. Το Spark προσφέρει ένα απλό και εύχρηστο μοντέλο προγραμματισμού που υποστηρίζει ένα ευρύ φάσμα εφαρμογών, συμπεριλαμβανομένου των ETL, μηχανικής μάθησης, επεξεργασίας ροής δεδομένων, και επεξεργασία γράφων. Tez [43]: Ένα γενικευμένο πλαίσιο προγραμματισμού, για το Hadoop YARN, το οποίο παρέχει μια ισχυρή και ευέλικτη υπολογιστική μηχανή για την επεξεργασία ροής δεδομένων. Zookeeper [44]: Μια υπηρεσία συντονισμού υψηλής απόδοσης για κατανεμημένες εφαρμογές. 10

18 2.1.3 Κατανεμημένο σύστημα αρχείων Hadoop To Hadoop Distributed File System αποτελεί το κατανεμημένο σύστημα αποθήκευσης αρχείων του Hadoop [45]. Έχει σχεδιαστεί για να υποστηρίζει την αποθήκευση μεγάλου όγκου δεδομένων (TeraBytes ή PetaBytes), και να παρέχει πρόσβαση σε αυτά τα δεδομένα, σε πολλούς χρήστες που συνδέονται μέσω ενός δικτύου. To HDFS έχει υλοποιηθεί ως ένα σύστημα αρχείων με μπλοκ. Όπως δείχνει το Σχήμα 1, τα αρχεία διαχωρίζονται σε μπλοκ καθορισμένου μεγέθους και αποθηκεύονται στους κόμβους του Hadoop cluster [45]. Ένα αρχείο μπορεί να αποτελείται από διάφορα μπλοκ, τα οποία είναι αποθηκευμένα σε διαφορετικούς κόμβους, έτσι η πρόσβαση σε ένα αρχείο συνήθως απαιτεί πρόσβαση σε πολλούς κόμβους. Με αυτόν τον τρόπο δίνεται η δυνατότητα αποθήκευσης αρχείων που μπορεί να είναι πολύ μεγαλύτερα από τη χωρητικότητα του δίσκου του κάθε κόμβου. Τα αρχεία που αποθηκεύονται στο HDFS είναι του μοντέλου write-once and read-many, ωστόσο αυτό δεν ισχύει για τα μεταδεδομένα που αφορούν τα αρχεία. Για αυτό τον λόγο στο HDFS υπάρχει ένας αφιερωμένος κόμβος, που ονομάζεται NameNode, και αποθηκεύει όλα τα μεταδεδομένα για το σύστημα αρχείων του cluster και φροντίζει να είναι πάντα ενημερωμένα. Αυτό σημαίνει ότι υλοποιείται μια αρχιτεκτονική master/slave όπου ο NameNode είναι ο master, ο οποίος διαχειρίζεται το χώρο ονομάτων του συστήματος αρχείων και καθορίζει την πρόσβαση των πελατών στα αρχεία. Ενώ οι slaves ονομάζονται DataNodes και είναι υπεύθυνοι για την αποθήκευση των δεδομένων και την εκτέλεση ενεργειών που τους υπαγορεύει ο NameNode. Σχήμα 1: Αρχιτεκτονική HDFS. 11

19 Η σχεδίαση του HDFS έγινε με τέτοιο τρόπο ώστε τα μεταδεδομένα που αντιστοιχούν σε κάθε αρχείο να είναι μικρά σε μέγεθος, προκειμένου ο NameNode να μπορεί να αποθηκεύει όλα τα μεταδεδομένα στην κύρια μνήμη, επιτρέποντας έτσι γρήγορη τυχαία προσπέλαση. Για να διευκολυνθεί αυτό, το προεπιλεγμένο μέγεθος ενός μπλοκ είναι 64 MB που είναι τάξεις μεγέθους μεγαλύτερο από το μέγεθος μπλοκ της πλειοψηφίας των περισσότερων συστημάτων αρχείων που χρησιμοποιούν μπλοκ. Ο ρόλος του NameNode είναι ιδιαίτερα σημαντικός και πιθανή βλάβη θα σήμαινε καταστροφή του συστήματος. Για την αποφυγή μιας τέτοιας κατάστασης το Hadoop παρέχει δύο μηχανισμούς [29]. Ο πρώτος είναι να δημιουργηθούν αντίγραφα ασφαλείας των μεταδεδομένων σε διάφορα συστήματα αρχείων. Ο δεύτερος τρόπος είναι η ύπαρξη ενός secondary NameNode, που παρά την ονομασία του δεν ενεργεί ως NameNode. Ο κύριος ρόλος του είναι να συγχωνεύει σε τακτά χρονικά διαστήματα την εικόνα του namespace με το αρχείο Edit Log που καταγράφει τις αλλαγές των μεταδεδομένων, ώστε το Edit Log να μην γίνει πολύ μεγάλο. Ο secondary NameNode τρέχει συνήθως σε ένα ξεχωριστό φυσικό μηχάνημα, γιατί είναι υπολογιστικά απαιτητικό. Το αντίγραφο του namespace που κρατά μπορεί να χρησιμοποιηθεί σε περίπτωση αποτυχίας του NameNode. Επίσης εκτός από τον NameNode, μπορεί να πάθει βλάβη και κάποιος DataNode, με αποτέλεσμα τα μπλοκ που ήταν αποθηκευμένα σε αυτόν να μην είναι πλέον προσβάσιμα. Για να αποφευχθεί αυτό το πρόβλημα, το HDFS αντιγράφει (από προεπιλογή) το κάθε μπλοκ και σε άλλους τρεις κόμβους (Σχήμα 2) [52]. Το προεπιλεγμένο μέγεθος μπλοκ και ο παράγοντας αντιγραφής καθορίζονται από την αρχική ρύθμιση του Hadoop, αλλά μπορούν στη συνέχεια να αλλάξουν. Κάθε εφαρμογή μπορεί να καθορίσει το μέγεθος μπλοκ, τον αριθμό των αντιγράφων, και τον παράγοντα αντιγραφής για ένα συγκεκριμένο αρχείο κατά τη στιγμή της δημιουργίας του. Όταν ένας πελάτης γράφει δεδομένα σε ένα αρχείο HDFS, αυτά τα δεδομένα πρώτα γράφονται σε ένα τοπικό αρχείο. Όταν το τοπικό αρχείο σχηματίσει ένα πλήρες μπλοκ δεδομένων, ο πελάτης συμβουλεύεται το NameNode για να μάθει τη λίστα με τους DataNodes που έχουν επιλεχθεί για να αποθηκεύσουν αντίγραφα αυτού του μπλοκ. Ο πελάτης έπειτα γράφει το μπλοκ δεδομένων από το τοπικό χώρο στο πρώτο DataNode. Ο DataNode αποθηκεύει τα ληφθέντα μπλοκ στο τοπικό του σύστημα αρχείων, και στη συνέχεια το προωθεί στον επόμενο DataNode που είναι στη λίστα, η διαδικασία επαναλαμβάνεται μέχρι το μπλοκ να φτάσει και στο τελευταίο DataNode της λίστας. 12

20 Σχήμα 2: Αντιγραφή του κάθε μπλοκ σε τρεις κόμβους [52]. Ένα σημαντικό χαρακτηριστικό στην αντιγραφής των δεδομένων είναι το Rack Awareness [52]. Συνήθως οι μεγάλες εφαρμογές του HDFS τρέχουν σε ένα cluster υπολογιστών που εκτείνονται σε πολλά racks. Αυτό που ισχύει συνήθως είναι ότι το εύρος ζώνης του δικτύου μεταξύ συσκευών στο ίδιο rack, είναι μεγαλύτερό από το εύρος ζώνης του δικτύου μεταξύ διαφόρων racks. Ο NameNode καθορίζει σε ποιο rack είναι ο κάθε DataNode με τη διαδικασία Hadoop Rack Awareness [45]. Μια απλή πολιτική που χρησιμοποιείται, είναι να τοποθετούνται αντίγραφα σε διαφορετικά racks. Αυτή η πολιτική αποτρέπει την απώλεια δεδομένων όταν ένα ολόκληρο rack πάθει βλάβη. Επίσης με αυτόν τον τρόπο κατανέμονται ομοιόμορφα τα αντίγραφα στο cluster, αλλά μειώνεται η απόδοση της εγγραφής στο σύστημα. Μια βέλτιστη αξιοποίηση του Hadoop Rack Awareness είναι να μειωθεί ο όγκος των εγγραφών μεταξύ των racks, χρησιμοποιώντας λιγότερα racks από τον αριθμό των αντιγράφων. Για παράδειγμα, όταν ο παράγοντας αντιγραφής είναι τρία, δύο αντίγραφα τοποθετούνται σε ένα rack, και το τρίτο σε ένα διαφορετικό rack. Επίσης αξίζει να σημειωθεί, ότι για να ελαχιστοποιηθεί η συνολική χρησιμοποίηση εύρους ζώνης και ο χρόνος ανάγνωσης, το HDFS προσπαθεί να απαντάει σε ένα αίτημα ανάγνωσης, με ένα αντίγραφο που είναι πιο κοντά στον αναγνώστη. 13

21 2.1.4 MAPREDUCE Το MapReduce είναι ένα batch-based, κατανεμημένο υπολογιστικό πλαίσιο που παρουσιάστηκε από τη σχετική εργασία που δημοσίευσε η Google [4]. Επιτρέπει την παράλληλη εκτέλεση εργασιών σε ένα μεγάλο όγκο δεδομένων, όπως για παράδειγμα, επιτρέπει την επεξεργασία μεγάλου όγκου αρχείων καταγραφής σε συνδυασμό με OLTP, για την εξαγωγή συμπερασμάτων για το πώς οι χρήστες αλληλοεπιδρούν με κάποια ιστοσελίδα. Αυτό το είδος επεξεργασίας, θα μπορούσε να χρειαστεί μέρες ή και περισσότερο αν γινόταν με κλασσικό σειριακό προγραμματισμό, ενώ χρησιμοποιώντας MapReduce σε ένα Hadoop cluster μπορεί να μειωθεί σε λίγα λεπτά. Όπως στο HDFS και στο MapReduce υπάρχουν δύο ειδών κόμβοι, ο JobTracker (master) και οι TaskTrackers (slaves). Σε κάθε MapReduce cluster υπάρχει ένας JobTracker ο οποίος καθορίζει ποια αρχεία θα επεξεργαστούν, είναι υπεύθυνος για την ανάθεση κόμβων σε διάφορες εργασίες, καθώς και την παρακολούθηση όλων των εκτελούμενων διεργασιών [46]. Οι TaskTrackers τρέχουν τις διεργασίες που τους ανατίθενται από τον JobTracker. Σχήμα 3: MapReduce στο Hadoop [48]. Στο Σχήμα 3 φαίνεται η διαδικασία που ακολουθείται για να εκτελεστεί μια MapReduce διεργασία στο Hadoop [46]. Αρχικά ο JobClient υποβάλει τη MapReduce διεργασία, έπειτα ο 14

22 JobTracker αρχικοποιεί τη διεργασία. Ο κάθε TaskTracker επικοινωνεί περιοδικά με τον JobTracker και τον ενημερώνει για τη κατάστασή του. Σύμφωνα με αυτές τις πληροφορίες ο JobTracker αναθέτει διεργασίες σε κάθε TaskTracker. Αν ο JobTracker δεν λάβει ενημέρωση από κάποιον TaskTracker τότε δε του αναθέτει άλλες εργασίες, και οι πιθανές εργασίες που έτρεχαν σε αυτόν και δεν έχουν επιστρέψει αποτέλεσμα, ανατίθενται σε άλλους TaskTrackers, πετυχαίνοντας έτσι ανοχή σε σφάλματα (fault-tolerance). Για να εκτελέσει μια διεργασία, ο TaskTracker ανακτά τα απαραίτητα αρχεία από το HDFS και εκκινεί το Java Virtual Machine (JVM), στο οποίο θα εκτελεστεί η εργασία. Σχήμα 4: Αναπαράσταση υψηλού επιπέδου MapReduce[49]. Στο Σχήμα 4 απεικονίζεται η διαδικασία MapReduce σε υψηλό επίπεδο. Όπως έχει προαναφερθεί το MapReduce έχει δύο κύριες φάσεις το Map και το Reduce. Κατά τη φάση του Map, ο κάθε TaskTracker ξεκινά μια διεργασία Mapper για κάθε είσοδο που του έχει ανατεθεί. Μια διεργασία Mapper διαβάζει τα αρχεία εισόδου και εφαρμόζει μια συνάρτηση η οποία δίνει σαν έξοδο τα ενδιάμεσα ζεύγη (κλειδί, τιμή), τα οποία γράφονται στον τοπικό δίσκο του κόμβου. Οι έξοδοι που παράγει η συνάρτηση Map χωρίζονται σε partitions που αντιστοιχούν στους Reducers στους οποίους θα αποσταλούν πριν γραφτούν στον δίσκο. Ο Partitioner [53] θα βάλει όλα τα ζεύγη (κλειδί, τιμή) με το ίδιο κλειδί (ίδιο χρώμα στο Σχήμα 4) στο ίδιο partition. Η φάση της μείωσης έχει με τη σειρά τις δύο κύριες διαδικασίες: το Shuffle (ανακάτεμα) και το Reduce (μείωση). Μόλις ένας Mapper τελειώσει, κάθε Reducer ξεκινά να αντιγράφει τo partition της συγκεκριμένης Map διεργασίας με τις ενδιάμεσες τιμές (Shuffling). Μετά την ολοκλήρωση του Shuffling, οι είσοδοι σε κάθε Reducer που έχουν το ίδιο ενδιάμεσο κλειδί (ίδιο χρώμα στο Σχήμα 4) συγχωνεύονται και δημιουργούν ένα νέο ζεύγος (κλειδί, τιμές []), όπου 15

23 «τιμές []» σημαίνει μία ακολουθία τιμών. Στη συνέχεια εφαρμόζεται η συνάρτηση Reduce και οι έξοδοι που παράγονται αποθηκεύονται στο HDFS MAPREDUCE 2 -Yarn Το YARN (Yet Another Resource Negotiator) [32] δημιουργήθηκε από τη Yahoo το 2010, με σκοπό να λύσει το πρόβλημα επεκτασιμότητας που είχε το MapReduce για cluster που είχαν περισσότερους από κόμβους. Για να αντιμετωπίσει το πρόβλημα επεκτασιμότητας διαχωρίζει τις αρμοδιότητες χρονοδρομολόγησης των εργασιών στους TaskTrackers και της παρακολούθησης των διεργασιών που μέχρι τώρα ήταν υπεύθυνος ο JobTracker [50]. Δηλαδή δημιουργούνται δύο διαφορετικοί daemons, ένας που διαχειρίζεται τους πόρους στο cluster και ένας application master που ελέγχει το κύκλο ζωής της εφαρμογής στο cluster [50]. Η βασική ιδέα είναι ότι ο application master διαπραγματεύεται με τον διαχειριστή πόρων για τους πόρους του cluster, -οι οποίοι εκφράζονται με τον όρο container, όπου κάθε container έχει όριο μέχρι κάποια μνήμηκαι μετά εκτελεί τις διεργασίες του συγκεκριμένου προγράμματος σε αυτά τα containers. Το YARN είναι πιο γενικό από το MapReduce (Σχήμα 5), στην πραγματικότητα το MapReduce είναι μια YARN εφαρμογή. Υπάρχουν και άλλες εφαρμογές YARN [51], που μπορούν να τρέχουν παράλληλα με το MapReduce, κάτω από τον ίδιο διαχειριστή πόρων. Σχήμα 5: Από το Hadoop στο Hadoop 2 [50]. Στο Σχήμα 6 φαίνονται οι διαφορές στην αρχιτεκτονική του Hadoop 1 και Hadoop 2 - YARN. Το MapReduce σε YARN περιλαμβάνει περισσότερες οντότητες από το κλασικό 16

24 MapReduce, οι οποίες φαίνονται στο Σχήμα 6 (β). Μία νέα οντότητα είναι ο διαχειριστής πόρων του YARN, που συντονίζει την κατανομή των πόρων στο cluster. Ο διαχειριστής πόρων έχει έναν χρονοπρογραμματιστή που είναι υπεύθυνος για την κατανομή των πόρων στις διάφορες εφαρμογές που εκτελούνται. Ο χρονοπρογραμματιστής δε παρακολουθεί την εξέλιξη μιας εφαρμογής και έτσι δεν μπορεί να εγγυηθεί την επανεκκίνηση των εργασιών που αποτυγχάνουν. Ακόμη μια νέα οντότητα που εισάγει το YARN είναι ο διαχειριστής κόμβων. Ο διαχειριστής κόμβων είναι υπεύθυνος για τη δημιουργία των containers της εφαρμογής, την επίβλεψη χρησιμοποίησης των πόρων από κάθε εφαρμογή και την αναφορά των παραπάνω στον διαχειριστή πόρων. Τέλος ο application master διαπραγματεύεται με τον χρονοπρογραμματιστή για τα containers. Ανιχνεύει τη θέσης των containers και παρακολουθεί την εξέλιξή τους. (α) Αρχιτεκτονική Hadoop 1. 17

25 (β) Αρχιτεκτονική Hadoop 2. Σχήμα 6: Σύγκριση αρχιτεκτονικής του Hadoop 1 και Hadoop 2 [57] Παράδειγμα MAP REDUCE Στην συνέχεια ακολουθεί ο πηγαίος κώδικας ενός προγράμματος που μετρά το πλήθος εμφάνισης της κάθε λέξης σε ένα κείμενο και ο σχολιασμός αυτού. Μέσα από αυτό το παράδειγμα φαίνεται η λογική προγραμματισμού που πρέπει να ακολουθηθεί για τη κατασκευή ενός προγράμματος Hadoop. Το παράδειγμα είναι από το tutorial της Apache [47] και ο κώδικας είναι σε java. public static class TokenizerMapper extends Mapper<Object, Text, Text, IntWritable>{ private final static IntWritable one = new IntWritable(1); private Text word = new Text(); //Ορισμός της συνάρτησης map public void map(object key, Text value, Context context ) throws IOException, InterruptedException { //Διαχωρισμός του αρχείου κειμένου σε λέξεις StringTokenizer itr = new StringTokenizer(value.toString()); while (itr.hasmoretokens()) { 18

26 word.set(itr.nexttoken()); //Γράφει τα ζεύγη (κλειδί, τιμή) context.write(word, one); Στην κλάση TokenizenMapper, ορίζεται μια συνάρτηση map η οποία δημιουργεί τα ζεύγη (κλειδί, τιμή) διαβάζοντας το αρχείο εισόδου. Σε αυτό το παράδειγμα, το αρχείο εισόδου είναι ένα αρχείο κειμένου με πολλές λέξεις σε κάθε γραμμή. Χρησιμοποιώντας το TextInputFormat (default), η συνάρτηση map διαβάζει τα αρχεία γραμμή προς γραμμή, και έπειτα με το StringTokenizer διαχωρίζει τις γραμμές σε λέξεις και δημιουργεί τα ζεύγη (λέξη, ένα), όπου το ένα μετρά πόσες φορές εμφανίστηκε η λέξη. public static class IntSumReducer extends Reducer<Text,IntWritable,Text,IntWritable> { private IntWritable result = new IntWritable(); // Ορισμός της συνάρτησης reduce public void reduce(text key, Iterable<IntWritable> values, Context context ) throws IOException, InterruptedException { int sum = 0; //Μετράει πόσες φορές η λέξη «κλειδί» εμφανίζεται συνολικά, προσθέτοντας τις επιμέρους τιμές for (IntWritable val : values) { sum += val.get(); result.set(sum); //Γράφει τα αποτελέσματα context.write(key, result); Η reduce συνάρτηση της κλάσης IntSumReducer εφαρμόζεται σε κάθε ζεύγος (κλειδί, τιμές[]) των ενδιάμεσων δεδομένων που προκύπτουν μετά το shuffling. Αυτή η συνάρτηση αθροίζει τις φορές, που εμφανίστηκε το κάθε κλειδί-λέξη. public static void main(string[] args) throws Exception { //Δημιουργία job Configuration conf = new Configuration(); 19

27 Job job = Job.getInstance(conf, "word count"); job.setjarbyclass(wordcount.class); //ορισμός των κλάσεων Map, Combine και Reduce job.setmapperclass(tokenizermapper.class); job.setcombinerclass(intsumreducer.class); job.setreducerclass(intsumreducer.class); //Ορισμός του τύπου κλειδιού, τιμής job.setoutputkeyclass(text.class); job.setoutputvalueclass(intwritable.class); //Ορισμός των μονοπατιών αρχείων εισόδου, εξόδου FileInputFormat.addInputPath(job, new Path(args[0])); FileOutputFormat.setOutputPath(job, new Path(args[1])); System.exit(job.waitForCompletion(true)? 0 : 1); Τέλος είναι η κύρια συνάρτηση. Εδώ δημιουργείται το job και το configuration του. Επίσης ορίζεται ένας combiner, με τον οποίο συνδυάζονται (combine) τοπικά τα αποτελέσματα που προέκυψαν από τη map διαδικασία πριν προχωρήσουν στον Reducer. Στην ουσία ο combiner είναι σαν reducer ανά job. Αν υποθέσουμε ότι σε αυτό το πρόγραμμα δίνονται 2 αρχεία εισόδου τα οποία είναι αρχεία κειμένου και περιέχουν τα εξής: «Hello World Bye World» το πρώτο αρχείο και «Hello Hadoop Goodbye Hadoop» το δεύτερο αρχείο. Για τα δεδομένα 2 αρχεία μετά τη μέθοδο map θα έχουμε: < Hello, 1> < World, 1> < Bye, 1> < World, 1> < Hello, 1> < Hadoop, 1> < Goodbye, 1> < Hadoop, 1> Μετά την εκτέλεση του τοπικού combiner έχουμε: < Bye, 1> < Hello, 1> < World, 2> < Goodbye, 1> < Hadoop, 2> < Hello, 1> Τέλος μετά τον reducer εμφανίζονται τα παρακάτω αποτελέσματα: Bye, 1 Goodbye, 1 Hadoop, 2 Hello, 2 World, 2 20

28 2.2 APACHE SPARK Το Apache Spark είναι μια ισχυρή υπολογιστική μηχανή ανοιχτού κώδικα για το Hadoop, είναι εξοπλισμένο με εξελιγμένες τεχνικές ανάλυσης και σχεδιασμένο για ταχύτητα, και ευκολία χρήσης [54]. Όσον αφορά τη ταχύτητα, το Spark επεκτείνει το δημοφιλές μοντέλο MapReduce υποστηρίζοντας περισσότερους τύπους επεξεργασίας, όπως διαδραστικά ερωτήματα και επεξεργασία ροής δεδομένων [54]. Ένα από τα κύρια χαρακτηριστικά του Spark που συμβάλει στην αύξηση της ταχύτητας είναι η ικανότητα να τρέχει υπολογισμούς στη μνήμη [8]. Το Spark μπορεί να επιταχύνει μια εφαρμογή σε Hadoop cluster έως εκατό φορές με τη χρήση μνήμης, και ως δέκα φορές χρησιμοποιώντας μόνο τον δίσκο [54]. Για την ευκολία χρήσης, το Spark προσφέρει απλά APIs σε Python, Java, Scala και SQL, καθώς και πλούσιες ενσωματωμένες βιβλιοθήκες [54]. Μπορεί επίσης να χρησιμοποιηθεί εύκολα με άλλα εργαλεία big data όπως το να τρέξει σε Hadoop cluster έχοντας πρόσβαση σε όλα τα δεδομένα του Hadoop. Τέλος όσον αφορά τις εξελιγμένες τεχνικές ανάλυσης, το Spark εκτός από το κλασικό MapReduce υποστηρίζει ερωτήματα SQL, επεξεργασία ροής δεδομένων, και πολύπλοκα analytics όπως η μηχανική μάθηση και αλγόριθμοι out-of-the-box [54]. Επίσης δίνει τη πολύ σημαντική δυνατότητα στον χρήστη, να συνδυάσει όλα αυτά σε ένα μόνο πρόγραμμα Η εξέλιξη του Spark Το Spark αναπτύχθηκε το 2009 στο AMPLab του UC Berkeley, και έγινε πρόγραμμα ανοιχτού κώδικα το 2010 [54]. Το 2011, το AMPLab άρχισε να αναπτύσσει στοιχεία υψηλότερου επιπέδου για το Spark, όπως το Spark Streaming [10]. Το 2013, το πρόγραμμα δωρήθηκε στον οργανισμό ανοιχτού λογισμικού Apache και τον Φεβρουάριο του 2014 το Spark έγινε πρόγραμμα υψηλού επιπέδου στον ίδιο οργανισμό [55]. Τον Νοέμβριο του 2014, η ομάδα μηχανικών στη Databricks έθεσαν ένα νέο ρεκόρ στην ταξινόμηση πολλών δεδομένων χρησιμοποιώντας το Spark [56]. 21

29 2.2.2 Το οικοσύστημα του Spark Επειδή ο πυρήνας του Spark είναι γρήγορος και γενικού σκοπού, υποστηρίζει και άλλα στοιχεία υψηλότερου επιπέδου, εξειδικευμένα για ένα συγκεκριμένο είδος επεξεργασίας [54]. Αυτά τα στοιχεία είναι σχεδιασμένα να λειτουργούν στενά με τον πυρήνα, και μπορούν να χρησιμοποιηθούν σαν βιβλιοθήκες κατά την ανάπτυξη ενός προγράμματος. Με αυτόν τον τρόπο πετυχαίνει μείωση των δαπανών, καθώς αντί να τρέχουν τέσσερα-πέντε ανεξάρτητα συστήματα λογισμικού, τρέχει μόνο ένα. Επίσης το μεγαλύτερο πλεονέκτημα είναι ότι έτσι, δίνεται η δυνατότητα να αναπτυχθούν εφαρμογές που συνδυάζουν άψογα διαφορετικά μοντέλα επεξεργασίας. Σχήμα 7: Οικοσύστημα Spark. Τα στοιχεία που αποτελούν το οικοσύστημα του Spark είναι [54]: Spark Core: Είναι ο πυρήνας του Spark και περιέχει τις βασικές λειτουργίες του Spark. Περιλαμβάνει τα απαραίτητα στοιχεία για τον χρονοπρογραμματισμό εργασιών, διαχείριση μνήμης, αποκατάστασης βλαβών, αλληλεπίδρασης με το σύστημα αποθήκευσης, και άλλα. Spark SQL: Παρέχει υποστήριξη ερωτημάτων SQL καθώς και της γλώσσας παραπλήσιας της SQL που δημιουργήθηκε από τον Apache Hive, και λέγεται Hive Query Language - HiveQL. Πέρα από την παροχή της διεπαφής SQL για το Spark, το Spark SQL επιτρέπει στους προγραμματιστές να εισάγουν ερωτήματα SQL στο πρόγραμμα Spark που αναπτύσσουν, χωρίς να χρειάζεται κάτι παραπάνω. Spark Streaming: Είναι ένα στοιχείο του Spark που επιτρέπει την επεξεργασία ροής δεδομένων σε πραγματικό χρόνο. MLlib: Είναι μια βιβλιοθήκη που περιέχει συναρτήσεις μηχανικής μάθησης. Η MLlib παρέχει διάφορους αλγορίθμους μηχανικής μάθησης, συμπεριλαμβανομένης της δυαδικής ταξινόμησης (binary classification), της παλινδρόμησης (regression) και του συνεργατικού φιλτραρίσματος (collaborative filtering). GraphX: Είναι μια βιβλιοθήκη που προστέθηκε στο Spark 0.9 (Φεβρουάριος 2014) και παρέχει ένα API για το χειρισμό γράφων και την παράλληλη εκτέλεση υπολογισμών σε γράφους π.χ. επεξεργασία σε γράφο που αναπαριστά τους φίλους σε ένα κοινωνικό δίκτυο. 22

30 2.2.3 Resilient Distributed Datasets Το Spark έχει ορίσει μια αφαιρετική έννοια για την επεξεργασία των δεδομένων. Αυτή η έννοια είναι ένα σύνολο δεδομένων που ονομάζεται Resilient Distributed Datasets RDD [58]. Ένα RDD είναι απλά μια κατανεμημένη συλλογή στοιχείων. Στο Spark όλες οι εργασίες εκφράζονται είτε ως δημιουργία νέων RDDs, είτε ως μετατροπή RDDs, ή εκτέλεση λειτουργιών σε κάποια RDDs [58]. Το Spark διανέμει αυτόματα τα δεδομένα που περιέχονται στα RDDs στο cluster και παραλληλοποιεί τις εργασίες που εκτελούνται σε αυτά. Τα RDDs μπορεί να περιέχουν οποιοδήποτε αντικείμενο ή κλάση Python, Java ή Scala. Τα RDDs υποστηρίζουν δύο τύπους λειτουργιών [58]: μετασχηματισμούς (transformations), οι οποίοι δημιουργούν ένα νέο σύνολο δεδομένων από ένα υπάρχον, και πράξεις (actions), που επιστρέφουν μια τιμή στο πρόγραμμα driver (το driver πρόγραμμα είναι αυτό το πρόγραμμα που τρέχει τη συνάρτηση main() ) μετά την εκτέλεση επεξεργασίας σε ένα σύνολο δεδομένων. Για παράδειγμα, το map είναι ένας μετασχηματισμός που περνά κάθε στοιχείο του συνόλου δεδομένων σε μια συνάρτηση η οποία σαν αποτέλεσμα παράγει ένα νέο RDD. Από την άλλη, το reduce είναι μια πράξη (action) που συγκεντρώνει όλα τα στοιχεία του RDD χρησιμοποιώντας κάποια συνάρτηση και επιστρέφει το τελικό αποτέλεσμα στο πρόγραμμα driver. Όλοι οι μετασχηματισμοί στο Spark είναι "τεμπέληδες", με την έννοια ότι δεν τρέχουν την επεξεργασία τους αμέσως. Αντ 'αυτού, οι μετασχηματισμοί τρέχουν μόνο όταν ένα action απαιτεί να επιστραφεί ένα αποτέλεσμα στο πρόγραμμα driver. Αυτός ο σχεδιασμός επιτρέπει στο Spark να λειτουργεί πιο αποτελεσματικά. Για παράδειγμα, η map δεν επιστρέφει στο πρόγραμμα driver το σύνολο δεδομένων, αλλά το σύνολο δεδομένων η map το δίνει ως είσοδο στη reduce και τελικά στο πρόγραμμα driver επιστρέφεται μόνο το αποτέλεσμα. Μερικοί από τους μετασχηματισμούς που υποστηρίζει το Spark είναι [58]: map (func): Επιστρέφει ένα νέο κατανεμημένο σύνολο δεδομένων το οποίο σχηματίζεται περνώντας κάθε στοιχείο του RDD πηγής από μια συνάρτηση func. filter (func): Επιστρέφει ένα νέο σύνολο δεδομένων που σχηματίζεται από την επιλογή των στοιχείων του RDD πηγής, για τα οποία η συνάρτηση func επιστρέφει true. flatmap (func): Παρόμοιο με το map, αλλά κάθε στοιχείο εισόδου μπορεί να γίνει map επιστρέφοντας κανένα ή περισσότερα στοιχεία εξόδου. union (otherdataset): Επιστρέφει ένα σύνολο δεδομένων που περιέχει την ένωση των στοιχείων του RDD πηγής με ένα άλλο σύνολο otherdataset. groupbykey ([numtasks]): Συγχωνεύει τις τιμές για κάθε κλειδί. Από προεπιλογή, το επίπεδο της παραλληλίας στην έξοδο εξαρτάται από τον αριθμό των partitions του RDD. 23

31 Μπορεί να πάρει μια προαιρετική παράμετρο numtasks ώστε να οριστεί διαφορετικός αριθμός εργασιών (tasks). reducebykey (func, [numtasks]): Όταν εκτελεστεί σε ένα σύνολο δεδομένων με ζεύγη (κλειδί, τιμή), επιστρέφει ένα σύνολο δεδομένων με ζεύγη (κλειδί, τιμή), όπου οι τιμές για κάθε κλειδί αθροίζονται χρησιμοποιώντας τη συνάρτηση map, η οποία πρέπει να είναι τύπου (τιμή, τιμή) => τιμή. Όπως στο groupbykey, ο αριθμός των map εργασιών μπορεί να καθοριστεί με μια προαιρετική δεύτερη μεταβλητή numtasks. join (otherdataset, [numtasks]): Επιστρέφει ένα RDD που περιέχει όλα τα ζεύγη στοιχείων των οποίων ταιριάζουν τα κλειδιά του ενός RDD με το άλλο. Μερικά από τα actions που υποστηρίζει το Spark είναι [58]: reduce (func): Αθροίζει τα στοιχεία αυτού του RDD χρησιμοποιώντας τη συνάρτηση func. Η συνάρτηση πρέπει να είναι αντιμεταθετική και προσεταιριστική, έτσι ώστε να μπορεί να εκτελεστεί παράλληλα. collect (): Επιστρέφει όλα τα στοιχεία του RDD ως μια λίστα στο πρόγραμμα driver. count (): Επιστρέφει τον αριθμό των στοιχείων του RDD. first (): Επιστρέφει το πρώτο στοιχείο του RDD. saveastextfile (path): Γράφει τα στοιχεία του RDD σε ένα αρχείο κειμένου στο συγκεκριμένο κατάλογο (path) του τοπικού συστήματος αρχείων, HDFS ή οποιοδήποτε άλλο σύστημα αρχείων που υποστηρίζει το Hadoop. saveassequencefile (path): Γράφει τα στοιχεία αυτού του RDD ως ένα αρχείο Hadoop SequenceFile σε ένα συγκεκριμένο κατάλογο (path) στο τοπικό σύστημα αρχείων, HDFS ή οποιαδήποτε άλλο σύστημα αρχείων που υποστηρίζει το Hadoop. Τέλος μία από τις πιο σημαντικές ικανότητες του Spark είναι η διατήρηση (persisting) ή προσωρινή αποθήκευση (caching) ενός συνόλου δεδομένων στη μνήμη. Όταν διατηρείται ένα RDD, κάθε κόμβος κρατά αποθηκευμένα όλα τα partitions του συγκεκριμένου RDD στη μνήμη και τα επαναχρησιμοποιεί εκτελώντας άλλες διεργασίες σε αυτό το σύνολο δεδομένων. Αυτό επιτρέπει μελλοντικές ενέργειες να είναι πολύ πιο γρήγορες, συχνά περισσότερο από δέκα φορές. Ένα RDD μπορεί να "διατηρηθεί" με τις μεθόδους persist() ή cache(). Την πρώτη φορά που θα εκτελεστεί ένα action, θα διατηρηθεί στη μνήμη των κόμβων. Η μνήμη cache του Spark είναι ανεκτική σε σφάλματα (fault-tolerant), αν καταστραφεί κάποιο partition του RDD, τότε 24

32 αυτόματα θα επαναυπολογιστεί χρησιμοποιώντας τους μετασχηματισμούς που δημιούργησαν το partition αρχικά Παράδειγμα Spark Στην συνέχεια ακολουθεί ο πηγαίος κώδικας ενός προγράμματος που μετρά το πλήθος εμφάνισης της κάθε λέξης σε ένα αρχείο κειμένου και ο σχολιασμός αυτού. Το παράδειγμα είναι όμοιο με το παράδειγμα υπολογισμού πλήθους λέξεων που είχε περιγράφει στο Hadoop και έχει σκοπό να δείξει τις διαφορές που έχει η ανάπτυξη προγραμμάτων για τα δύο διαφορετικά πλαίσια Hadoop και Spark. Το παράδειγμα είναι από το tutorial της Apache [59] και ο κώδικας είναι σε java. //Δημιουργία RDD που περιέχει το αρχείο κειμένου από το HDFS JavaRDD<String> file = spark.textfile("hdfs://..."); // Διαχωρισμός των λέξεων JavaRDD<String> words = file.flatmap(new FlatMapFunction<String, String>() { public Iterable<String> call(string s) { return Arrays.asList(s.split(" ")); ); //Δημιουργία ζευγών (λέξη,1) JavaPairRDD<String, Integer> pairs = words.maptopair(new PairFunction<String, String, Integer>() { public Tuple2<String, Integer> call(string s) { return new Tuple2<String, Integer>(s, 1); ); //Άθροισμα των ζευγών ανά κλειδί για να υπολογιστεί πόσες φορές εμφανίζεται η κάθε λέξη JavaPairRDD<String, Integer> counts = pairs.reducebykey(new Function2<Integer, Integer>() { public Integer call(integer a, Integer b) { return a + b; ); //Αποθήκευση των αποτελεσμάτων σε αρχείο στο HDFS counts.saveastextfile("hdfs://..."); Στον παραπάνω κώδικα δημιουργούνται τέσσερα RDDs. Το πρώτο RDD περιέχει το περιεχόμενο του αρχείο κειμένου. Tο δεύτερο δημιουργείται με τη flatmap και περιέχει τις λέξεις που προκύπτουν από το μετασχηματισμό του προηγούμενου RDD. Tο τρίτο δημιουργείται με το maptopair και επιστρέφει RDD που προκύπτει από το μετασχηματισμό του προηγούμενου RDD και έχει ζεύγη της μορφής (λέξη,1). Το τέταρτο RDD δημιουργείται από το reducebykey με μετασχηματισμό του προηγούμενου RDD έχει ζεύγη της μορφής (λέξη, #). Τέλος είναι το action saveastextfile που αποθηκεύει το τελικό RDD σε ένα αρχείο κειμένου στο HDFS. 25

33 3 ΑΝΑΛΥΣΗ ΑΡΧΕΙΩΝ ΚΑΤΑΓΡΑΦΗΣ Στη συνέχεια αυτού του κεφαλαίου θα οριστεί τι είναι τα αρχεία καταγραφής και από τι αποτελούνται. Επίσης θα προσδιοριστεί τι είναι η ανάλυση των αρχείων καταγραφής και θα δοθούν διάφορα παραδείγματα για το που μπορεί να χρησιμοποιηθεί και τι συμπεράσματα μπορεί να προκύψουν. Τέλος θα παρουσιαστεί ο τρόπος με τον οποίο γίνεται η ανάλυση στο νέφος και ένα νέο είδος υπηρεσίας νέφους που δημιουργήθηκε, για να καλύψει αυτή την ανάγκη. 3.1 ΑΡΧΕΙΑ ΚΑΤΑΓΡΑΦΗΣ Τα αρχεία καταγραφής περιλαμβάνουν δεδομένα καταγραφής (log data) που αποτελούνται από τα μηνύματα καταγραφής (logs). Ένα μήνυμα καταγραφής είναι αυτό που παράγει ένα υπολογιστικό σύστημα, συσκευή, λογισμικό, κλπ, ως απάντηση σε κάποιο ερέθισμα [11][12]. Ένα τέτοιο ερέθισμα για παράδειγμα στα συστήματα Unix, είναι η σύνδεση και αποσύνδεση ενός χρήστη. [11]: Τα μηνύματα καταγραφής μπορούν να ταξινομηθούν στις ακόλουθες γενικές κατηγορίες Ενημερωτικό (Information): Τα μηνύματα αυτού του τύπου έχουν σχεδιαστεί για να ενημερώνουν τους χρήστες και διαχειριστές ότι έχει συμβεί ένα καλοήθες γεγονός. Για 26

34 παράδειγμα, το Cisco IOS δημιουργεί μηνύματα κατά την επανεκκίνηση του συστήματος. Debug: Τα μηνύματα debug παράγονται από τα συστήματα λογισμικού, προκειμένου να βοηθήσουν τους προγραμματιστές λογισμικού να διαπιστώσουν και να αντιμετωπίσουν τα προβλήματα που αφορούν την εκτέλεση κώδικα. Προειδοποίησης (Warning): Τα προειδοποιητικά μηνύματα αφορούν καταστάσεις όπου κάποια πράγματα μπορεί να λείπουν ή να απαιτούνται για ένα σύστημα, ωστόσο η απουσία αυτών δεν επηρεάζει τη λειτουργία του συστήματος. Για παράδειγμα, αν κατά την εκτέλεση ενός προγράμματος από τη γραμμή εντολών δεν έχει εισαχθεί ο σωστός αριθμός παραμέτρων, αλλά παρόλα αυτά το πρόγραμμα μπορεί να τρέξει. Σφάλματος (Error): Τα μηνύματα σφαλμάτων χρησιμοποιούνται για την ένδειξη των σφαλμάτων που συμβαίνουν σε διάφορα επίπεδα σε ένα υπολογιστικό σύστημα. Για παράδειγμα, ένα λειτουργικό σύστημα μπορεί να δημιουργήσει ένα μήνυμα σφάλματος, αν δεν μπορεί να συγχρονίσει τα buffers στο δίσκο. Ειδοποίησης (Alert): Ένα μήνυμα ειδοποίησης έχει ως στόχο να δείξει ότι κάτι ενδιαφέρον έχει συμβεί. Συνήθως, εμφανίζονται σε εφαρμογές ασφαλείας και συστήματα που αφορούν την ασφάλεια. Για παράδειγμα εάν ένα σύστημα πρόληψης εισβολής, ανιχνεύσει μια κακόβουλη σύνδεση θα δημιουργήσει ένα μήνυμα ειδοποίησης. Ένα τυπικό μήνυμα καταγραφής περιλαμβάνει τη χρονοσφραγίδα (timestamp), τη πηγή (source), και τα δεδομένα (data). Η χρονοσφραγίδα δηλώνει τον χρόνο κατά τον οποίο δημιουργήθηκε το μήνυμα καταγραφής. Η πηγή είναι το σύστημα που δημιούργησε το μήνυμα καταγραφής και συνήθως την αντιπροσωπεύει μια διεύθυνση IP ή ένα όνομα υπολογιστή. Τέλος, τα δεδομένα είναι η ουσία του μηνύματος καταγραφής. Δυστυχώς δεν υπάρχει τυποποιημένη μορφή για το πώς να αναπαρίστανται τα δεδομένα σε ένα μήνυμα καταγραφής. Μπορεί να περιλαμβάνουν διεύθυνση IP πηγής και προορισμού, ονόματα χρηστών, ονόματα προγραμμάτων, κ.λπ. Σχήμα 8: Μήνυμα καταγραφής Syslog [11]. Ένας από τους πιο διαδεδομένους τύπους αρχείων καταγραφής είναι το Syslog [61]. Στο Σχήμα 8 φαίνεται ένα μήνυμα syslog που παράχθηκε από ένα router Cisco. Ο αριθμός 1 27

35 αντιστοιχεί στη χρονική στιγμή που ο κόμβος (loghost) έλαβε το μήνυμα καταγραφής. Η χρονοσφραγίδα περιλαμβάνει το μήνα, ημέρα, ώρα, λεπτό, και το δευτερόλεπτο που έγινε η παραλαβή του μηνύματος. Ο αριθμός 2 αντιστοιχεί στη διεύθυνση IP του Cisco router. Μετά από την IP του router ακολουθούν τα δεδομένα του μηνύματος καταγραφής, το σημείο υποδεικνύεται με τον αριθμό 3. Στη συγκεκριμένη περίπτωση, η χρονοσφραγίδα κάτω από τον αριθμό 3 είναι από το router και δείχνει τη στιγμή που συνέβη το γεγονός. Ακολουθεί το %LINEPROTO-5-UPDOWN το οποίο δηλώνει τη προτεραιότητα του μηνύματος και συγκεκριμένα η σοβαρότητα του γεγονότος δηλώνεται από τον αριθμό 5. Τέλος ακολουθεί το γεγονός που καταγράφηκε είναι σε κείμενο ελεύθερης μορφής, και περιγράφει ότι το συγκεκριμένο interface FastEthernet0/0 τέθηκε σε λειτουργία. 3.2 ΑΝΑΛΥΣΗ ΤΩΝ ΜΗΝΥΜΑΤΩΝ ΚΑΤΑΓΡΑΦΗΣ Η ανάλυση των μηνυμάτων καταγραφής έχει να κάνει με την ανάλυση των δεδομένων καταγραφής, προκειμένου να εξαχθεί κάποια πληροφορία [11]. Όπως έχουμε αναφέρει τα μηνύματα καταγραφής έρχονται σε μια ποικιλία μορφών και μεγεθών, και μερικές φορές μπορεί να είναι δύσκολο να εξαχθούν πληροφορίες από αυτά. Η αποτελεσματική ανάλυση των αρχείων καταγραφής απαιτεί καλή γνώση του συστήματος, θα πρέπει να είναι αντιληπτό τι είναι καλό και τί κακό για σύστημα, τι είναι ύποπτο και τί είναι φυσιολογικό. Αυτό που θεωρείται κακό ή περίεργο για κάποιον μπορεί να είναι απόλυτα φυσιολογικό για κάποιον άλλον. Για παράδειγμα, η καταγραφή χρηστών από χώρες του εξωτερικού μπορεί να είναι ύποπτη για μια ιστοσελίδα, ενώ για κάποια άλλη ιστοσελίδα μπορεί να είναι συνηθισμένο οι επισκέπτες να είναι ως επί το πλείστων από το εξωτερικό. Από την ανάλυση των αρχείων καταγραφής, μπορεί να προκύψουν χρήσιμες πληροφορίες για το τί συμβαίνει στο δίκτυό, πληροφορίες για τις επιδόσεις του συστήματος, την ανίχνευση σφαλμάτων και την ανίχνευση εισβολών. Επίσης τα αρχεία καταγραφής μπορεί να είναι μια καλή πηγή για να προσδιοριστεί το τι συνέβη μετά από ένα επικίνδυνο ή καταστροφικό περιστατικό. Η ανάλυση των αρχείων καταγραφής μπορεί να βοηθήσει στη διαχείριση πόρων με τη πληθώρα πληροφοριών που περιέχουν. Για παράδειγμα, ένας τυπικός τρόπος για να εξεταστεί αν ένας κόμβος είναι ενεργός ή όχι, είναι να χρησιμοποιηθεί το πρωτόκολλο ελέγχου μηνυμάτων Internet (ICMP) και να γίνει "ping" στον κόμβο. Ωστόσο επιτυχές ping σε ένα κόμβο δηλώνει ότι η διεπαφή δικτύου λειτουργεί και όχι αν ο κόμβος έχει πρόβλημα. Βλέποντας όμως ένα αρχείο καταγραφής του μπορούμε να πούμε με σιγουριά ότι το σύστημα λειτουργεί αρκετά ώστε να παραχθεί το μήνυμα. Τα μηνύματα καταγραφής δεν δηλώνουν μόνο αν ο κόμβος λειτουργεί, 28

36 αλλά επίσης ποιες εφαρμογές τρέχουν στον υπολογιστή και τί λειτουργία εκτελούν. Βλάβες, στο υλικό και λογισμικό, συχνά εμφανίζονται στα αρχεία καταγραφής πριν το σύστημα καταρρεύσει. Σχήμα 9: Επίθεση ssh [11]. Τα αρχεία καταγραφής είναι πολύ χρήσιμα και για την ανίχνευση εισβολών [64]. Στο Σχήμα 9 φαίνεται μια αποτυχημένη προσπάθεια σύνδεσης, χρησιμοποιώντας το όνομα χρήστη Erin. Οι λέξεις illegal user (παράνομος χρήστης) εμφανίζονται επειδή δεν υπάρχει λογαριασμός με τέτοιο όνομα στο σύστημα. Αυτό το μήνυμα ήταν το αποτέλεσμα μιας επίθεσης με SSHscanner που επιχειρεί να συνδεθεί σε έναν υπολογιστή μέσω SSH, χρησιμοποιώντας ένα σύνολο γνωστών ονομάτων και κωδικών πρόσβασης. Επιπλέον τα αρχεία καταγραφής μπορεί να αποδειχθούν καλύτερος δείκτης εισβολής από ένα IDS (Intrusion Detection Systems) [66]. Ένα IDS συνήθως ανιχνεύει την επίθεση αλλά δεν μπορεί να πει αν η απόπειρα ήταν επιτυχής, ενώ αντίθετα ένα αρχείο καταγραφής παρέχει λεπτομέρειες σχετικά με το τι συνέβη στο σύστημα. Φυσικά και η μέθοδος με αρχεία καταγραφής δεν είναι απόλυτα ασφαλής. Μπορεί να μην υπάρχει διαθέσιμος χώρος αποθήκευσης στο δίσκο, ή ο εισβολέας να διαγράψει τα αρχεία καταγραφής. Γι' αυτό είναι σημαντικό τα αρχεία να αποστέλλονται σε ένα απομακρυσμένο σημείο, ώστε ακόμα και αν ο επιτιθέμενος καλύψει τα ίχνη του, τα δεδομένα να υπάρχουν σε ένα άλλον κόμβο. Τα αρχεία καταγραφής μπορούν επίσης να βοηθήσουν στην εύρεση των αιτιών που οδήγησαν σε μια επικίνδυνη κατάσταση [11]. Μετά από την ανάκαμψη από μια επικίνδυνη κατάσταση συνήθως συγκεντρώνονται στοιχεία για να βρεθεί ο λόγος που προέκυψε το πρόβλημα. Τα αρχεία καταγραφής μπορεί να παίξουν πολύ μεγάλο ρόλο σε τέτοιου είδους έρευνες, καθώς δεν αλλοιώνονται (με κανονική χρήση του συστήματος), παρέχουν μια χρονολογική σειρά των γεγονότων και αποτελούν καλής ποιότητας αποδεικτικά στοιχεία (αρκεί να μην έχουν αλλαχτεί από πιθανό εισβολέα). Τέλος τα αρχεία καταγραφής είναι πολύτιμα για την αντιμετώπιση προβλημάτων. Το Syslog σχεδιάστηκε ειδικά για αυτόν τον σκοπό. 29

37 3.3 ΑΝΑΛΥΣΗ ΑΡΧΕΙΩΝ ΚΑΤΑΓΡΑΦΗΣ ΣΤΟ ΝΕΦΟΣ Η ύπαρξη των υπολογιστικών νεφών επιτρέπει την ανάλυση μεγάλου όγκου (GBytes, PBytes) αρχείων καταγραφής [23]. Μάλιστα έχει προκύψει ένας νέος όρος, το Logging as a Service (LaaS) που αναφέρετε σε παροχή υπηρεσιών ανάλυσης αρχείων καταγραφής ως υπηρεσία, σε περιβάλλον νέφους [11]. Δηλαδή, κάποιοι πάροχοι υπηρεσιών νέφους, προσφέρουν υπηρεσίες ανάλυσης αρχείων καταγραφής και αναλαμβάνουν να εκτελέσουν αυτοί την ανάλυση των αρχείων καταγραφής εκ μέρους κάποιου πελάτη τους [65]. Οι χρήστες μιας τέτοιας υπηρεσίας μπορεί να συλλέξουν τα αρχεία καταγραφής από διάφορες συσκευές και προγράμματα και να τα αποστείλουν στο νέφος για επεξεργασία, όπως φαίνεται στο Σχήμα 10. Σχήμα 10: Logging as a Service [11]. Το LaaS είναι αρκετά νέο και υπάρχουν διάφοροι πάροχοι που προσφέρουν διαφορετικές υπηρεσίες [62] [63]. Υπάρχουν κάποια χαρακτηριστικά και δυνατότητες που υποστηρίζονται από όλους τους παρόχους και κάποια που διαφέρουν από πάροχο σε πάροχο. Τα βασικά στοιχεία που έχει μια υπηρεσία LaaS είναι η δυνατότητα αποστολής αρχείων, ευρετηρίαση (indexing) των δεδομένων (για γρήγορη αναζήτηση, κλπ.), μακροχρόνια αποθήκευση, και διεπαφή χρήστη για την αναζήτηση και ανασκόπηση (review) των δεδομένων [11]. Οι περισσότεροι πάροχοι επίσης υποστηρίζουν syslog και έχουν ένα δικό τους API [62] 30

38 [63]. Το Syslog είναι πολύ σημαντικό γιατί καλύπτει το 95% των συσκευών στον κόσμο, ενώ το API βοηθάει στο να ενταχθούν λειτουργίες ανάλυσης αρχείων καταγραφής σε εφαρμογές που θα αναπτύξει ο χρήστης. Επιπλέον η πλειοψηφία των παρόχων χρεώνει τις υπηρεσίες της με το μοντέλο "pay as you go", όπου ο χρήστης χρεώνεται ανάλογα με τη χρήση των υπηρεσιών που κάνει [62] [63]. Από την άλλη, διαφορετικός είναι ο τρόπος που ο κάθε πάροχος έχει δομήσει το σύστημά του [11]. Ορισμένοι πάροχοι έχουν χτίσει τις υπηρεσίες τους σε νέφη άλλων παρόχων, ενώ άλλοι έχουν δημιουργήσει το δικό τους νέφος. Επίσης αν και όλοι παρέχουν δυνατότητα μακροχρόνιας αποθήκευσης των δεδομένων, διαφέρει η χρέωση που κάνουν για αυτήν την υπηρεσία και ο μέγιστος δυνατός χρόνος αποθήκευσης των δεδομένων. Επιπλέον όπως είναι λογικό διαφέρουν οι χρεώσεις που ισχύουν για τον κάθε πάροχο. 31

39 4 ΕΓΚΑΤΑΣΤΑΣΗ ΚΑΙ ΡΥΘΜΙΣΗ ΝΕΦΟΥΣ Σε αυτό το κεφάλαιο θα περιγραφεί η υπηρεσία IaaS ~okeanos που χρησιμοποιήθηκε για να στηθεί το cluster και η διαδικασία η οποία ακολουθήθηκε για να δημιουργηθούν οι εικονικές μηχανές και το δίκτυο. Επίσης θα παρουσιαστεί ο τρόπος εγκατάστασης και ρύθμισης των δύο υπολογιστικών πλαισίων Hadoop και Spark. 4.1 Η ΥΠΗΡΕΣΙΑ ΝΕΦΟΥΣ ~OKEANOS Ο ~okeanos [68] είναι μια IaaS (Infrastructure as a Service) υπηρεσία νέφους που προσφέρει εικονικούς υπολογιστικούς πόρους [67]. Έχει αναπτυχθεί από το Ελληνικό Δίκτυο Έρευνας και Τεχνολογίας (ΕΔΕΤ) και είναι έργο ανοικτού κώδικα. Ο ~okeanos προσφέρει πρόσβαση σε εικονικές μηχανές, εικονικά δίκτυα, εικονικούς δίσκους, και εικονικά Firewalls, τα οποία είναι προσβάσιμα μέσω μιας απλής web-based διεπαφής χρήστη. Ο ~okeanos είναι μια υπηρεσία που αποτελείται από διάφορα επιμέρους τμήματα [67]: Cyclades: Είναι το κομμάτι που έχει να κάνει με την επεξεργασία και το δίκτυο. Συνδυάζει backend του Google Ganeti για την διαχείριση των εικονικών μηχανών και Python/Django API για frontend. Οι εικονικές μηχανές δημιουργούνται με το KVM [69] και μπορούν να τρέξουν linux και windows. Οι εικονικές μηχανές είναι προσβάσιμες στον χρήστη μέσω του διαδικτύου ή προγραμματιστικά. Οι χρήστες μπορούν να 32

40 δημιουργήσουν, εκκινήσουν, επανεκκινήσουν, να κλείσουν και να καταστρέψουν εικονικές μηχανές. Επίσης όσον αφορά τη ρύθμιση των παραμέτρων κάθε εικονικής μηχανής, μπορούν να καθορίσουν τον αριθμό των CPUs, το μέγεθος της μνήμης και του δίσκου. Η διεπαφή χρήστη έχει υλοποιηθεί σε javascript/jquery και τρέχει εξ' ολοκλήρου στον πελάτη. Όσον αφορά τη λειτουργία του δικτύου, ο ~okeanos υποστηρίζει IPv4 και IPv6. Επίσης δίνει τη δυνατότητα χρήσης firewall και δημιουργία τοπικών δικτύων. Pithos+: Είναι η υπηρεσία αποθήκευσης αρχείων. Είναι μια υλοποίηση του OpenStack Object Storage API σε Python και Django. Στο backend κάθε αρχείο είναι αποθηκευμένο ως μια συλλογή από διευθυνσιοδοτημένα ως προς το περιεχόμενο μπλοκ. Στο forntend έχει ένα web-based, command-line και native clients που καλούν το ίδιο API. Astakos: Είναι η υπηρεσία διαχείρισης ταυτοτήτων του ~okeanos. Παρέχει το μοναδικό σημείο πιστοποίησης και εξουσιοδότησης για τις Cyclades και το pithos+. Plankton: Είναι το μητρώο εικόνων του ~okeanos. Έχει υλοποιηθεί ως ένα λεπτό στρώμα πάνω από το pithos+ και κάθε εικόνα στο plankton είναι ένα αρχείο στο pithos+ με ειδικά μεταδεδομένα. Στο frontend, το plankton υλοποιεί το OpenStack Glance API και στο backend κάνει ερωτήσεις στο υπάρχων backend του Pithos+. Aquarium: Είναι η λογιστική και χρεωστική υπηρεσία του ~okeanos. Λαμβάνει τα γεγονότα από τις Cyclades, Pithos+, και Astakos, παρακολουθεί τη χρήση των πόρων για κάθε χρήστη και καθορίζει τη χρέωση. Archipelago: Έχει σκοπό να γεφυρώσει το κενό μεταξύ της τυχαίας προσπέλασης Volumes στις εικονικές μηχανές και της πραγματικής αποθήκευσης των μπλοκ. Είναι μια στοιβάδα (layer) αποθήκευσης που χειρίζεται τα Volumes ως ένα σετ διακριτών μπλοκ στο backend. Σχήμα 11: Τα επιμέρους τμήματα της πλατφόρμας okeanos [67]. 33

41 4.2 ΔΗΜΙΟΥΡΓΙΑ ΕΙΚΟΝΙΚΩΝ ΜΗΧΑΝΩΝ ΣΤΟ ~OKEANOS Αρχικά πρέπει να δημιουργηθεί ο λογαριασμός χρήστη στο ~okeanos. Η διαδικασία είναι πολύ απλή και αν ολοκληρωθεί με επιτυχία, ο χρήστης λαμβάνει επιτυχούς ενεργοποίησης του λογαριασμού του. Αφού έχει ενεργοποιηθεί ο λογαριασμός, τότε μπορούμε να προχωρήσουμε στη δημιουργία του νέφους. Με βάση τους διαθέσιμους πόρους του λογαριασμού που αντιστοιχεί σε κάθε χρήστη, μπορούν να δημιουργηθούν οι αντίστοιχες εικονικές μηχανές. Στη δική μας περίπτωση θα δημιουργηθούν 5 εικονικές μηχανές όπως εμφανίζονται στον παρακάτω πίνακα. Όνομα μηχανής Επεξεργαστές Μνήμη Δίσκος Master 8 8 GB 40 GB Slave1 2 6 GB 40 GB Slave2 2 6 GB 40 GB Slave3 2 6 GB 40 GB Slave4 2 6 GB 40 GB O Master θα είναι ο κόμβος διαχειριστής του συστήματος και στις δύο περιπτώσεις (Hadoop και Spark) για αυτό είναι υπολογιστικά ισχυρότερος. Απαραίτητη προϋπόθεση είναι η ύπαρξη ενός τοπικού ιδιωτικού δικτύου με το οποίο θα επικοινωνούν οι κόμβοι του συστήματός μας μεταξύ τους. Έτσι προτού προχωρήσουμε στη δημιουργία των εικονικών μηχανών, πρώτα δημιουργούμε το τοπικό ιδιωτικό δίκτυο. Για να το κάνουμε αυτό επιλέγουμε από τη καρτέλα του δικτύου New Network+ (Σχήμα 12 α). (α) 34

42 (β) Σχήμα 12: Δημιουργία δικτύου. Το δίκτυο που δημιουργήθηκε έχει όνομα Local και subnet /24 (Σχήμα 12 β). Τώρα μπορούμε να προχωρήσουμε στη δημιουργία των εικονικών μηχανών. Από τη καρτέλα των εικονικών μηχανών, επιλέγουμε το New Machine +. Στη συνέχεια θα εμφανιστεί μια λίστα παρόμοια με αυτή που εμφανίζεται στο Σχήμα 14 για να επιλέξουμε λειτουργικό σύστημα. Στη δικής μας περίπτωση επιλέχθηκε το λειτουργικό σύστημα Debian Base 7.7, γιατί είναι μια δημοφιλής και αξιόπιστη διανομή linux, που συστήνεται για τις εφαρμογές που θα εκτελεστούν. Σχήμα 13: Δημιουργία νέας εικονικής μηχανής. 35

43 Σχήμα 14: Επιλογή λειτουργικού συστήματος. Αφού επιλέξουμε το λειτουργικό σύστημα συνεχίζουμε στην επόμενη καρτέλα στην οποία ορίζουμε τον αριθμό των πυρήνων, το μέγεθος της μνήμης και του δίσκου για το συγκεκριμένο μηχάνημα (Σχήμα 15). Σχήμα 15: Επιλογή επεξεργαστή, μνήμης και δίσκου. 36

44 Στη συνέχεια στην επόμενη καρτέλα εμφανίζονται οι επιλογές δικτύου (Σχήμα 16). Σε αυτή τη καρτέλα μπορούμε να επιλέξουμε σε ποια δίκτυα θα ανήκει η εικονική μηχανή. Στη συγκεκριμένη εικονική μηχανή δόθηκε μια δημόσια ip (83.xxx.xxx.xxx) η οποία χρησιμεύει για τη διαχείριση του κόμβου και επίσης μια τοπική ip του δικτύου Local. Δημόσια ip στο δικό μας cluster θα έχει μόνο ο κόμβος Master, οι υπόλοιποι κόμβοι θα είναι προσβάσιμοι μέσω του Master με ssh. Σχήμα 16: Επιλογή δικτύων. Αφού ολοκληρώσουμε τις ρυθμίσεις δικτύου, δίνουμε όνομα στη μηχανή που δημιουργήσαμε. Η συγκεκριμένη μηχανή θα ονομαστεί Slave1 (Σχήμα 17). 37

45 Σχήμα 17: Επιλογή ονόματος εικονικής μηχανής. Και τέλος στη καρτέλα με τον αριθμό 4 επιβεβαιώνουμε τις επιλογές που έγιναν στα προηγούμενα βήματα και πατώντας την επιλογή create machine, δημιουργείται η εικονική μηχανή εντός λίγων λεπτών (Σχήμα 18). Για τη δημιουργία των υπόλοιπων εικονικών μηχανών θα ακολουθηθεί η ίδια διαδικασία. Σχήμα 18: Έλεγχος και δημιουργία εικονικής μηχανής. 38

46 Αφού δημιουργηθούν όλες οι μηχανές μπορούμε να ελέγξουμε ότι όλες λειτουργούν χωρίς πρόβλημα (Σχήμα 19) και ότι πράγματι είναι συνδεδεμένες στο ίδιο τοπικό ιδιωτικό δίκτυο (Σχήμα 20). Σχήμα 19: Οι εικονικές μηχανές του νέφους. 39

47 Σχήμα 20: Δίκτυο του νέφους. 40

48 4.3 ΕΓΚΑΤΑΣΤΑΣΗ HADOOP Προϋποθέσεις Πριν προχωρήσουμε στην εγκατάσταση και λειτουργία του Hadoop, πρέπει ο κάθε κόμβος του νέφους να ικανοποιεί δύο βασικές απαιτήσεις. Πρέπει να έχει εγκατεστημένο το jvm και πρέπει ο κάθε κόμβος να μπορεί να επικοινωνήσει με τους άλλους με ssh χωρίς να ζητείται κωδικός Δημιουργία κλειδιών ssh Ενημερώνεται το αρχείο /etc/hosts του κάθε κόμβου ώστε να περιέχει τις αντιστοιχίες τοπικών ip, με τα ονόματα του κάθε κόμβου του cluster που δημιουργήσαμε. Το αρχείο θα περιλαμβάνει δηλαδή τα παρακάτω : master snf-62xxxx.vm.okeanos.grnet.gr snf-62xxxx slave1 snf-62xxxx.vm.okeanos.grnet.gr snf-62xxxx slave2 snf-62xxxx.vm.okeanos.grnet.gr snf-62xxxx slave3 snf-62xxxx.vm.okeanos.grnet.gr snf-62xxxx slave4 snf-62xxxx.vm.okeanos.grnet.gr snf-62xxxx Στη συνέχεια κατασκευάζουμε ένα ζεύγος κλειδιών ssh στον master. Πατώντας στο τερματικό του master τις ακόλουθες εντολές (Σχήμα 21): ssh-keygen cat /root/.ssh/id_rsa.pub >> /root/.ssh/authorized_keys chmod 700 /root/.ssh/ chmod 600 /root/.ssh/id_rsa 41

49 Σχήμα 21: Δημιουργία κλειδιών ssh. Τέλος πρέπει να αντιγραφούν τα κλειδιά που δημιουργήθηκαν και στους slaves. Στο Σχήμα 22 φαίνεται πως έγινε επιτυχώς η μεταφορά του κλειδιού μεταξύ του master και του slave1 και πως γίνεται ssh σύνδεση του master με τον slave1 χωρίς να ζητηθεί κωδικός. Σχήμα 22: Επικοινωνία ssh χωρίς να απαιτείται είσοδος κωδικού. 42

50 Εγκατάσταση JVM Στην εικόνα (image) του λειτουργικού που διαθέτει ο ~okeanos, δεν έχει προεγκατεστημένο το jvm, έτσι πρέπει να γίνει η εγκατάσταση του jvm σε όλα τα μηχανήματα με τις εντολές : apt-get update apt-get install apt-get install openjdk-7-jdk Στην συνέχεια γίνεται έλεγχος αν έχει γίνει η εγκατάσταση με το java version και βλέπουμε ότι πράγματι έχει γίνει η εγκατάσταση (Σχήμα 23). Σχήμα 23: Έλεγχος ύπαρξης Java Εγκατάσταση και ρύθμιση Hadoop Αρχικά γίνεται λήψη σε όλους του κόμβους του συμπιεσμένου αρχείου που περιέχει τα αρχεία του Hadoop. Αφού γίνει η λήψη του αρχείου το αποσυμπιέζουμε και το μετονομάζουμε για ευκολία σε hadoop, με τις παρακάτω εντολές: wget tar xvzf hadoop tar.gz mv hadoop /usr/local/hadoop Το Hadoop δίνει τη δυνατότητα να προσαρμοστούν πάρα πολλοί παράμετροι του συστήματος προκειμένου να ανταποκρίνεται καλύτερα στις ανάγκες της κάθε εφαρμογής και να αξιοποιεί βέλτιστα τους διαθέσιμους πόρους, ωστόσο στη συνέχεια θα δείξουμε τις βασικές ρυθμίσεις που πρέπει να γίνουν για να λειτουργήσει το Hadoop. Οι παράμετροι που πρέπει να οριστούν βρίσκονται στα αρχεία : ~/.bashrc /usr/local/hadoop/etc/hadoop/hadoop-env.sh /usr/local/hadoop/etc/hadoop/core-site.xml /usr/local/hadoop/etc/hadoop/yarn-site.xml /usr/local/hadoop/etc/hadoop/mapred-site.xml.template /usr/local/hadoop/etc/hadoop/hdfs-site.xml 43

51 Στο αρχείο ~/.bashrc προσθέτουμε τον παρακάτω κώδικα : export JAVA_HOME=/usr/lib/jvm/java-7-openjdk-amd64 export HADOOP_INSTALL=/usr/local/hadoop export PATH=$PATH:$HADOOP_INSTALL/bin export PATH=$PATH:$HADOOP_INSTALL/sbin export HADOOP_MAPRED_HOME=$HADOOP_INSTALL export HADOOP_COMMON_HOME=$HADOOP_INSTALL export HADOOP_HDFS_HOME=$HADOOP_INSTALL export YARN_HOME=$HADOOP_INSTALL export HADOOP_COMMON_LIB_NATIVE_DIR=$HADOOP_INSTALL/lib/native export HADOOP_OPTS="-Djava.library.path=$HADOOP_INSTALL/lib" Στο αρχείο hadoop-env.sh προσθέτουμε τον παρακάτω κώδικα : export JAVA_HOME=/usr/lib/jvm/java-7-openjdk-amd64 export HADOOP_PREFIX=/usr/local/hadoop export HADOOP_YARN_HOME=/usr/local/hadoop export HADOOP_CONF_DIR=/usr/local/hadoop/etc/Hadoop export HADOOP_OPTS=-Djava.net.preferIPv4Stack=true Στο αρχείο core-site.xml προσθέτουμε τον παρακάτω κώδικα : <property> <name>fs.default.name</name> <value>hdfs://master:8020</value> </property> Στο αρχείο yarn-site.xml προσθέτουμε τον παρακάτω κώδικα : <property> <name>yarn.resourcemanager.address</name> <value>master:8022</value> </property> <property> <name>yarn.resourcemanager.admin.address</name> <value>master:8033</value> </property> <property> 44

52 <name>yarn.resourcemanager.resource-tracker.address</name> <value>master:8025</value> </property> <property> <name>yarn.resourcemanager.scheduler.address</name> <value>master:8030</value> </property> <property> <name>yarn.acl.enable</name> <value>false</value> </property> <property> <name>yarn.nodemanager.local-dirs</name> <value>/usr/local/hadoop_work/mapred/nodemanager</value> <final>true</final> </property> <property> <name>yarn.nodemanager.aux-services</name> <value>mapreduce_shuffle</value> </property> <property> <name>yarn.nodemanager.resource.memory-mb</name> <value>6144</value> </property> <property> <name>yarn.nodemanager.resource.cpu-vcores</name> <value>2</value> </property> Στο αρχείο mapred-site.xml προσθέτουμε τον παρακάτω κώδικα : <configuration> <property> <name>mapreduce.framework.name</name> <value>yarn</value> </property> <property> <name>mapred.job.tracker</name> <value>localhost:9001</value> </property> </configuration> 45

53 Στο αρχείο hdfs-site.xml προσθέτουμε τον παρακάτω κώδικα : <property> <name>dfs.name.dir</name> <value>/usr/local/hadoop/name/data</value> </property> <property> <name>dfs.data.dir</name> <value>/usr/local/hdfs/data</value> </property> <property> <name>dfs.replication</name> <value>4</value> </property> <property> <name>dfs.namenode.rpc-bind-host</name> <value> </value> </property> <property> <name>dfs.namenode.servicerpc-bind-host</name> <value> </value> </property> Και στο αρχείο hadoop/slaves του master προσθέτουμε τα παρακάτω στοιχεία : Slave1 Slave2 Slave3 Slave4 Τέλος γίνεται Format το Hadoop Filesystem, ελέγχεται η ορθή λειτουργία του YARN (Σχήμα 24) και εκκινούν αυτόματα οι διεργασίες σε όλους του κόμβους του νέφους με την εντολή sbin/start-all.sh (Σχήμα 25). Επίσης για να βεβαιωθούμε για την ορθή λειτουργία του συστήματος εκτελείται το παράδειγμα υπολογισμού π (Σχήμα 27). Σχήμα 24: Έλεγχος YARN. 46

54 Σχήμα 25: Εκκίνηση namenode, datanodes, resourcemanager, nodemanagers. Σχήμα 26: Διεπαφή Hadoop, προβολή συνδεδεμένων κόμβων slaves. Σχήμα 27: Διεπαφή Hadoop, επιτυχής εκτέλεση προγράμματος MapReduce υπολογισμού π. 47

55 4.4 ΕΓΚΑΤΑΣΤΑΣΗ SPARK Αρχικά πρέπει να γίνει λήψη του συμπιεσμένου αρχείου που περιέχει τα αρχεία του Spark σε κάθε κόμβο του νέφους. Από τη σελίδα επιλέγουμε την έκδοση του Spark και κάνουμε λήψη του αρχείου. Αφού ολοκληρωθεί η λήψη του αρχείου, το αποσυμπιέζουμε, και το βάζουμε στον κατάλογο που επιθυμούμε, στη δική μας περίπτωση στο /usr/local/spark. Στη συνέχεια ορίζουμε τις παρακάτω μεταβλητές σε κάθε κόμβο: export HADOOP_PREFIX=/usr/local/hadoop export HADOOP_YARN_HOME=/usr/local/hadoop export HADOOP_CONF_DIR=/usr/local/hadoop/etc/hadoop export PATH=$PATH:$HADOOP_YARN_HOME/bin Και στο αρχείο spark/conf/slaves εισάγουμε του κόμβους slaves δηλαδή: slave1 slave2 slave3 slave4 Έπειτα αφού μεταφερθούμε στον κατάλογο που βρίσκεται το Spark, δίνουμε την εντολή sbin/start-all.sh. Επίσης πρέπει να δοθούν οι εντολές $HADOOP_CONF_DIR yarn-daemon.sh start resourcemanager στον master και $HADOOP_CONF_DIR yarn-daemons.sh start nodemanager στους slaves, προκειμένου να ξεκινήσει να εκτελείται Spark και το YARN σε όλους του κόμβους που έχει εγκατασταθεί. Στο Σχήμα 28 φαίνεται ότι πράγματι το Spark αναγνωρίζει τους κόμβους slaves. Έπειτα για να σιγουρευτούμε για την ορθή λειτουργία του συστήματος τρέχουμε το παράδειγμα υπολογισμού π τη πρώτη φορά στο Spark standalone (Σχήμα 29) και τη δεύτερη στο Spark YARN (Σχήμα 30). 48

56 Σχήμα 28: Διεπαφή Spark, προβολή συνδεδεμένων κόμβων. Σχήμα 29: Διεπαφή Spark, επιτυχής εκτέλεση υπολογισμού π με πρόγραμμα Spark standalone. Σχήμα 30: Διεπαφή Hadoop, επιτυχής εκτέλεση προγράμματος Spark on Yarn υπολογισμού π. 49

57 5 ΥΛΟΠΟΙΗΣΗ ΠΡΟΓΡΑΜΜΑΤΩΝ HADOOP MAPREDUCE Σε αυτό το κεφάλαιο θα παρουσιαστούν αρχικά τα εργαλεία ανάπτυξης των προγραμμάτων. Στη συνέχεια θα περιγραφούν τα προγράμματα που υλοποιήθηκαν με το προγραμματιστικό μοντέλο MapReduce. Αυτά τα προγράμματα είναι ενδεικτικά για την ανάλυση των αρχείων καταγραφής και εκφράζουν ρεαλιστικές απαιτήσεις που μπορεί να έχει μια σύγχρονη εταιρία, οργανισμός ή κάποιος ιδιώτης. Η ανάλυση των αρχείων καταγραφής, (όπως προαναφέρθηκε) μπορεί να χρησιμοποιηθεί για διάφορους σκοπούς. Κάθε φορά η ανάλυση προσαρμόζεται με βάση τις συσκευές που λαμβάνονται τα αρχεία καταγραφής και τα συμπεράσματα που αναμένονται να εξαχθούν. Στη συνέχεια θα περιγραφούν κάποιες βασικές περιπτώσεις όπου η ανάλυση των αρχείων καταγραφής χρησιμοποιείται για την εξαγωγή στατιστικών για τη χρήση των υπηρεσιών, την ανίχνευση και αντιμετώπιση σφαλμάτων και επιθέσεων. Επίσης θα γίνουν μετρήσεις σε διάφορα προγράμματα που αφορούν τον χρόνο εκτέλεσης τους και πως αυτός επηρεάζεται από διάφορες παραμέτρους. 5.1 ΤΑ ΕΡΓΑΛΕΙΑ ΑΝΑΠΤΥΞΗΣ Η ανάπτυξη των προγραμμάτων MapReduce έγινε στη γλώσσα προγραμματισμού java, στην οποία είναι γραμμένος και ο πυρήνας του προγραμματιστικού μοντέλου. Για τη δημιουργία των προγραμμάτων χρησιμοποιήθηκε το εργαλείο αυτόματης δημιουργίας java projects, Maven [71]. Κύριο χαρακτηριστικό του Maven είναι ότι ορίζει ένα αρχείο XML που ονομάζεται 50

58 pom.xml. Σε αυτό περιγράφονται διάφοροι παράμετροι, όπως οι εξαρτήσεις του project με άλλα modules, η σειρά κατασκευής, καθώς και τυχόν plug ins που χρησιμοποιεί το πρόγραμμα. Η δημιουργία java projects θα μπορούσε να γίνει με το Maven σε terminal κάποιου μηχανήματος linux του νέφους, ή σε κάποιο άλλο μηχάνημα linux ή windows. Ωστόσο για την ευκολότερη ανάπτυξη και αποσφαλμάτωση μπορεί να χρησιμοποιηθεί σε συνδυασμό με κάποιο java IDE. Στη δική μας περίπτωση χρησιμοποιήθηκε το Eclipse Java IDE [72] η έκδοση Luna για Windows για την ανάπτυξη και έλεγχο των προγραμμάτων. Στο Eclipse έγινε εγκατάσταση του plug-in, m2eclipse, για την αυτόματη δημιουργία Maven java projects. Έτσι μπορούμε να δημιουργήσουμε ένα νέο Maven java project, από το μενού File -> New Project -> Maven Project (Σχήμα 31). Όταν ολοκληρωθεί η αυτόματη διαδικασία (wizard) του Eclipse, θα δημιουργηθεί το project. Σχήμα 31: Δημιουργία Maven Project. Αφού δημιουργηθεί το project, πρέπει να προστεθούν οι εξαρτήσεις για το Hadoop στο project, προκειμένου να μπορούν να χρησιμοποιηθούν οι Hadoop κλάσεις, μέθοδοι και τύποι. 51

59 Αυτό γίνεται επιλέγοντας το αρχείο pom.xml από τον κατάλογο του project, και στην καρτέλα dependencies προσθέτουμε στα αντίστοιχα πεδία τις εξαρτήσεις που χρειάζονται, όπως φαίνεται στο Σχήμα 32. Σχήμα 32: Πρόσθεση εξαρτήσεων στο maven java project. Με τον παραπάνω τρόπο δίνεται η δυνατότητα ανάπτυξης και αποσφαλμάτωσης προγραμμάτων MapReduce τοπικά, πριν εκτελεστούν στο νέφος. Η εκτέλεση τους τοπικά γίνεται καλώντας το Map Reduce JAR, με ορίσματα εισόδου και εξόδου όμοια με αυτά που θα δοθούν κατά την εκτέλεση των προγραμμάτων στο νέφος. 52

60 5.2 ΤΟ ΑΡΧΕΙΟ ΚΑΤΑΓΡΑΦΗΣ ΠΟΥ ΧΡΗΣΙΜΟΠΟΙΗΘΗΚΕ Για να είναι τα παραδείγματα που ακολουθούν όσο το δυνατό πιο ρεαλιστικά, χρησιμοποιήθηκε ένα πραγματικό αρχείο καταγραφής, το οποίο ήταν δημόσια προσβάσιμο στο διαδίκτυο και βρέθηκε μετά από αναζήτηση στη διεύθυνση ftp:// xxx.xxx/apache2.2/logs/. Είναι ένα αρχείο apache web access log του οποίου τα μηνύματα καταγραφής έχουν τη μορφή που φαίνεται στο Σχήμα 33. Σχήμα 33: Πραγματικά μηνύματα καταγραφής Apache web access log. Όπως φαίνεται στο Σχήμα 33, το πρώτο δεδομένο είναι η ip του πελάτη (π.χ ) ή μπορεί να είναι το όνομα του κόμβου. Ακολουθούν 2 παύλες ( - - ), η πρώτη παύλα είναι μέρος του ελέγχου ταυτότητας που ορίζει το RFC 1413 [74] και η παύλα δηλώνει ότι δεν υπάρχει τιμή για αυτό το πεδίο [73]. Η δεύτερη παύλα αντιπροσωπεύει την ταυτότητα χρήστη που αιτείται στο εξυπηρετητή, και πάλι η παύλα δηλώνει ότι στη συγκεκριμένη περίπτωση δεν υπάρχει τιμή για αυτό το πεδίο. Το τέταρτο στοιχείο στη σειρά δηλώνει την ημερομηνία και ώρα που εξυπηρετήθηκε η αίτηση του πελάτη, και η ζώνη ώρας του εξυπηρετητή (π.χ ) [73]. Ακολουθεί η αίτηση που έλαβε ο εξυπηρετητής μέσα σε "" και τέλος δύο ακόμη αριθμοί. Ο προτελευταίος αριθμός είναι ο κωδικός κατάστασης που ο εξυπηρετητής επιστρέφει πίσω στον πελάτη (π.χ. 200) και ο τελευταίο αριθμός δηλώνει το μέγεθος του αντικειμένου που επιστράφηκε στον πελάτη και συνήθως εκφράζεται σε bytes (π.χ. 8013) [73]. Το αρχείο web access log πρέπει να αποθηκευτεί στο κατανεμημένο σύστημα αρχείων HDFS (Σχήμα 34) προκειμένου να είναι προσβάσιμο για επεξεργασία από του κόμβους του νέφους. Κατά τη ρύθμιση του Hadoop, ο παράγοντας αντιγραφής τέθηκε στο τέσσερα, έτσι το κάθε block που συστήνει ένα αρχείο θα υπάρχει και στους τέσσερεις κόμβους slaves. Το μέγεθος του μπλοκ είναι 128MB και το αρχείο καταγραφής είναι 1.1 GB, οπότε όπως φαίνεται και στο Σχήμα 35 το αρχείο διαχωρίζεται σε εννιά μπλοκ τα οποία αποθηκεύονται στο HDFS και το κάθε μπλοκ αντιγράφεται σε κάθε κόμβο slave. 53

61 Σχήμα 34: Αποστολή αρχείου καταγραφή στο HDFS. Σχήμα 35: Διεπαφή HDFS πληροφορίες για το αρχείο καταγραφής. 54

62 5.3 ΑΝΑΛΥΣΗ ΓΙΑ ΤΗΝ ΕΞΑΓΩΓΗ ΣΤΑΤΙΣΤΙΚΩΝ ΧΡΗΣΗΣ ΥΠΗΡΕΣΙΩΝ Η ανάλυση των αρχείων καταγραφής μπορεί να χρησιμοποιηθεί προκειμένου να εξαχθούν στατιστικά στοιχεία για κάποιο σύστημα. Στη δική μας περίπτωση που τα αρχεία καταγραφής αφορούν κάποια ιστοσελίδα, θεωρούμε ότι είναι πολύ χρήσιμο για διαχειριστικούς και οικονομικούς λόγους, να εξαχθούν συμπεράσματα που αφορούν την κατανομή της κίνησης του ιστοτόπου και την εύρεση των σελίδων με τη μεγαλύτερη κίνηση Πρόγραμμα εύρεσης κίνησης ανά μέρα Το πρώτο πρόγραμμα που θα υλοποιηθεί, θα μετρά τις αιτήσεις που γίνονται κάθε στιγμή στο σύστημα, και θα τις ταξινομεί με βάση τη μέρα που έγιναν. Με αυτόν τον τρόπο θα εξαχθούν συμπεράσματα για τον τρόπο που κατανέμεται η κίνηση στις εφτά ημέρες της βδομάδας. Υποθέτουμε ότι ζητήθηκε να γίνει ανάλυση σε επίπεδο ημέρας, ωστόσο με μικρές αλλαγές στο πρόγραμμα που θα υλοποιηθεί, θα μπορούσαν να εξαχθούν συμπεράσματα σε επίπεδο δευτερολέπτων, μέχρι επίπεδο χρόνων. Ξεκινώντας το πρόγραμμά μας υλοποιούμε τη κλάση mapper. Αυτή η κλάση διαχωρίζει το αρχείο καταγραφής σε μηνύματα καταγραφής, δηλαδή σε γραμμές. Προσπελαύνει τη κάθε γραμμή χρησιμοποιώντας regular expression και διαβάζει την ώρα που γίνεται κάθε αίτηση. Στη συνέχεια ο mapper επιλέγει τη μέρα και τη δίνει ως έξοδο μαζί με τη τιμή one. Ακολουθεί ο κώδικας του mapper: //Ορίζουμε τη μορφή της ημερομηνίας public static SimpleDateFormat dateformatter = new SimpleDateFormat("dd/MMMMM/yyyy:hh:mm:ss z"); // Ορίζουμε ένα πίνακα με της ημέρες της βδομάδας private static String[] daytable = {"", "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"; //Το regular expression για το log message public static final Pattern p = Pattern.compile("^(\\S+) (\\S+) (\\S+) \\[([\\w:/]+\\s[+\\- ]\\d{4)\\]" +" \"(.+?)\" (\\d{3) (\\S+)"); //Η κλάση mapper public static class LogEntryMapper extends Mapper<Object, Text, IntWritable, IntWritable> { private final static IntWritable one = new IntWritable(1); 55

63 public void map(object key, Text value, Context context) throws IOException, InterruptedException { try { //Χρήση της regular expression για τον καθορισμό μηνυμάτων καταγραφής Matcher matcher = p.matcher(value.tostring()); if (matcher.matches()) { Date time = dateformatter.parse(matcher.group(4)); //Δημιουργία νέου στιγμιότυπου του calendar Calendar calendar = GregorianCalendar.getInstance(); //Θέτουμε το calendar στη δοσμένη ημερομηνία calendar.settime(time); //Διαβάζεται η μέρα σε μορφή int, ξεκινώντας από τη Κυριακή με τον αριθμό 0 int days = calendar.get(calendar.day_of_week); context.write(new IntWritable(days), one); catch (ParseException e) { e.printstacktrace(); Στη συνέχεια ακολουθεί η κλάση reducer. Αφού έχουν παραχθεί τα ζεύγη (κλειδί-τιμή) από τη κλάση map, ταξινομούνται και στη συνέχεια καλείται ο reducer για κάθε ένα κλειδί. Κάθε reducer διαβάζει τις τιμές και υπολογίζει το σύνολο των αιτήσεων για κάθε μέρα. public static class LogEntryReducer extends Reducer<IntWritable, IntWritable, Text, IntWritable> { public void reduce(intwritable key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException { int sum = 0; for (IntWritable val : values) { sum += val.get(); //Με βάση τον πίνακα daytable που είχε οριστεί στην αρχή, αντιστοιχούμε τους αριθμούς σε ημέρες String dayofweek = daytable[key.get()]; context.write(new Text(dayOfWeek), new IntWritable(sum)); 56

64 Τέλος υλοποιήθηκε η main public static void main(string[] args) throws Exception { Configuration conf = new Configuration(); //Δημιουργία job Job job = new Job(conf, "LogAnalyzerRequestsPerDay"); job.setjarbyclass(loganalyzerrequestsperday.class); // Ορισμός mapper, reducer job.setmapperclass(logentrymapper.class); job.setreducerclass(logentryreducer.class); //Ορισμός του τύπου κλειδιού, τιμής job.setmapoutputkeyclass(intwritable.class); job.setmapoutputvalueclass(intwritable.class); //Διαβάζει τις 2 μεταβλητές εισόδου FileInputFormat.addInputPath(job, new Path(args[0])); FileOutputFormat.setOutputPath(job, new Path(args[1])); System.exit(job.waitForCompletion(true)? 0 : 1); Αφού το πρόγραμμα μεταγλωττίστηκε (compilation) και παράχθηκε το εκτελέσιμο αρχείο, μεταφέρουμε το εκτελέσιμο αρχείο στο νέφος και το εκτελούμε. Ως είσοδο στο πρόγραμμα δόθηκε η διεύθυνση του αρχείου apache web access log στο HDFS. Με αυτήν την είσοδο το πρόγραμμα υπολόγισε τα παρακάτω στοιχεία: Sunday Monday Tuesday Wednesday Thursday Friday Saturday Οι πληροφορίες που προέκυψαν είναι εύκολα κατανοητές και μπορούν να οπτικοποιηθούν εύκολα σε ένα ιστόγραμμα με κάποιο πρόγραμμα όπως το Microsoft Excel. Αυτές οι πληροφορίες οι οποίες έχουν προκύψει από την ανάλυση πολλών εκατομμυρίων μηνυμάτων καταγραφής, είναι πλέον εύκολα διαχειρίσιμες και μπορούν να χρησιμοποιηθούν για 57

65 Αριθμός αιτήσεων την εξαγωγή συμπερασμάτων. Συγκεκριμένα όπως φαίνεται και στο Σχήμα 36 μπορεί εύκολα να γίνει κατανοητό ότι η χρήση του συστήματος ξεκινά να μειώνεται από τη Παρασκευή, και σημειώνει τα μικρότερα νούμερα το σαββατοκύριακο. Αιτήσεις στο σύστημα ανά ημέρα Ημέρα Σχήμα 36: Αιτήσεις στο σύστημα ανά ημέρα Πρόγραμμα εύρεσης δημοφιλέστερων σελίδων Το δεύτερο πρόγραμμα που αφορά την ανάλυση των αρχείων καταγραφής, έχει σκοπό την εύρεση των δέκα πιο δημοφιλών ερωτημάτων που γίνονται στις σελίδες. Οι σελίδες που συγκροτούν τη διεπαφή με το χρήστη του συγκεκριμένου ιστοτόπου είναι τύπου php και για αυτό τον λόγο θα βρεθούν τα δέκα δημοφιλέστερα ερωτήματα που γίνονται σελίδες php από τους χρήστες. Αρχικά θα υπολογιστεί πόσες φορές γίνεται η κάθε αίτηση στο σύστημα. Με αυτόν τον τρόπο θα παρέχεται μια πλήρης εικόνα για όλα τα ερωτήματα που γίνονται στο σύστημα, περιλαμβανομένου του αριθμού εμφάνισης του κάθε ερωτήματος. Ωστόσο αυτά τα δεδομένα είναι υπερβολικά πολλά για να μπορεί κάποιος να βγάλει εύκολα συμπέρασμα. Ο κώδικας που ακολουθεί δείχνει τις κλάσεις Mapper και Reducer που υλοποιούν αυτό το πρόγραμμα. public static final Pattern p = Pattern.compile("^(\\S+) (\\S+) (\\S+) \\[([\\w:/]+\\s[+\\- ]\\d{4)\\]" +" \"(.+?)\" (\\d{3) (\\S+)"); public static class LogEntryMapper extends Mapper<Object, Text, Text, IntWritable> { private final static IntWritable one = new IntWritable(1); 58

66 public void map(object key, Text value, Context context) throws IOException, InterruptedException { Matcher matcher = p.matcher(value.tostring()); if (matcher.matches()) { Text url = new Text(matcher.group(5)); context.write(new Text(url), one); public static class LogEntryReducer extends Reducer<Text, IntWritable, Text, IntWritable> { private IntWritable total = new IntWritable(); public void reduce(text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException { int sum = 0; for (IntWritable value : values) { sum += value.get(); total.set(sum); context.write(key, total); Εκτελώντας το πρόγραμμα που παράγει ο παραπάνω κώδικας, προκύπτει ένα μεγάλο σε μέγεθος αρχείο που περιέχει όλες τις αιτήσεις που γίνονται στο σύστημα και έναν αριθμό που δείχνει το πόσες φορές έγινε η κάθε μία. Αυτό το αρχείο θα είναι είσοδος στο πρόγραμμα το οποίο θα υπολογίσει τις δέκα δημοφιλέστερες σελίδες. Για να επιτευχθεί υψηλή απόδοση στο πρόγραμμα, δεν θα γίνει ταξινόμηση όλων των μετρήσεων που έχουν γίνει και επιλογή των δέκα πρώτων. Ο κάθε mapper θα βρίσκει τις δέκα δημοφιλέστερες σελίδες στα δεδομένα που επεξεργάζεται και ο reducer θα βρει τις συνολικά δέκα δημοφιλέστερες σελίδες. Ο Mapper επεξεργάζεται όλα τα αρχεία εισόδου και τα αποθηκεύει σε ένα treemap [80]. Ένα treemap είναι μια υποκλάση του map που ταξινομεί τα ζεύγη σε αύξουσα σειρά με βάση το κλειδί. Στη συνέχεια, εάν υπάρχουν περισσότερες από δέκα εγγραφές στο treemap, το πρώτο στοιχείο αφαιρείται. Αφού έχει τελειώσει η ρουτίνα του Mapper, οι δέκα εγγραφές που έχουν παραμείνει στο treemap εξάγονται από τη δομή του treemap με τη μέθοδο cleanup. public static class MapClass extends Mapper<Object, Text, Text, Text> { //Ορίζουμε τη δομή TreeMap private TreeMap<Integer, Text> TopTenMap = new TreeMap<Integer, Text>() ; 59

67 public void map(object key, Text value, Context context) throws IOException, InterruptedException { //Διαχωρισμός κάθε γραμμής σε αίτηση και πλήθος εμφάνισης String[] logs = value.tostring().split("\t") ; int value_cnt = Integer.parseInt(logs[1]) ; //Ελέγχουμε αν η συγκεκριμένη αίτηση αφορά php αρχείο if (logs[0].contains(".php")){ TopTenMap.put(new Integer(value_cnt), new Text(logs[0])); //Αν υπάρχουν πάνω από 10 εγγραφές αφαιρούμε αυτή με το χαμηλότερο αριθμό εμφάνισης if (TopTenMap.size() > 10) { TopTenMap.remove(TopTenMap.firstKey()); protected void cleanup(context context) throws IOException, InterruptedException { //Δίνουμε ως έξοδο τις 10 εγγραφές στον reducer for (Integer k : TopTenMap.keySet()) { context.write(new Text(k.toString()), TopTenMap.get(k)); Η λειτουργία του Reducer είναι όμοια με του Mapper. Χρησιμοποιείται και εδώ η δομή treemap όπου αποθηκεύονται οι συνολικά δέκα δημοφιλέστερες σελίδες και μια μέθοδο cleanup που εξάγει τα αποτελέσματα από το treemap και γράφει τα τελικά αποτελέσματα. public static class ReduceClass extends Reducer<NullWritable, Text, NullWritable, Text> { //Ορίζουμε τη δομή Treemap private TreeMap<Integer, Text> TopTenMap = new TreeMap <Integer, Text>(); public void reduce (Integer key, Iterable<Text> values, Context context) throws IOException, InterruptedException { for (Text value : values) { //Αν υπάρχουν πάνω από 10 εγγραφές αφαιρούμε αυτή με το χαμηλότερο αριθμό εμφάνισης TopTenMap.put(new Integer(key), new Text(value)); if (TopTenMap.size() > 10) { TopTenMap.remove(TopTenMap.firstKey()) ; 60

68 Ερωτήματα protected void cleanup(context context) throws IOException, InterruptedException { for (Text t : TopTenMap.values()) { context.write(nullwritable.get(), t); Τα αποτελέσματα που προκύπτουν, εμφανίζουν τα δέκα πιο δημοφιλή ερωτήματα που γίνονται σε σελίδες php με τη μεγαλύτερη κίνηση και έχουν τη παρακάτω μορφή GET /p4p/sent_boss.php HTTP/ POST /phpmyadmin/scripts/setup.php HTTP/ GET /phpmyadmin/scripts/setup.php HTTP/ POST /p4p/index.php HTTP/ GET /poll/chartpoll.php HTTP/ GET /poll/chartpoll2.php HTTP/ GET /p4p/detail2.php HTTP/ GET /p4p/report.php HTTP/ POST /p4p/form.php HTTP/ GET /p4p/detail.php HTTP/1.1 Με βάση τις παραπάνω πληροφορίες προκύπτει το Σχήμα 37, όπου μπορεί εύκολα να γίνει κατανοητό ποιες σελίδες έχουν τη περισσότερη κίνηση και με πόση διαφορά από τις υπόλοιπες. Οι php σελίδες που δέχονται τα περισότερα ερωτήματα GET /p4p/detail.php HTTP/1.1 POST /p4p/form.php HTTP/1.1 GET /p4p/report.php HTTP/1.1 GET /p4p/detail2.php HTTP/1.1 GET /poll/chartpoll2.php HTTP/1.1 GET /poll/chartpoll.php HTTP/1.1 POST /p4p/index.php HTTP/1.1 GET /phpmyadmin/scripts/setup.php HTTP/1.1 POST /phpmyadmin/scripts/setup.php HTTP/1.1 GET /p4p/sent_boss.php HTTP/ Σύνολο ερωτημάτων Σχήμα 37:Οι σελίδες php που δέχονται τα περισσότερα ερωτήματα. 61

69 5.4 ΑΝΑΛΥΣΗ ΓΙΑ ΑΝΙΧΝΕΥΣΗ ΚΑΙ ΑΝΤΙΜΕΤΩΠΙΣΗ ΕΠΙΘΕΣΕΩΝ Μια από τις πιο συνηθισμένες επιθέσεις που πραγματοποιούνται το τελευταίο διάστημα είναι οι επιθέσεις άρνησης υπηρεσίας (Denial of Service DoS attacks) [77]. Ο σκοπός μιας τέτοιας επίθεσης είναι η κατάρρευση μιας υπηρεσίας ή υπολογιστικών πόρων ενός συστήματος, ούτως ώστε οι νόμιμοι χρήστες αυτού να μην μπορούν πλέον να εξυπηρετηθούν. Αυτός ο τύπος επίθεσης είναι ιδιαίτερα επικίνδυνος γιατί μπορεί να πραγματοποιηθεί σχετικά εύκολα και μπορεί να έχει πολύ σοβαρές επιπτώσεις. Η μέθοδος με την οποία πραγματοποιείται μια τέτοια επίθεση περιλαμβάνει την αποστολή υπερβολικά μεγάλου αριθμού αιτημάτων στον υπολογιστή-θύμα, ο οποίος αδυνατεί να ανταποκριθεί σε τόσο μεγάλο φόρτο και καταρρέει. Μια τέτοια επίθεση μπορεί να γίνει από ένα υπολογιστή-επιτιθέμενο αλλά και από ένα σύνολο επιτιθέμενων υπολογιστών, που μέσω του δικτύου στέλνουν ταυτόχρονα αιτήματα σε ένα υπολογιστή στόχο. Στη περίπτωση που η επίθεση γίνεται από πολλούς υπολογιστές μέσω του δικτύου ονομάζεται κατανεμημένη επίθεση άρνησης παροχής υπηρεσιών (Distributed Denial of Service DDoS attack) (Σχήμα 38). Η κατανεμημένη επίθεση γίνεται από υπολογιστές που έχουν μολυνθεί με κάποιο σχετικό ιό ή μπορεί να συμμετέχουν με τη θέληση του χρήστη σε μια επίθεση. Επίσης έχουν δημιουργηθεί ιστοσελίδες στις οποίες η DoS επίθεση προσφέρεται ως υπηρεσία που μπορεί να ενοικιαστεί με μικρό κόστος, που κυμαίνεται στα πέντε δολάρια ανά ώρα επίθεσης [78]. Σχήμα 38: Κατανεμημένη επίθεση άρνησης παροχής υπηρεσιών [79]. 62

70 Με βάση τα παραπάνω υποθέτουμε ότι θα ήταν πολύ πιθανό ο υπεύθυνος ασφαλείας ενός συστήματος να θέλει να βρει αν το σύστημα του έχει δεχτεί DoS επίθεση και αν ναι από ποιον, προκειμένου να λάβει τα απαραίτητα μέτρα. Στη συνέχεια θα αναπτυχθούν δύο προγράμματα, το πρώτο έχει σκοπό την ανίχνευση επιθέσεων τέτοιου τύπου και το δεύτερο θα εκτελεστεί αφού διαπιστωθεί ύποπτη συμπεριφορά στο σύστημα, για να βρεθούν και να αποκλειστούν οι ύποπτοι Πρόγραμμα ανίχνευσης πιθανής επίθεσης DoS Το πρόγραμμα που θα αναπτυχθεί θα πρέπει να εξετάζει αν σε μια χρονική στιγμή γίνεται υπερβολικά μεγάλος αριθμός ίδιων αιτήσεων στον εξυπηρετητή και να καταγράφει τη χρονική στιγμή και το πλήθος των αιτήσεων. Ας υποθέσουμε ότι για τον συγκεκριμένο ιστότοπο του οποίου έχουμε τα αρχεία καταγραφής, με βάση τη κίνηση που καταγράφεται, θεωρείται ύποπτο να υπάρχουν πάνω από εκατό ίδια αιτήματα για εξυπηρέτηση ανά δευτερόλεπτο. Με βάση αυτό, το πρόγραμμα θα πρέπει να επιστρέφει αν υπήρχε χρονική στιγμή που ο εξυπηρετητής δεχόταν παραπάνω από 100 ίδια αιτήματα το δευτερόλεπτο και αν ναι, τότε να μετρά τον αριθμό των αιτημάτων ανά δευτερόλεπτο και να καταγράφει τη χρονική στιγμή που έγιναν. //Ο Mapper είναι όμοιος με προηγούμενο πρόγραμμα public static class LogEntryMapper extends Mapper<Object, Text, Text, IntWritable> { private final static IntWritable one = new IntWritable(1); private Pattern p = Pattern.compile("^(\\S+) (\\S+) (\\S+) \\[([\\w:/]+\\s[+\\-]\\d{4)\\]" +" \"(.+?)\" (\\d{3) (\\S+)"); public void map(object key, Text value, Context context) throws IOException, InterruptedException { Matcher matcher = p.matcher(value.tostring()); if (matcher.matches()) { Text time = new Text(matcher.group(4)); context.write(new Text(time), one); public static class LogEntryReducer extends Reducer<Text, IntWritable, Text, IntWritable> { private IntWritable total = new IntWritable(); public void reduce(text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException { int sum = 0; for (IntWritable value : values) { sum += value.get(); 63

71 //Ελέγχουμε αν ο αριθμός αιτήσεων ανά δευτερόλεπτο είναι περισσότερο από εκατό if (sum>100){ total.set(sum); context.write(key, total); Εκτελώντας τον παραπάνω κώδικα για το συγκεκριμένο αρχείο καταγραφής θα πάρουμε τα παρακάτω αποτελέσματα: 05/Mar/2014:11:21: /Mar/2014:11:21: /Mar/2014:13:55: /Mar/2014:13:55: /Mar/2014:13:55: /Mar/2014:13:55: /Mar/2014:16:25: /Mar/2014:16:25: /Feb/2014:14:10: /Apr/2014:00:32: /Jan/2013:13:10: /Jan/2013:13:50: /Feb/2013:12:02: /Apr/2014:14:45: /Feb/2014:14:09: /Sep/2014:09:27: /Sep/2014:09:29: /Sep/2014:09:29: /Sep/2014:09:30: /Sep/2014:09:30: Σε κάθε γραμμή στην αρχή υπάρχει η ακριβής ώρα και ημερομηνία και ακολουθεί ο αριθμός αιτήσεων για εκείνη τη στιγμή. Αυτή η πληροφορία αναπαρίσταται στο Σχήμα

72 Ημερομηνία και ώρα Χρονικές στιγμές με ύποπτο αριθμό αιτημάτων 25/Sep/2014:09:30: /Sep/2014:09:30: /Sep/2014:09:29: /Sep/2014:09:29: /Sep/2014:09:27: /Feb/2014:14:09: /Apr/2014:14:45: /Feb/2013:12:02: /Jan/2013:13:50: /Jan/2013:13:10: /Apr/2014:00:32: /Feb/2014:14:10: /Mar/2014:16:25: /Mar/2014:16:25: /Mar/2014:13:55: /Mar/2014:13:55: /Mar/2014:13:55: /Mar/2014:13:55: /Mar/2014:11:21: /Mar/2014:11:21: Αριθμός ίδιων αιτημάτων ανά δευτερόλεπτο Σχήμα 39: Χρονικές στιγμές με ύποπτο αριθμό αιτημάτων. Πλέον ο διαχειριστής του συστήματος ξέρει ότι υπήρχαν είκοσι στιγμές στο διάστημα που καλύπτει το αρχείο καταγραφής που μπορούν να θεωρηθούν ύποπτες. Έτσι μετά την ανάλυση του αρχείου καταγραφής που περιέχει πάνω από εννιά εκατομμύρια μηνύματα καταγραφής ο διαχειριστής μπορεί να επικεντρωθεί σε αυτές τις είκοσι στιγμές Πρόγραμμα εύρεσης ταυτότητας επιτιθέμενου Καθώς με το προηγούμενο πρόγραμμα βρέθηκαν κάποιες ύποπτες συμπεριφορές, σαν δεύτερο βήμα στην ανάλυσή μας πρέπει να εξεταστεί η κάθε περίπτωση. Παρατηρώντας το Σχήμα 39 βλέπουμε ότι οι εφτά κύριες ύποπτες περιπτώσεις είναι σε δύο μέρες και σε πολύ κοντινές στιγμές μεταξύ τους. Αν εκείνη τη στιγμή δεν έχει γίνει κάτι άλλο στο σύστημα που να δικαιολογεί αυτή τη συμπεριφορά, πρέπει να εξεταστεί η κάθε περίπτωση. 65

73 Το πρόγραμμα που θα αναπτυχθεί θα εξετάζει μια ύποπτη χρονική στιγμή και θα βρίσκει τους πελάτες που εκείνη τη στιγμή αιτούνταν στο σύστημα. Επίσης θα μετρήσει το σύνολο των αιτήσεων που έκανε κάθε πελάτης. public static class LogEntryMapper extends Mapper<Object, Text, Text, IntWritable> { private final static IntWritable one = new IntWritable(1); private Pattern p = Pattern.compile("^(\\S+) (\\S+) (\\S+) \\[([\\w:/]+\\s[+\\-]\\d{4)\\]" +" \"(.+?)\" (\\d{3) (\\S+)"); public void map(object key, Text value, Context context) throws IOException, InterruptedException { Matcher matcher = p.matcher(value.tostring()); if (matcher.matches()) { Text ip = new Text(matcher.group(1)); if (new String(matcher.group(4)).equals("25/Sep/2014:09:29:48 ")){ context.write(new Text(ip), one); public static class LogEntryReducer extends Reducer<Text, IntWritable, Text, IntWritable> { private IntWritable total = new IntWritable(); public void reduce(text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException { int sum = 0; for (IntWritable value : values) { sum += value.get(); total.set(sum); context.write(key, total); Τρέχοντας τον παραπάνω κώδικα ενδεικτικά για τη χρονική στιγμή 25/Sep/2014:09:29:48 παίρνουμε το αποτέλεσμα ότι όλες οι αιτήσεις έγιναν από την τοπική ip οπότε μπορούμε να ελέγξουμε τον συγκεκριμένο υπολογιστή και να δούμε τι οδήγησε σε αυτή τη συμπεριφορά. Σε περίπτωση που ανιχνεύσουμε μια ύποπτη ip που θεωρούμε επιτιθέμενο, τότε μπορούμε να αποκλείσουμε τη συγκεκριμένη διεύθυνση ενημερώνοντας το firewall του συστήματός μας. 66

74 5.5 ΑΝΑΛΥΣΗ ΓΙΑ ΤΗΝ ΕΥΡΕΣΗ ΚΑΙ ΑΝΤΙΜΕΤΩΠΙΣΗ ΣΦΑΛΜΑΤΩΝ Η ανάλυση των αρχείων καταγραφής μπορεί να χρησιμοποιηθεί για να βρεθεί ο αριθμός και το είδος των σφαλμάτων, προκειμένου οι διαχειριστές του συστήματος να έχουν μια ολοκληρωμένη άποψη για τη λειτουργεία του συστήματος. Αφού γίνει η ανίχνευση των σφαλμάτων ακολουθεί η αντιμετώπιση τους. Για να γίνει αυτό θα πρέπει να εντοπιστεί το ακριβές σημείο που προκύπτει το σφάλμα και να καθοριστεί η σοβαρότητα και η συχνότητα εμφάνισής του. Για την εύρεση και αντιμετώπιση των σφαλμάτων θα αναπτυχθούν δύο προγράμματα. Το πρώτο θα αναγνωρίζει και θα μετρά την εμφάνιση του κάθε προβλήματος, παρέχοντας μια γενική εικόνα για το σύστημα. Το δεύτερο θα αναφέρει αναλυτικά πληροφορίες για το πού προέκυψε το πρόβλημα, το είδος του προβλήματος και το πόσες φορές συνέβη Πρόγραμμα εύρεσης και υπολογισμού πλήθους σφαλμάτων Όπως προαναφέρθηκε για το συγκεκριμένο αρχείο καταγραφής Apache web access log, κάθε μήνυμα καταγραφής που περιέχεται στο αρχείο έχει στο έκτο πεδίο του έναν αριθμό, που είναι ο κωδικός κατάστασης που ο εξυπηρετητής επιστρέφει πίσω στον πελάτη. Όταν αυτός ο αριθμός είναι μεγαλύτερος από το 300 σημαίνει ότι υπάρχει κάποιο πρόβλημα [75]. Έτσι το πρόγραμμά μας θα πρέπει να ελέγχει εάν το συγκεκριμένο πεδίο του κάθε μηνύματος καταγραφής, έχει κωδικό μεγαλύτερο από το 300 και αν ναι, τότε να μετρά τον αριθμό εμφάνισης του κάθε κωδικού. Ξεκινώντας το πρόγραμμά μας πρέπει να δημιουργήσουμε τη κλάση Mapper [76]. Αυτή η κλάση διαχωρίζει το αρχείο καταγραφής σε μηνύματα καταγραφής, και διαβάζει το έκτο πεδίο του κάθε μηνύματος. Στη συνέχεια ελέγχει αν αυτός ο αριθμός είναι μεγαλύτερος από το 300 και αν ναι τότε του αναθέτει τη τιμή ένα ως αριθμό εμφάνισης του συγκεκριμένου. public static class LogsMapper extends Mapper<Object, Text, Text, IntWritable> { //θα χρειαστεί για το άθροισμα στον reducer private final static IntWritable one = new IntWritable(1); private Text codenumber = new Text(); //Regular expression για το log message private Pattern p = Pattern.compile("^(\\S+) (\\S+) (\\S+) \\[([\\w:/]+\\s[+\\-]\\d{4)\\]" +" \"(.+?)\" (\\d{3) (\\S+)"); public void map(object key, Text value, Context context) throws IOException, InterruptedException{ //Χρήση της regular expression για τον καθορισμό μηνυμάτων καταγραφής 67

75 Matcher matcher = p.matcher(value.tostring()); if (matcher.matches()) { Integer httpcode = Integer.parseInt(matcher.group(6)); //Ελέγχουμε αν υπάρχει κωδικός λάθους if ( httpcode >= 300 ) { codenumber.set(matcher.group(6)); context.write(codenumber, one); Στη συνέχεια δημιουργούμε τη κλάση reducer η οποία αθροίζει το επιμέρους πλήθος εμφάνισης του κάθε κωδικού που υπολόγισε ο mapper. public static class LogsReducer extends Reducer<Text, IntWritable, Text, IntWritable> { private IntWritable total = new IntWritable(); public void reduce(text key, Iterable<IntWritable> values, Context context)throws IOException, InterruptedException { //Μετράει το πλήθος εμφάνισης του κάθε κωδικού int count = 0; for (IntWritable value : values) { count += value.get(); //Γράφει το σύνολο των εμφανίσεων του κάθε κωδικού total.set(count); context.write(key, total); Με βάση των παραπάνω κώδικα δημιουργείται το εκτελέσιμο αρχείο το οποίο θα εκτελεστεί στο Hadoop cluster. Στο Σχήμα 40 βλέπουμε πως καλείται το πρόγραμμα και πως αρχίζουν να εκτελούνται οι εργασίες Map και Reduce. Στο Σχήμα 41 βλέπουμε το αρχείο με τα αποτελέσματα που παράγει το πρόγραμμα. 68

76 Σχήμα 40: Εκτέλεση προγράμματος μέτρησης σφαλμάτων. Σχήμα 41: Αποτελέσματα εκτέλεσης προγράμματος μέτρησης σφαλμάτων. Όπως βλέπουμε στο Σχήμα 41, έχουν μετρηθεί οι φορές που εμφανίζεται κάθε κωδικός σφάλματος. Στην αριστερή στήλη υπάρχει ο κωδικός και στην δεξιά στήλη ο αντίστοιχος αριθμός εμφάνισής τους. Στο Σχήμα 42 όπου απεικονίζονται τα παραπάνω αποτελέσματα, φαίνεται ότι τα περισσότερα σφάλματα με μεγάλη διαφορά είναι με τον κωδικό 404, ο οποίος επιστρέφεται από τον εξυπηρετητή όταν το αρχείο που ζητά ο πελάτης δεν υπάρχει. 69

77 ΠΛΗΘΟΣ Συνολική εμφάνιση σφαλμάτων ΚΩΔΙΚΟΣ ΣΦΑΛΜΑΤΟΣ Σχήμα 42: Ιστόγραμμα εμφάνισης σφαλμάτων Πρόγραμμα εντοπισμού σφαλμάτων Πλέον ο διαχειριστής του συστήματος γνωρίζει το πλήθος και το είδος των σφαλμάτων, ως συνέχεια θα πρέπει να ερευνήσει και τα αίτια που προκαλούν αυτά τα σφάλματα. Ας υποθέσουμε ότι στη συγκεκριμένη περίπτωση ο διαχειριστής του συστήματος θέλει να μάθει, ποια αρχεία που δεν υπάρχουν, ζητούνται και προκαλούν τόσα πολλά σφάλματα 404. Για να βρεθούν αυτά τα αρχεία πρέπει να αλλάξει μια συνθήκη ελέγχου στον mapper και να προστεθεί μια συνθήκη ελέγχου στον reducer. Έτσι με βάση τα νέα ζητούμενα ο η κλάση mapper γίνεται : public static class LogsMapper extends Mapper<Object, Text, Text, IntWritable> { private final static IntWritable one = new IntWritable(1); private Text codenumber = new Text(); private Pattern p = Pattern.compile("^(\\S+) (\\S+) (\\S+) \\[([\\w:/]+\\s[+\\-]\\d{4)\\]" +" \"(.+?)\" (\\d{3) (\\S+)"); public void map(object key, Text value, Context context) throws IOException, InterruptedException{ 70

78 Matcher matcher = p.matcher(value.tostring()); if (matcher.matches()) { Integer httpcode = Integer.parseInt(matcher.group(6)); //Ελέγχουμε αν υπάρχει κωδικός λάθους 404 if ( httpcode == 404 ) { codenumber.set(matcher.group(6)); context.write(codenumber, one); Και η κλάση reducer γίνεται: public static class LogsReducer extends Reducer<Text, IntWritable, Text, IntWritable> { private IntWritable total = new IntWritable(); public void reduce(text key, Iterable<IntWritable> values, Context context)throws IOException, InterruptedException { int count = 0; for (IntWritable value : values) { count += value.get(); //Ελέγχουμε αν το σφάλμα έχει εμφανιστεί πάνω από 1000 φορές if (count >1000){ total.set(count); context.write(key, total); Με αυτόν τον τρόπο παράγεται ένα αρχείο που δείχνει κάθε αίτημα που έγινε στο σύστημα και προκάλεσε σφάλμα 404 περισσότερες από χίλιες φορές. Έτσι ο διαχειριστής μπορεί να βρει το ακριβές αρχείο που προκαλεί τη πλειοψηφία των σφαλμάτων 404 του συστήματος και να το διορθώσει. Στη συγκεκριμένη περίπτωση όπως φαίνεται στο Σχήμα 43 τα περισσότερα σφάλματα προκαλούνται από δύο αρχεία εικόνας, το 123_17.jpg και το main_frame_16.jpg 71

79 Αίτημα που παράγει το σφάλαμα Αρχεία που προκαλούν πάνω από 1000 σφάλαματα 404 GET /vs/stylesnewdrawn.css HTTP/1.1 GET /vs/script.js HTTP/1.1 GET /vs/jquery.validate.min.js HTTP/1.1 GET /vs/jquery-latest.js HTTP/1.1 GET /vs/css/page.css HTTP/1.1 GET /vs/bootstrap.css HTTP/1.1 GET /styles.css HTTP/1.1 GET /script.js HTTP/1.1 GET /schedule/templates/bootlab/img/glyphicons- GET /robots.txt HTTP/1.1 GET /pics/iso_qp_hos_001_560.png HTTP/1.1 GET /p4p/p_report/images/b41.jpg HTTP/1.1 GET /p4p/p_report/images/b1.jpg HTTP/1.1 GET /p4p/p_report/css/style.css HTTP/1.1 GET /p4p/jquery/jquery.calendars.persian.js HTTP/1.1 GET /p4p/images/p4p_t_19.jpg HTTP/1.1 GET /p4p/images/p4p_t_17.jpg HTTP/1.1 GET /p4p/images/main_frame_16.jpg HTTP/1.1 GET /p4p/images/bg.jpg HTTP/1.1 GET /p4p/images/123_17.jpg HTTP/1.1 GET /material/css/stylepromist.css HTTP/1.1 GET /material/calendar/calendar.js HTTP/1.1 GET /fix/stylesnewdrawn.css HTTP/1.1 GET /fix/styles.css HTTP/1.1 GET /fix/script.js HTTP/1.1 GET /fix/admin/stylesnewdrawn.css HTTP/1.1 GET /fix/admin/script.js HTTP/1.1 GET /favicon.ico HTTP/1.1 GET /favicon.ico HTTP/1.0 GET /computer_repair/main.css HTTP/1.1 GET /computer_repair/images/bac_table.png HTTP/1.1 GET /apple-touch-icon.png HTTP/1.1 GET /apple-touch-icon-precomposed.png HTTP/1.1 GET /P4P/p_report/images/b1.jpg HTTP/1.1 GET /P4P/p_report/css/style.css HTTP/1.1 GET /P4P/jquery/jquery.calendars.persian.js HTTP/1.1 GET /P4P/images/main_frame_16.jpg HTTP/1.1 GET /P4P/images/bg.jpg HTTP/1.1 GET /P4P/images/123_17.jpg HTTP/ Πλήθος εμφάνισης σφάλματος Σχήμα 43: Αρχεία που προκαλούν πάνω από 1000 σφάλματα

80 Δευτερόλεπτα 5.6 Η ΑΠΟΔΟΣΗ ΤΩΝ ΠΡΟΓΡΑΜΜΑΤΩΝ MAP/REDUCE Από τα παραπάνω προγράμματα που υλοποιήθηκαν επιλέχθηκε από κάθε κατηγορία ένα πρόγραμμα το οποίο εκτελέστηκε στο νέφος για διαφορετικές παραμέτρους. Για κάθε πρόγραμμα λήφθηκαν μετρήσεις που αφορούν τον χρόνο εκτέλεσης του, αλλάζοντας κάθε φορά των αριθμό των ενεργών κόμβων slaves και το μέγεθος του αρχείου εισόδου. Για τα πειράματα που πραγματοποιήθηκαν, χρησιμοποιήθηκαν τρία αρχεία καταγραφής με μέγεθος 1.1GB, 4.4GB και 11GB αντίστοιχα, που δημιουργήθηκαν από το πραγματικό αρχείο καταγραφής που βρέθηκε στο διαδίκτυο. Επιπλέον μετρήσεις λήφθηκαν για διαφορετικό αριθμό κόμβων slaves από ένα μέχρι τέσσερα μηχανήματα. Χρόνοι εκτέλεσης για αρχείο 1.1 GB Αριθμός κόμβων slaves Πρόγραμμα εύρεσης κίνησης ανά ημέρα Πρόγραμμα εύρεσης ταυτότητας επιτιθέμενου Πρόγραμμα εντοπισμού σφλαμάτων Σχήμα 44: Χρόνοι εκτέλεσης προγραμμάτων MapReduce για αρχείο εισόδου 1.1 GB. 73

81 Δευτερόλεπτα Δευτερόλεπτα Χρόνοι εκτέλεση για αρχείο 4.4 GB Αριθμός κόμβων slaves Πρόγραμμα εύρεσης κίνησης ανά ημέρα Πρόγραμμα εντοπισμού σφλαμάτων Πρόγραμμα εύρεσης ταυτότητας επιτιθέμενου Σχήμα 45: Χρόνοι εκτέλεσης προγραμμάτων MapReduce για αρχείο εισόδου 4,4 GB. Χρόνοι εκτέλεσης για αρχεία 11 GB Αριθμός κόμβων slaves Πρόγραμμα εύρεσης κίνησης ανά ημέρα Πρόγραμμα εντοπισμού σφλαμάτων Πρόγραμμα εύρεσης ταυτότητας επιτιθέμενου Σχήμα 46 Χρόνοι εκτέλεσης προγραμμάτων MapReduce για αρχείο εισόδου 11 GB. 74

82 Στα Σχήματα βλέπουμε τους χρόνους εκτέλεσης σε δευτερόλεπτα για τρία διαφορετικά αρχεία εισόδου διαφορετικού μεγέθους. Παρατηρούμε ότι γενικά ισχύει ότι όσο αυξάνεται το μέγεθος του αρχείου εισόδου, αυξάνεται και ο χρόνος εκτέλεσης του προγράμματος. Επίσης παρατηρούμε αύξηση στον χρόνο εκτέλεσης, όταν μειώνονται οι κόμβοι slaves με ιδιαίτερα μεγάλη αύξηση όταν μένει μόνο ένας κόμβος slave. Αυτό είναι λογικό γιατί με αυτούς τους δύο τρόπους αυξάνεται ο όγκος επεξεργασίας που αντιστοιχεί σε κάθε κόμβο άρα και ο χρόνος επεξεργασίας. Επιπλέον βλέπουμε ότι το πρώτο πρόγραμμα (μπλε) παίρνει αρκετά περισσότερο χρόνο να εκτελεστεί, αυτό γίνεται λόγω της φύσης του προγράμματος, γιατί η δική του Reduce απαιτεί πολύ παραπάνω επεξεργασία από τις Reduce των άλλων δύο προγραμμάτων. Και ενώ οι διαδικασίες Map έχουν σχεδόν τους ίδιους χρόνους εκτέλεσης, η μεγάλη διαφορά στη Reduce κάνει τη διαφορά στο τέλος. Ακόμη μπορούμε να παρατηρήσουμε ότι για το μικρότερο αρχείο δεν έχει μεγάλη διαφορά αν υπάρχουν δύο ή τέσσερεις κόμβοι, γιατί το αρχείο είναι σχετικά μικρό και η επεξεργασία που απαιτεί μπορεί να γίνει από τους δύο κόμβους και να μη χρειάζονται παραπάνω. Στο μεγαλύτερο αρχείο όμως βλέπουμε ότι ο κάθε κόμβος κάνει διαφορά, αυτό γίνεται γιατί το αρχείο απαιτεί περισσότερη επεξεργασία και ο κάθε παραπάνω κόμβος βοηθά στη μείωση του χρόνου εκτέλεσης. Τέλος παρατηρούμε ότι στο Σχήμα 46 όπου αξιοποιούνται και οι τέσσερεις κόμβοι περισσότερο λόγω του μεγάλου αρχείου εισόδου, όταν οι κόμβοι διπλασιάζονται, ο χρόνος σχεδόν υποδιπλασιάζεται. Αυτή είναι μια πολύ χρήσιμη ιδιότητα του Hadoop που βλέπουμε ότι πράγματι ισχύει. 75

83 6 ΥΛΟΠΟΙΗΣΗ ΠΡΟΓΡΑΜΜΑΤΩΝ SPARK Σε αυτό το κεφάλαιο θα υλοποιηθούν σε Spark τα αντίστοιχα προγράμματα που δημιουργήθηκαν στο Hadoop με MapReduce. Αυτά τα προγράμματα θα αφορούν την ανάλυση των αρχείων καταγραφής για την εξαγωγή στατιστικών για τη χρήση των υπηρεσιών, την ανίχνευση και αντιμετώπιση σφαλμάτων και επιθέσεων. Με αυτόν τον τρόπο θα επισημανθούν οι διαφορές μεταξύ των δύο προγραμματιστικών μοντέλων και θα δειχθεί ο διαφορετικός τρόπος γραφής του κώδικα. Και σε αυτή τη περίπτωση επιλέχθηκε η γλώσσα προγραμματισμού java για να είναι άμεση η σύγκριση με τον κώδικα του Hadoop. Επίσης θα γίνουν όμοιες μετρήσεις με αυτές που έγιναν και στο MapReduce, προκειμένου να γίνει σύγκριση της απόδοσης των δύο μοντέλων για διαφορετικές παραμέτρους. Η ανάπτυξη των προγραμμάτων θα γίνει με το eclipse και maven με τον τρόπο που περιεγράφηκε στο κεφάλαιο 5.1 προσαρμόζοντας τις αντίστοιχες παραμέτρους. Επίσης το αρχείο καταγραφής είναι ακριβώς το ίδιο με αυτό που χρησιμοποιήθηκε στο MapReduce και περιγράφεται στο κεφάλαιο 5.2. Στα προγράμματα χρησιμοποιήθηκαν προγραμματιστικές τεχνικές από το [60] και [84]. 76

84 6.1 ΑΝΑΛΥΣΗ ΓΙΑ ΤΗΝ ΕΞΑΓΩΓΗ ΣΤΑΤΙΣΤΙΚΩΝ ΧΡΗΣΗΣ ΥΠΗΡΕΣΙΩΝ Στη συνέχεια θα αναπτυχθούν δύο προγράμματα σε Spark που αφορούν την επεξεργασία αρχείων καταγραφής, προκειμένου να εξαχθούν συμπεράσματα για τη χρήση των υπηρεσιών. Το πρώτο πρόγραμμα μετρά την κατανομή της κίνησης ανά μέρα και το δεύτερο βρίσκει τις σελίδες που δέχονται τα περισσότερα ερωτήματα από τους χρήστες Πρόγραμμα εύρεσης κίνησης ανά μέρα Αυτό το πρόγραμμα όπως και το αντίστοιχο που αναπτύχθηκε για το Hadoop, θα μετρά τις αιτήσεις που γίνονται κάθε στιγμή στο σύστημα και θα τις ταξινομεί με βάση τη μέρα που έγιναν. Ο σκοπός αυτό του προγράμματος είναι να δείξει πως κατανέμεται η κίνηση στο σύστημα ανά ημέρα παρέχοντας στους διαχειριστές χρήσιμες πληροφορίες. Το πρόγραμμα που υλοποιήθηκε περιγράφεται από το παρακάτω κώδικα. public final class TrafficPerDaySpark { //Ορίζουμε τη μορφή της ημερομηνίας public static SimpleDateFormat dateformatter = new SimpleDateFormat("dd/MMMMM/yyyy:hh:mm:ss z"); // Ορίζουμε ένα πίνακα με τις ημέρες της βδομάδας private static String[] daytable = {"", "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"; //Το regular expression για το log message public static final Pattern apachelogregex = Pattern.compile("^(\\S+) (\\S+) (\\S+) \\[([\\w:/]+\\s[+\\-]\\d{4)\\]" +" \"(.+?)\" (\\d{3) (\\S+)"); //Χρήση Serialization για βελτίωση της απόδοσης στο κατανεμημένο σύστημα public static class Stats implements Serializable { private final int count; public Stats(int count) { this.count = count; public Stats merge(stats other) { return new Stats(count + other.count); public String tostring() { return String.format("count=%s", count); 77

85 public static String extractkey(string line) { //Χρήση της regular expression για τον καθορισμό μηνυμάτων καταγραφής Matcher m = apachelogregex.matcher(line); if (m.find()) { try { Date time = dateformatter.parse(m.group(4)); //Δημιουργία νέου στιγμιότυπου calendar Calendar calendar = GregorianCalendar.getInstance(); //Θέτω το calendar στη δοσμένη ημερομηνία calendar.settime(time); //Από κάθε στιγμή παίρνω την ημέρα, που θα είναι και το κλειδί int days = calendar.get(calendar.day_of_week); String dayofweek = daytable[days]; return new String (dayofweek); catch (ParseException e) { e.printstacktrace(); return new String ("null"); public static void main(string[] args) { // Δημιουργία Spark Context SparkConf sparkconf = new SparkConf().setAppName("TrafficPerDay"); JavaSparkContext jsc = new JavaSparkContext(sparkConf); //Εισαγωγή του αρχείου καταγραφής στο Spark ως RDD JavaRDD<String> dataset = jsc.textfile(args[0]); //Δημιουργία νέου RDD ζεύγους, έχοντας τη πρώτη λέξη ως κλειδί. JavaPairRDD< String, Stats> extracted = dataset.maptopair(new PairFunction<String, String, Stats>() public Tuple2< String, Stats> call(string s) { return new Tuple2<String, Stats>(extractKey(s), new Stats(1)); ); //Δημιουργία νέου RDD ζεύγους με το reducebykey που περιέχει το κλειδί και τη reduced τιμή για αυτό το κλειδί. JavaPairRDD<String, Stats> counts = extracted.reducebykey(new Function2<Stats, Stats, Stats>() public Stats call(stats stats, Stats stats2) { 78

86 ); return stats.merge(stats2); //Εμφάνιση των αποτελεσμάτων στην οθόνη List<Tuple2<String, Stats>> output = counts.collect(); for (Tuple2<?,?> t : output) { System.out.println(t._1() + "\t" + t._2()); //Πριν τελειώσει η εκτέλεση του προγράμματος σταματάμε το Spark Context jsc.stop(); Ξεκινώντας από την αρχή του κώδικα ορίζουμε τα απαραίτητα στοιχεία για να γίνει η αντιστοιχία των χρονικών στιγμών που είναι αποθηκευμένες στο αρχείο καταγραφής, σε κάποια μέρα της βδομάδας. Στη συνέχεια υλοποιούνται κάποιες βοηθητικές μεθόδους και ακολουθεί η main. Εκεί δημιουργείται το Spark Context και τα RDDs που χρειάζονται για το πρόγραμμα. Οι δύο βασικές μέθοδοι maptopair και reducebykey, αρχικά δημιουργούν ένα ζεύγος (κλειδί, τιμή) και στη συνέχεια δημιουργείται το ζεύγος (κλειδί, αριθμός εμφάνισης) αντίστοιχα. Τέλος τα αποτελέσματα εμφανίζονται στη οθόνη και σταματάει το Spark Context. Μετά την εκτέλεση του προγράμματος με είσοδο το αρχείο καταγραφής, τα αποτελέσματα είναι ίδια με αυτά του Hadoop, επιβεβαιώνοντας έτσι την ορθή λειτουργεία του προγράμματος. Σχήμα 47: Αποτελέσματα εκτέλεσης προγράμματος Spark Πρόγραμμα εύρεσης δημοφιλέστερων σελίδων Το δεύτερο πρόγραμμα, έχει σκοπό την εύρεση των δημοφιλέστερων σελίδων php όπου γίνονται τα περισσότερα ερωτήματα. Για να γίνει αυτό θα πρέπει να γίνει ταξινόμηση των αιτήσεων που αφορούν php σελίδες με βάση το πλήθος που έγιναν και στη συνέχεια να επιλεχθούν οι δέκα πρώτες. Ακολουθεί ο κώδικας του προγράμματος που δημιουργήθηκε. 79

87 public final class TopRequests { //Το regular expression για το log message//το regular expression για το log message public static final Pattern apachelogregex = Pattern.compile("^(\\S+) (\\S+) (\\S+) \\[([\\w:/]+\\s[+\\-]\\d{4)\\]" +" \"(.+?)\" (\\d{3) (\\S+)"); //Χρήση Serialization για βελτίωση της απόδοσης στο κατανεμημένο σύστημα public static class Stats implements Serializable { private final int count; public Stats(int count) { this.count = count; public Stats merge(stats other) { return new Stats(count + other.count); public String tostring() { return String.format("%s", count); //Κλάση στην οποία υλοποιείται η σύγκριση δύο tuple public static class ValueComparator<K, V> implements Comparator<Tuple2<K, V>>, Serializable { private Comparator<V> comparator; public ValueComparator(Comparator<V> comparator) { this.comparator = public int compare(tuple2<k, V> t1, Tuple2<K, V> t2) { return comparator.compare(t1._2(), t2._2()); //Κλάση στην οποία υλοποιείται η σύγκριση δύο Stats public static class LongComparator implements Comparator<Stats>, Serializable public int compare(stats a, Stats b) { if (Integer.parseInt(a.toString()) > Integer.parseInt(b.toString())) return 1; if (a.tostring().equals(b.tostring())) return 0; return -1; 80

88 public static Comparator<Stats> LONG_COMPARATOR = new LongComparator(); public static String extractkey(string line) { //Χρήση της regular expression για τον καθορισμό μηνυμάτων καταγραφής Matcher m = apachelogregex.matcher(line); if (m.find()) { String ip = m.group(1); String httpcode = m.group(6); String query = m.group(5); return new String (query); return new String ("ok"); public static void main(string[] args) { // Δημιουργία Spark Context SparkConf sparkconf = new SparkConf().setAppName("TopRequests"); JavaSparkContext jsc = new JavaSparkContext(sparkConf); //Εισαγωγή του αρχείου καταγραφής στο Spark ως RDD JavaRDD<String> dataset = jsc.textfile(args[0]); //Δημιουργία RDD που έχει μόνο μηνύματα εγγραφής με το.php JavaRDD<String> phpdataset = dataset.filter(new Function<String, Boolean>() { public Boolean call(string s) { return s.contains(".php"); ); //Δημιουργία νέου RDD ζεύγους, έχοντας τη πρώτη λέξη ως κλειδί. JavaPairRDD< String, Stats> extracted = phpdataset.maptopair(new PairFunction<String, String, Stats>() public Tuple2< String, Stats> call(string s) { return new Tuple2<String, Stats>(extractKey(s), new Stats(1)); ); //Δημιουργία νέου RDD ζεύγους με το reducebykey που περιέχει το κλειδί και τη reduced τιμή για αυτό το κλειδί. JavaPairRDD<String, Stats> counts = extracted.reducebykey(new Function2<Stats, Stats, Stats>() 81

89 ); public Stats call(stats stats, Stats stats2) { return stats.merge(stats2); //Επιλογή των 10 πρώτων και εμφάνιση των αποτελεσμάτων την οθόνη List<Tuple2<String, Stats>> output = counts.top(20, new ValueComparator<String, Stats>(LONG_COMPARATOR)); for (Tuple2<?,?> t : output) { System.out.println(t._1() + "\t" + t._2()); //Πριν τελειώσει η εκτέλεση του προγράμματος σταματάμε το Spark Context jsc.stop(); Όπως φαίνεται από τα σχόλια στον παραπάνω κώδικα η δομή που ακολουθείται είναι παρόμοια με το προηγούμενο πρόγραμμα. Σε αυτό το πρόγραμμα ωστόσο υλοποιήθηκαν επιπροσθέτως βοηθητικές συναρτήσεις για την εκτέλεση των συγκρίσεων. Επίσης εκτός από τις maptopair και reducebykey υπάρχει και μια συνάρτηση filter που καλείται στο αρχικό rdd που περιέχει το αρχείο καταγραφής, για να βρεθούν μόνο τα ερωτήματα που αφορούν php σελίδες. Εκτελώντας το πρόγραμμα που προκύπτει από τον παραπάνω κώδικα, με είσοδο το αρχείο καταγραφής παίρνουμε ως έξοδο τα αποτελέσματα που φαίνονται στο Σχήμα 48 και είναι ίδια με αυτά του αντίστοιχου προγράμματος Hadoop. Σχήμα 48: Αποτελέσματα εκτέλεσης προγράμματος εύρεσης δημοφιλέστερων σελίδων σε Spark. 82

90 6.2 ΑΝΑΛΥΣΗ ΓΙΑ ΑΝΙΧΝΕΥΣΗ ΚΑΙ ΑΝΤΙΜΕΤΩΠΙΣΗ ΕΠΙΘΕΣΕΩΝ Ακολουθούν δύο προγράμματα Spark σε java που έχουν σκοπό την ανίχνευση μιας πιθανής επίθεσης DoS και την εύρεση των επιτιθέμενων Πρόγραμμα ανίχνευσης πιθανής επίθεσης DoS Για την ανάπτυξη αυτού του προγράμματος θα κάνουμε τη παραδοχή που κάναμε και στο αντίστοιχο πρόγραμμα Hadoop. Θα υποθέσουμε δηλαδή ότι για το συγκεκριμένο σύστημα θεωρείται ύποπτο αν υπάρχουν παραπάνω από εκατό ίδια αιτήματα το δευτερόλεπτο. Έτσι το πρόγραμμα που θα αναπτυχθεί θα πρέπει να βρει αν υπήρχε χρονική στιγμή με πάνω από εκατό ίδια αιτήματα το δευτερόλεπτο και αν ναι, τότε θα πρέπει να καταγράφει τη στιγμή και τον αριθμό των αιτήσεων. Με βάση αυτά αναπτύχθηκε το παρακάτω πρόγραμμα. public final class DosAttacks { //Το regular expression για το log message public static final Pattern apachelogregex = Pattern.compile("^(\\S+) (\\S+) (\\S+) \\[([\\w:/]+\\s[+\\-]\\d{4)\\]" +" \"(.+?)\" (\\d{3) (\\S+)"); //Χρήση Serialization για βελτίωση της απόδοσης στο κατανεμημένο σύστημα public static class Stats implements Serializable { private final int count; public Stats(int count) { this.count = count; public Stats merge(stats other) { return new Stats(count + other.count); public String tostring() { return String.format("%s", count); public static String extractkey(string line) { //Χρήση της regular expression για τον καθορισμό μηνυμάτων καταγραφής Matcher m = apachelogregex.matcher(line); if (m.find()) { String time = m.group(4); return new String (time); return new String ("null"); 83

91 public static void main(string[] args) { // Δημιουργία Spark Context SparkConf sparkconf = new SparkConf().setAppName("DosAttacks"); JavaSparkContext jsc = new JavaSparkContext(sparkConf); //Εισαγωγή του αρχείου καταγραφής στο Spark ως RDD JavaRDD<String> dataset = jsc.textfile(args[0]); //Δημιουργία νέου RDD ζεύγους, έχοντας τη πρώτη λέξη ως κλειδί. JavaPairRDD< String, Stats> extracted = dataset.maptopair(new PairFunction<String, String, Stats>() public Tuple2< String, Stats> call(string s) { return new Tuple2<String, Stats>(extractKey(s), new Stats(1)); ); //Δημιουργία ενός νέου RDD ζεύγους με το reducebykey που περιέχει το κλειδί και τη reduced τιμή για αυτό το κλειδί. JavaPairRDD<String, Stats> counts = extracted.reducebykey(new Function2<Stats, Stats, Stats>() public Stats call(stats stats, Stats stats2) { return stats.merge(stats2); ); //Συνάρτηση που θα χρησιμοποιηθεί σαν φίλτρο στο rdd για να βρεθεί αν ο αριθμός των αιτήσεων είναι περισσότερες από εκατό ανά δευτερόλεπτο Function<Tuple2<String, Stats>, Boolean> WordFilter = new Function<Tuple2<String, Stats>, Boolean>() { public Boolean call(tuple2<string, Stats> input) { return (Integer.parseInt(input._2.toString()) > 100); ; JavaPairRDD<String, Stats> filtered = counts.filter(wordfilter); //Εμφάνιση των αποτελεσμάτων στην οθόνη List<Tuple2<String, Stats>> output = filtered.collect(); for (Tuple2<?,?> t : output) { System.out.println(t._1() + "\t" + t._2()); //Πριν τελειώσει η εκτέλεση του προγράμματος σταματάμε το Spark Context jsc.stop(); 84

92 Όπως φαίνεται στον κώδικα τα βασικά στοιχεία του προγράμματος είναι η maptopair, η reducebykey και η συνάρτηση WordFilter. Η maptopair δημιουργεί ζεύγη (κλειδιού, τιμής), η reducebykey δημιουργεί το ζεύγος (κλειδιού, αριθμός εμφάνισης) και τέλος η WordFilter ελέγχει αν ο αριθμός εμφάνισης είναι πάνω από εκατό. Μετά την εκτέλεση του προγράμματος με είσοδο το αρχείο καταγραφής τα αποτελέσματα φαίνονται στην παρακάτω σχήμα και είναι ίδια με αυτά του αντίστοιχου προγράμματος Hadoop. Σχήμα 49: Αποτελέσματα εκτέλεσης προγράμματος εύρεσης επιθέσεων DoS σε Spark Πρόγραμμα εύρεσης ταυτότητας επιτιθέμενου Αυτό το πρόγραμμα έχει σκοπό να ανιχνεύσει τους επιτιθέμενους προκειμένου να ληφθούν τα κατάλληλα μέτρα, όπως να ενημερωθεί το firewall του συστήματος. Ο σκοπός του είναι να εξετάσει σε μια ύποπτη χρονική στιγμή, ποιοι χρήστες αιτούνταν στο σύστημα. Η χρονική στιγμή που επιλέχθηκε είναι η 25/Sep/2014:09:29:48, γιατί σύμφωνα με το προηγούμενο πρόγραμμα τότε έγιναν οι περισσότερες αιτήσεις. public final class FindAttackers { //Το regular expression για το log message public static final Pattern apachelogregex = Pattern.compile("^(\\S+) (\\S+) (\\S+) \\[([\\w:/]+\\s[+\\-]\\d{4)\\]" +" \"(.+?)\" (\\d{3) (\\S+)"); //Χρήση Serialization για βελτίωση της απόδοσης στο κατανεμημένο σύστημα public static class Stats implements Serializable { 85

93 private final int count; public Stats(int count) { this.count = count; public Stats merge(stats other) { return new Stats(count + other.count); public String tostring() { return String.format("%s", count); public static String extractkey(string line) { //Χρήση της regular expression για τον καθορισμό μηνυμάτων καταγραφής Matcher m = apachelogregex.matcher(line); if (m.find()) { String ip = m.group(1); return new String (ip); return new String ("null"); public static void main(string[] args) { // Δημιουργία Spark Context SparkConf sparkconf = new SparkConf().setAppName("FindAttackers"); JavaSparkContext jsc = new JavaSparkContext(sparkConf); //Εισαγωγή του αρχείου καταγραφής στο Spark ως RDD JavaRDD<String> dataset = jsc.textfile(args[0]); //Δημιουργία RDD που έχει μόνο μηνύματα εγγραφής με το 25/Sep/2014:09:29:48 JavaRDD<String> errors = dataset.filter(new Function<String, Boolean>() { public Boolean call(string s) { return s.contains("25/sep/2014:09:29:48 "); ); //Δημιουργία ενός νέου RDD ζεύγους, έχοντας τη πρώτη λέξη ως κλειδί. JavaPairRDD< String, Stats> extracted = errors.maptopair(new PairFunction<String, String, Stats>() public Tuple2< String, Stats> call(string s) { return new Tuple2<String, Stats>(extractKey(s), new Stats(1)); 86

94 ); //Δημιουργία νέου RDD ζεύγους με το reducebykey που περιέχει το κλειδί και τη reduced τιμή για αυτό το κλειδί. JavaPairRDD<String, Stats> counts = extracted.reducebykey(new Function2<Stats, Stats, Stats>() public Stats call(stats stats, Stats stats2) { return stats.merge(stats2); ); //Συνάρτηση που θα χρησιμοποιηθεί σαν φίλτρο στο rdd για να βρεθεί αν ο αριθμός των αιτήσεων είναι περισσότερες από εκατό ανά δευτερόλεπτο Function<Tuple2<String, Stats>, Boolean> WordFilter = new Function<Tuple2<String, Stats>, Boolean>() { public Boolean call(tuple2<string, Stats> input) { return (Integer.parseInt(input._2.toString()) > 100); ; JavaPairRDD<String, Stats> filtered = counts.filter(wordfilter); //Εμφάνιση των αποτελεσμάτων στην οθόνη List<Tuple2<String, Stats>> output = filtered.collect(); for (Tuple2<?,?> t : output) { System.out.println(t._1() + "\t" + t._2()); //Πριν τελειώσει η εκτέλεση του προγράμματος σταματάμε το Spark Context jsc.stop(); Τρέχοντας τον παραπάνω κώδικα ενδεικτικά για τη χρονική στιγμή 25/Sep/2014:09:29:48 παίρνουμε το αποτέλεσμα ότι όλες οι αιτήσεις έγινα από την τοπική ip

95 6.3 ΑΝΑΛΥΣΗ ΓΙΑ ΤΗΝ ΕΥΡΕΣΗ ΚΑΙ ΑΝΤΙΜΕΤΩΠΙΣΗ ΣΦΑΛΜΑΤΩΝ Στη συνέχεια θα ακολουθήσουν δύο προγράμματα που σκοπό έχουν την ανίχνευση και τη διόρθωση των σφαλμάτων που συμβαίνουν στο σύστημα. Αυτά τα προγράμματα θα αναπτυχθούν για το spark και είναι αντίστοιχα αυτών που έχουν αναπτυχθεί για το Hadoop Πρόγραμμα υπολογισμού πλήθους σφαλμάτων Στη συγκεκριμένη περίπτωση θυμίζουμε ότι το σύστημα για το οποίο έχουμε τα αρχεία καταγραφής είναι ένας ιστότοπος και τα αρχείο καταγραφής είναι Apache web access logs. Έτσι κάθε σφάλμα καταγράφεται σε αυτό το αρχείο με έναν αριθμό μεγαλύτερο του 300, που αντιστοιχεί σε διάφορους τύπους σφαλμάτων. Στον κώδικα που ακολουθεί φαίνεται πως υλοποιήθηκε το συγκεκριμένο πρόγραμμα. public final class ErrorsCount { //Το regular expression για το log message public static final Pattern apachelogregex = Pattern.compile("^(\\S+) (\\S+) (\\S+) \\[([\\w:/]+\\s[+\\-]\\d{4)\\]" +" \"(.+?)\" (\\d{3) (\\S+)"); //Χρήση Serialization για βελτίωση της απόδοσης στο κατανεμημένο σύστημα public static class Stats implements Serializable { private final int count; public Stats(int count) { this.count = count; public Stats merge(stats other) { return new Stats(count + other.count); public String tostring() { return String.format("%s", count); public static String extractkey(string line) { //Χρήση της regular expression για τον καθορισμό μηνυμάτων καταγραφής Matcher m = apachelogregex.matcher(line); if (m.find()) { String ip = m.group(1); String httpcode = m.group(6); String query = m.group(5); return new String (httpcode); return new String ("ok"); 88

96 public static void main(string[] args) { // Δημιουργία Spark Context SparkConf sparkconf = new SparkConf().setAppName("ErrorsCount"); JavaSparkContext jsc = new JavaSparkContext(sparkConf); //Εισαγωγή του αρχείου καταγραφής στο Spark ως RDD JavaRDD<String> dataset = jsc.textfile(args[0]); //Δημιουργία νέου RDD ζεύγους, έχοντας τη πρώτη λέξη ως κλειδί. JavaPairRDD< String, Stats> extracted = dataset.maptopair(new PairFunction<String, String, Stats>() public Tuple2< String, Stats> call(string s) { return new Tuple2<String, Stats>(extractKey(s), new Stats(1)); ); //Συνάρτηση που θα χρησιμοποιηθεί σαν φίλτρο στο rdd για να βρεθεί αν ο κωδικός είνaι μεγαλύτερος από 300 Function<Tuple2<String, Stats>, Boolean> WordFilter = new Function<Tuple2<String, Stats>, Boolean>() { public Boolean call(tuple2<string, Stats> input) { return (Integer.parseInt(input._1()) > 300); ; JavaPairRDD<String, Stats> result = extracted.filter(wordfilter); //Δημιουργία νέου RDD ζεύγους με το reducebykey που περιέχει το κλειδί και τη reduced τιμή για αυτό το κλειδί. JavaPairRDD<String, Stats> counts = result.reducebykey(new Function2<Stats, Stats, Stats>() public Stats call(stats stats, Stats stats2) { return stats.merge(stats2); ); //Εμφάνιση των αποτελεσμάτων στην οθόνη List<Tuple2<String, Stats>> output = counts.collect(); for (Tuple2<?,?> t : output) { System.out.println(t._1() + "\t" + t._2()); //Πριν τελειώσει η εκτέλεση του προγράμματος σταματάμε το Spark Context jsc.stop(); 89

97 Και σε αυτή τη περίπτωση τα αποτελέσματα που προκύπτουν είναι ίδια με αυτά του αντίστοιχου προγράμματος Hadoop (Σχήμα 50). Σχήμα 50: Αποτελέσματα εκτέλεσης προγράμματος εύρεσης επιθέσεων σφαλμάτων σε Spark Πρόγραμμα εύρεσης σφαλμάτων Το τελευταίο πρόγραμμα που υλοποιήθηκε έχει σκοπό την εύρεση των αιτημάτων στο σύστημα που προκαλούν πάνω από χίλια σφάλματα 404. public final class ErrorTetrak{ //Το regular expression για το log message public static final Pattern apachelogregex = Pattern.compile("^(\\S+) (\\S+) (\\S+) \\[([\\w:/]+\\s[+\\-]\\d{4)\\]" +" \"(.+?)\" (\\d{3) (\\S+)"); //Χρήση Serialization για βελτίωση της απόδοσης στο κατανεμημένο σύστημα public static class Stats implements Serializable { private final int count; public Stats(int count) { this.count = count; public Stats merge(stats other) { return new Stats(count + other.count); public String tostring() { return String.format("%s", count); 90

98 public static Tuple2<String, String> extractkey(string line) { //Χρήση της regular expression για τον καθορισμό μηνυμάτων καταγραφής Matcher m = apachelogregex.matcher(line); if (m.find()) { String ip = m.group(1); String httpcode = m.group(6); String query = m.group(5); return new Tuple2<String, String>(httpcode, query); return new Tuple2<String, String>(null, null); public static void main(string[] args) { // Δημιουργία Spark Context SparkConf sparkconf = new SparkConf().setAppName("ErrorTetrak"); JavaSparkContext jsc = new JavaSparkContext(sparkConf); //Εισαγωγή του αρχείου καταγραφής στο Spark ως RDD JavaRDD<String> dataset = jsc.textfile(args[0]); //Δημιουργία RDD που έχει μόνο μηνύματα εγγραφής με 404 JavaRDD<String> errordataset = dataset.filter(new Function<String, Boolean>() { public Boolean call(string s) { return s.contains("404"); ); //Δημιουργία νέου RDD ζεύγους, έχοντας τη πρώτη λέξη ως κλειδί. JavaPairRDD< Tuple2<String, String>, Stats> extracted = errordataset.maptopair(new PairFunction<String, Tuple2<String, String>, Stats>() public Tuple2< Tuple2<String, String>, Stats> call(string s) { return new Tuple2<Tuple2<String, String>, Stats>(extractKey(s), new Stats(1)); ); //Δημιουργία νέου RDD ζεύγους με το reducebykey που περιέχει το κλειδί και τη reduced τιμή για αυτό το κλειδί. JavaPairRDD<Tuple2<String, String>, Stats> counts = extracted.reducebykey(new Function2<Stats, Stats, Stats>() public Stats call(stats stats, Stats stats2) { return stats.merge(stats2); 91

99 ); //Συνάρτηση που θα χρησιμοποιηθεί σαν φίλτρο στο rdd για να βρεθεί αν το πλήθος των σφαλμάτων 404 είναι περισσότερο από 1000 Function<Tuple2<Tuple2<String, String>, Stats>, Boolean> longwordfilter = new Function<Tuple2<Tuple2<String, String>, Stats>, Boolean>() { public Boolean call(tuple2<tuple2<string, String>, Stats> input) { return (Integer.parseInt(input._2.toString()) > 1000); ; JavaPairRDD<Tuple2<String, String>, Stats> result = counts.filter(longwordfilter); //Εμφάνιση των αποτελεσμάτων στην οθόνη List<Tuple2<Tuple2<String, String>, Stats>> output = result.collect(); for (Tuple2<?,?> t : output) { System.out.println(t._1() + "\t" + t._2()); //Πριν τελειώσει η εκτέλεση του προγράμματος σταματάμε το Spark Context jsc.stop(); Σε αυτό το πρόγραμμα χρησιμοποιήθηκαν δύο φίλτρα. Στην αρχή για να δημιουργηθεί ένα RDD που έχει εγγραφές με τον κωδικό 404 και στη συνέχεια η συνάρτηση longwordfilter για να ελέγξει αν ο αριθμός εμφάνισης του συγκεκριμένου αιτήματος είναι μεγαλύτερος από χίλια. Τα αποτελέσματα εκτέλεσης αυτού του προγράμματος φαίνονται στο Σχήμα

100 Σχήμα 51: Αποτελέσματα εκτέλεσης προγράμματος εύρεσης σφαλμάτων 404 με εμφάνιση πάνω από 1000 φορές σε Spark. 93

101 Δευερόλεπτα 6.4 Η ΑΠΟΔΟΣΗ ΤΩΝ ΠΡΟΓΡΑΜΜΑΤΩΝ Σε αντιστοιχία με τις μετρήσεις που λήφθηκαν για τα προγράμματα Hadoop για διάφορες παραμέτρους, θα ληφθούν οι αντίστοιχες μετρήσεις για τα προγράμματα Spark. Από τα προγράμματα Spark που υλοποιήθηκαν επιλέχθηκε από κάθε κατηγορία ένα πρόγραμμα το οποίο εκτελέστηκε στο νέφος για διαφορετικές παραμέτρους. Για κάθε πρόγραμμα πραγματοποιήθηκαν μετρήσεις που αφορούν τον χρόνο εκτέλεσης του, αλλάζοντας κάθε φορά των αριθμό των ενεργών κόμβων slaves και το μέγεθος του αρχείου εισόδου. Για αυτές τις μετρήσεις η εκτέλεση των προγραμμάτων έγινε ως standalone Spark εφαρμογές. Τα προγράμματα Spark μπορούν να εκτελεστούν ως standalone Spark εφαρμογές ή να εκτελεστούν με το YARN. Το στήσιμο του συγκεκριμένου συστήματος υποστηρίζει και τους δύο τρόπους εκτέλεσης, για τους οποίους έγιναν μετρήσεις για να εντοπιστούν οι διαφορές τους. Για τα πειράματα που πραγματοποιήθηκαν, εκτελέστηκαν τα προγράμματα εύρεσης των δέκα δημοφιλέστερων αιτήσεων σε σελίδες, πρόγραμμα εύρεσης ύποπτων για DoS επίθεση στιγμών και το πρόγραμμα μέτρησης σφαλμάτων. Χρησιμοποιήθηκαν τρία αρχεία καταγραφής με μέγεθος 1.1GB, 4.4GB και 11GB αντίστοιχα, που παράχθηκαν από το πραγματικό αρχείο καταγραφής που βρέθηκε στο διαδίκτυο. Επιπλέον μετρήσεις λήφθηκαν για διαφορετικό αριθμό κόμβων slaves από ένα μέχρι τέσσερα μηχανήματα. Χρόνοι εκτέλεσης για αρχείο 1.1 GB Αριθμός κόμβων slaves Πρόγραμμα εύρεσης 10 δημοφιλέστερων σελίδων Πρόγραμμα εύρεσης στιγμών πιθανών για DoS επίθεση Πρόγραμμα μέτρησης σφαλμάτων Σχήμα 52: Χρόνοι εκτέλεσης προγραμμάτων Spark για αρχείο εισόδου 1.1 GB. 94

102 Δευτερόλεπτα Δευτερόλεπτα Χρόνοι εκτέλεσης για αρχείο 4.4 GB Αριθμός κόμβων slaves Πρόγραμμα εύρεσης 10 δημοφιλέστερων σελίδων Πρόγραμμα εύρεσης στιγμών πιθανών για DoS επίθεση Πρόγραμμα μέτρησης σφαλμάτων Σχήμα 53: Χρόνοι εκτέλεσης προγραμμάτων Spark για αρχείο εισόδου 4.4 GB. Χρόνοι ετκέλεσης για αρχείο 11 GB Αριθμός κόμβων slaves Πρόγραμμα εύρεσης 10 δημοφιλέστερων σελίδων Πρόγραμμα εύρεσης στιγμών πιθανών για DoS επίθεση Πρόγραμμα μέτρησης σφαλμάτων Σχήμα 54: Χρόνοι εκτέλεσης προγραμμάτων Spark για αρχείο εισόδου 11 GB. 95

103 Δευτερόλεπτα Στα παραπάνω Σχήματα βλέπουμε τους χρόνους εκτέλεσης σε δευτερόλεπτα για τρεις εισόδους διαφορετικού μεγέθους. Αυτές οι μετρήσεις δείχνουν πως αντιδρά το Spark σε διάφορες παραμέτρους και δεν αποτελούν σύγκριση με τα αντίστοιχα προγράμματα του Hadoop, πράγμα που θα εξεταστεί στη συνέχεια. Γενικά παρατηρούμε και σε αυτές τις περιπτώσεις ότι όσο αυξάνεται το μέγεθος του αρχείου εισόδου αυξάνεται και ο χρόνος εκτέλεσης του προγράμματος. Επίσης παρατηρούμε αύξηση στον χρόνο εκτέλεσης όταν μειώνονται οι κόμβοι slaves με ιδιαίτερα μεγάλη αύξηση όταν μένει μόνο ένας κόμβος slave. Αυτό είναι λογικό γιατί με αυτούς τους δύο τρόπους αυξάνεται ο όγκος επεξεργασίας που αντιστοιχεί σε κάθε κόμβο άρα και ο χρόνος επεξεργασίας. Επιπλέον βλέπουμε ότι τα τρία προγράμματα έχουν διαφορετικούς χρόνους εκτέλεσης και μάλιστα διατηρούν την σειρά με την οποία ολοκληρώνονται. Δηλαδή το τρίτο πρόγραμμα (γκρι) κάνει τον λιγότερο χρόνο, ακολουθεί το πρώτο (μπλε) και τέλος το δεύτερο (πορτοκαλί). Αυτό γίνεται γιατί τα προγράμματα απαιτούν διαφορετικό αριθμό και είδος υπολογισμών, έτσι όσο λιγότερους υπολογισμούς και πιο απλούς εκτελεί ένα πρόγραμμα, τόσο πιο γρήγορα θα τελειώσει η εκτέλεσή του. Ακόμη παρατηρούμε ότι για το αρχείο μεγέθους 1.1 GB δεν έχει μεγάλη διαφορά αν υπάρχουν δύο έως τέσσερεις κόμβοι, γιατί το αρχείο είναι σχετικά μικρό και η επεξεργασία που απαιτεί μπορεί να γίνει από δύο κόμβους χωρίς να χρειάζονται παραπάνω. Για το μεγάλο αρχείο των 11 GB βλέπουμε ότι ο κάθε κόμβος κάνει διαφορά, αυτό γίνεται γιατί το αρχείο απαιτεί περισσότερη επεξεργασία και μπορεί να συμβάλει σε αυτό ο κάθε παραπάνω κόμβος. Χρόνοι εκτέλεσης Spark σε yarn και Spark standalone Yarn cluster-mode Yarn client-mode Standalone Τρόπος εκτέλεσης προγραμμάτων Πρόγραμμα εύρεσης 10 δημοφιλέστερων σελίδων Πρόγραμμα εύρεσης στιγμών πιθανών για DoS επίθεση Πρόγραμμα μέτρησης σφαλμάτων Σχήμα 55: Χρόνοι εκτέλεσης προγραμμάτων σε yarn και standalone. 96

104 Επίσης αυτά τα τρία προγράμματα εκτελέστηκαν για το ίδιο αρχείο εισόδου 1.1 GB στο ίδιο cluster αλλά με διαφορετικό τρόπο. Στο Σχήμα 55 φαίνεται η διαφορά στον χρόνο εκτέλεσης ανάλογα με το αν καλούνται για να τρέξουν με το YARN ή standalone. H εκτέλεση των προγραμμάτων Spark στο YARN προσφέρει επιπλέον δυνατότητες, όπως ο έλεγχος και η δυναμική διαχείριση των πόρων του cluster, ασφάλεια μέσω του πρωτοκόλλου Kerberos, δυνατότητα παράλληλης εκτέλεσης διαφόρων προγραμμάτων (π.χ. MapReduce, Hive) αλλά και άλλες δυνατότητες που δεν υποστηρίζει το standalone. Ωστόσο όπως φαίνεται στο Σχήμα 55 η εκτέλεση των προγραμμάτων στο YARN είναι αρκετά πιο αργή. Στη περίπτωση του clustermode, ο driver τρέχει σε μια διεργασία του master που διαχειρίζεται το YARN. Στην περίπτωση του client-mode ο driver τρέχει σε διεργασία του client και ο master ζητάει μόνο πόρους από το YARN [85]. Επίσης στο κάλεσμα των εφαρμογών στο standalone η διεύθυνση του master δίνεται ως παράμετρος στο κάλεσμα, ενώ στο YARN η διεύθυνση του master διαβάζεται από το αρχείο ρυθμίσεων του Hadoop. Με βάση λοιπόν ότι το YARN είναι αρκετά πολύπλοκο σε σχέση με το Spark standalone στη διαχείριση των πόρων και τον χρονοπρογραμματισμό, μπορεί να εξηγηθεί η διαφορά στο χρόνο εκτέλεσης. 97

105 7 ΑΝΑΛΥΣΗ ΜΕ ΤΥΠΟΥ SQL ΕΡΩΤΗΜΑΤΑ 7.1 ΕΚΤΕΛΕΣΗ SQL ΕΡΩΤΗΜΑΤΩΝ ΣΤΟ HADOOP Για την εκτέλεση SQL ερωτημάτων με τη μορφή εργασιών MapReduce στο Hadoop, επιλέχτηκε το Apache Hive [39] Το Apache Hive Το Hive αναπτύχθηκε από το Facebook για να λειτουργεί με το Hadoop, με σκοπό να καλύψει τις ανάγκες της εταιρίας για την γρήγορη εκτέλεση ερωτημάτων σε μεγάλο όγκο δεδομένων [82]. Αν και η SQL δεν είναι κατάλληλη για κάθε πρόβλημα που αφορά τα δεδομένα, μπορεί να χρησιμοποιηθεί με ευκολία από πολλούς ανθρώπους της πληροφορικής και είναι πιο εύκολος τρόπος από το να γραφτεί ένα πρόγραμμα MapReduce σε java, ή κάποια άλλη γλώσσα. Το Hive μετατρέπει τα ερωτήματα SQL σε MapReduce εργασίες, προκειμένου να εκτελεστούν σε ένα Hadoop cluster. Δεν παράγει προγράμματα Java MapReduce, αλλά γενικά modules Mapper και Reducer που ρυθμίζονται από ένα αρχείο XML [81]. Το Hive επικοινωνεί με το JobTracker για να ξεκινήσει η εργασία MapReduce, ωστόσο δεν απαιτείται να τρέχει στον ίδιο κόμβο με τον JobTracker. Το Hive οργανώνει τα δεδομένα σε πίνακες, οι οποίοι παρέχουν ένα μέσο για τη δόμηση των δεδομένων που είναι αποθηκευμένα στο HDFS. Τα μεταδεδομένα που αφορούν τους πίνακες, αποθηκεύονται σε μια βάση δεδομένων που ονομάζεται metastore. 98

106 Υπάρχουν διάφορες διεπαφές που μπορεί κάποιος να αλληλεπιδράσει για να χρησιμοποιήσει το Hive [81]. Υπάρχει η διεπαφή της γραμμής εντολών (CLI, command-line interface) και διάφορες γραφικές διεπαφές χρήστη, εμπορικές ή ανοιχτού κώδικα όπως το Karmasphere και το Hue της Cloudera. Σε αυτή την εργασία θα χρησιμοποιηθεί η CLI διεπαφή Εγκατάσταση Hive Αρχικά γίνεται λήψη του συμπιεσμένου αρχείου που περιέχει το Hive. Αφού ολοκληρωθεί η λήψη, αποσυμπιέζουμε το αρχείο και το μετονομάζουμε σε hive για ευκολία, με τις παρακάτω εντολές: #wget archive.apache.org/dist/hive/hive /apache-hive bin.tar.gz #tar -xzvf apache-hive bin.tar.gz #mv apache-hive bin hive Στη συνέχεια πρέπει να οριστούν μερικές απαραίτητες μεταβλητές. Στο αρχείο ~/.bashrc προσθέτουμε τα παρακάτω: # Set HIVE_HOME export HIVE_HOME="/usr/local/hive" PATH=$PATH:$HIVE_HOME/bin export PATH Στο αρχείο hive-config.sh προσθέτουμε: export HADOOP_HOME=/usr/local/Hadoop Τέλος δημιουργούμε του καταλόγους του Hive στο HDFS και του δίνουμε δικαιώματα ανάγνωσης εγγραφής για τους πίνακες. hadoop fs -mkdir /user/root/warehouse hadoop fs -chmod g+w /user/root/warehouse Με την εντολή hive ελέγχουμε τη λειτουργία του Hive και όπως βλέπουμε στο Σχήμα 56 το Hive δουλεύει και είναι έτοιμο να δεχθεί εντολές. 99

107 Σχήμα 56: Εκκίνηση Hive Δημιουργία πινάκων Για να μπορούν να γίνονται ερωτήσεις SQL στα δεδομένα θα πρέπει να δομηθούν σε μορφή πινάκων. Καθώς τα αρχεία καταγραφής είναι ήδη στο HDFS (από προηγούμενη επεξεργασία με το Hadoop) το αποτελεσματικότερο είναι να χρησιμοποιηθούν αυτά τα αρχεία, αντί να ακολουθηθεί η διαδικασία δημιουργίας πινάκων και εισαγωγής δεδομένων από την αρχή στο Hive. Δηλαδή αντί να αποθηκεύσουμε αντίγραφα των δεδομένων που θέλουμε να δομήσουμε σε πίνακες στο warehouse του Hive, που είναι στην ουσία κατάλογος του HDFS, χρησιμοποιούμε αυτά που είναι ήδη αποθηκευμένα στο HDFS, εξοικονομώντας πολύ χώρο από τις διπλοεγγραφές. Το Hive μπορεί εύκολα να χρησιμοποιήσει αυτά τα δεδομένα καθώς με τη δημιουργία του πίνακα ορίζονται οι σχέσεις στο Hive metastore Για να δημιουργηθεί πίνακας με ήδη υπάρχοντα δεδομένα θα χρησιμοποιηθεί η παράμετρος external. Επίσης για τον καθορισμό των πεδίων κάθε εγγραφής θα χρησιμοποιηθεί regular expression [76] [83]. Με βάση τα όσα περιεγράφηκαν εκτελούνται οι εντολές που φαίνονται στο Σχήμα 57 σε χρόνο μόλις 0.28 δευτερολέπτων. Ο πίνακας όπως φαίνεται και από το Σχήμα 57 θα έχει τα πεδία host STRING, identity STRING, user STRING, time STRING, request STRING, status INT, size STRING. Στη συνέχεια τρέχουμε τη κατάλληλη εντολή SQL για να δούμε τα πρώτα 20 μηνύματα καταγραφής από τον πίνακα, για να επιβεβαιωθεί ότι πράγματι ο πίνακας έχει δημιουργηθεί σωστά. Στο Σχήμα 58 φαίνονται οι διεργασίες MapReduce που δημιουργήθηκαν καθώς οι χρόνοι και τα αποτελέσματα του συγκεκριμένου ερωτήματος SQL. Σχήμα 57: Δημιουργία πίνακα στο Hive. 100

108 Σχήμα 58: Εκτέλεση ερωτήματος SQL επιστροφής 20 πρώτων εγγραφών Εκτέλεση ερωτημάτων στο Hive Πλέον το Hive τρέχει και στη διεπαφή του μπορεί να εκτελεστεί οποιοδήποτε ερώτημα SQL (που υποστηρίζει το Hive) και να εξαχθούν συμπεράσματα χωρίς να γραφτεί ούτε μια γραμμή κώδικα προγράμματος MapReduce. Θα εκτελεστούν ενδεικτικά τα ερωτήματα που έχουν να κάνουν με την εύρεση και αντιμετώπιση των σφαλμάτων και έχουν τον ίδιο σκοπό με τα δύο αντίστοιχα προγράμματα που υλοποιήθηκαν σε java. κώδικας SQL: Για την εύρεση του αριθμού εμφάνισης του κάθε σφάλματος θα εκτελεστεί ο παρακάτω SELECT status, count(*) FROM ApacheWebLogs GROUP BY status HAVING status > 300; 101

109 Ο παραπάνω κώδικας αν και είναι μόνο 4 γραμμές, εκτελεί την ίδια λειτουργία με το πρόγραμμα java του κεφαλαίου Στο Σχήμα 59 φαίνεται ότι πράγματι επιστρέφει τα ίδια αποτελέσματα με το αντίστοιχο πρόγραμμα σε java. Σχήμα 59: Εκτέλεση ερωτήματος SQL εύρεσης πλήθους λαθών στο Hive. Στη συνέχεια εκτελέστηκε ο παρακάτω κώδικας SQL για να βρεθούν οι αιτήσεις που προκαλούν πάνω από χίλια σφάλματα 404. SELECT request, COUNT(status) AS countst FROM ApacheWebLogs WHERE status=404 GROUP BY request HAVING countst > 1000; Και σε αυτή τη περίπτωση, η υλοποίηση με ερωτήματα SQL είναι εξαιρετικά πιο απλή από τη συγγραφή προγράμματος MapReduce (για κάποιον που γνωρίζει SQL) και τα 102

110 αποτελέσματα που προκύπτουν είναι ίδια με αυτά του προγράμματος που υλοποιήθηκε στο κεφάλαιο και παρουσιάζονται στο Σχήμα 60. Σχήμα 60: Εκτέλεση ερωτήματος SQL εύρεσης αιτήσεων που προκαλούν πάνω από χίλια σφάλματα 404 σε Hive. Όπως έχει γίνει αντιληπτό από τα παραπάνω παραδείγματα η χρήση του Hive είναι πιο απλή σε σχέση με την υλοποίηση προγραμμάτων MapReduce. Ωστόσο για την εκτέλεση 103

111 Χρόνος εκτέλεσης πολύπλοκων διεργασιών η έκφραση των απαιτούμενων υπολογισμών με τη χρήση SQL μπορεί να είναι πολύ δύσκολη ή ακόμη και αδύνατη. Επίσης καθώς το Hive μεταφράζει σειριακά τις εντολές SQL σε διεργασίες map και reduce, για πολύπλοκα ερωτήματα SQL η απόδοση του Hive μπορεί να είναι αρκετά μειωμένη σε σχέση με κάποιο αντίστοιχο πρόγραμμα MapReduce. Αυτό γίνεται γιατί με το Hive θα παραχθούν με αυτόματο τρόπο ενδιάμεσες διεργασίες Map και Reduce οι οποίες δεν χρειάζονται. Στο Σχήμα 61 που ακολουθεί φαίνονται οι μετρήσεις που έγιναν για την εκτέλεση του προγράμματος υπολογισμού σφαλμάτων σε java MapReduce και των αντίστοιχων εντολών SQL σε Hive. Για αρχείο εισόδου 1.1 GB η απόδοση των δύο υλοποιήσεων είναι σχεδόν ίδια, ωστόσο δεν ισχύει το ίδιο για μέγεθος αρχείου εισόδου 11 GB όπου το Hive είναι σαφώς πιο αργό. Την καθυστέρηση του Hive για την επεξεργασία του μεγαλύτερου αρχείου μπορεί να εξηγήσει αυτό που ήδη περιγράφθηκε. Δηλαδή το μεγαλύτερο αρχείο σημαίνει περισσότερες άσκοπες αναγνώσεις και εγγραφές δεδομένων στον δίσκο. Εκτέλεση προγράμματος εύρεσης σφαλμάτων GB 11 GB Αρχεία καταγραφής hive java Σχήμα 61: Μέτρηση σφαλμάτων με Hive και java MapReduce. 104

112 7.2 ΕΚΤΕΛΕΣΗ SQL ΕΡΩΤΗΜΑΤΩΝ ΣΤΟ SPARK Για την εκτέλεση SQL ερωτημάτων στο Spark θα χρησιμοποιηθεί ένα εργαλείο που υπάρχει ήδη στο προγραμματιστικό πλαίσιο Spark και είναι το Spark SQL Το Spark SQL Το Spark SQL δημιουργήθηκε το 2014 και επιτρέπει την εκτέλεση ερωτημάτων σε δομημένα δεδομένα [14]. Υποστηρίζει ένα σύνολο μορφών δομημένων δεδομένων όπως JSON, δεδομένα αποθηκευμένα στο Hive και Parquet. To Spark SQL μπορεί να χρησιμοποιηθεί σε ένα πρόγραμμα Spark ως βιβλιοθήκη αλλά και από εξωτερικά εργαλεία που συνδέονται με συνδέσμους JDBC / ODBC. Ο διακομιστής JDBC λειτουργεί ως αυτόνομο πρόγραμμα driver του Spark και μπορεί να χρησιμοποιηθεί από πολλούς πελάτες. Κάθε πελάτης μπορεί να αποθηκεύσει πίνακες στη μνήμη και να εκτελέσει ερωτήματα, μοιραζόμενος με τους υπόλοιπους χρήστες τους πόρους και τα αποθηκευμένα δεδομένα που υπάρχουν στη μνήμη. Όταν τo Spark SQL χρησιμοποιείται σε κάποιο πρόγραμμα Spark παρέχει ένα σύνολο νέων δυνατοτήτων, όπως τη δυνατότητα ένωσης RDDs και SQL πινάκων. Με αυτόν τον τρόπο ξεπερνιούνται οι περιορισμοί της SQL και γίνεται εφικτό να επαναχρησιμοποιηθούν κώδικες SQL που ήδη υπάρχουν. Για την ενσωμάτωσή του στον κώδικα ενός προγράμματος Spark, το Spark SQL παρέχει ένα ειδικό τύπο RDD το SchemaRDD. Το SchemaRDD είναι ένα RDD που περιέχει μια σειρά αντικειμένων, που το καθένα είναι μια εγγραφή. Το SchemaRDD γνωρίζει επίσης το σχήμα (δηλαδή, τα πεδία δεδομένων) των σειρών του. Επίσης τα SchemaRDDs αποθηκεύουν εσωτερικά τα δεδομένα με έναν πιο αποτελεσματικό τρόπο, εκμεταλλευόμενα το σχήμα τους. Το Spark SQL μπορεί να υπάρξει με ή χωρίς το Apache Hive. Ωστόσο όταν υποστηρίζει το Hive έχει κάποιες επιπλέον δυνατότητες. Επιτρέπει τη πρόσβαση σε Hive πίνακες, στα UDFs (user-defined functions), SerDes (serialization and deserialization formats) και την εκτέλεση ερωτημάτων τύπου SQL με τη HiveQL. 105

113 7.2.2 Εκτέλεση ερωτημάτων στο Spark SQL Όπως προαναφέρθηκε οι καινοτόμες δυνατότητες του Spark SQL γίνονται εμφανείς όταν χρησιμοποιείται σε κάποιο πρόγραμμα Spark, στη δική μας περίπτωση όμως θα χρησιμοποιηθεί το Spark SQL CLI, γιατί ο σκοπός μας είναι να συγκριθούν οι κοινές λειτουργίες που έχει με το Hadoop Hive. Για τη χρησιμοποίηση του Spark SQL δεν χρειάζεται η λήψη κάποιου επιπλέον αρχείου όπως είχε γίνει με το Hive, γιατί είναι ήδη κομμάτι του Spark και βρίσκεται στο αρχείο που περιλαμβάνει το Spark. Επίσης δε θα χρειαστεί να γίνει εκ νέου εισαγωγή των αρχείων καταγραφής σε μορφή πινάκων. Το συγκεκριμένο Spark SQL υποστηρίζει το Hive, άρα το μόνο που πρέπει να γίνει είναι να ενημερωθούν τα αρχεία του Spark SQL που περιλαμβάνουν τα μεταδεδομένα για το σχήμα της βάσης, με τις πληροφορίες που βρίσκονται στα αντίστοιχα αρχεία του Hive. Με αυτόν τον τρόπο τα ίδια δεδομένα μπορούν να χρησιμοποιηθούν για δομημένη και αδόμητη επεξεργασία, με Hadoop MapReduce ή Spark,κάνοντας βέλτιστη αξιοποίηση του αποθηκευτικού χώρου, χωρίς καμία διπλοεγγραφή. Το Spark SQL CLI ξεκινά με την εντολή./bin/spark-sql. Προσθέτοντας στην προηγούμενη εντολή την παράμετρο --master spark://sparkmaster:port γίνεται εκτέλεση των εντολών στο cluster του Spark, και με τη παράμετρο --master YARN γίνεται η εκτέλεση με το YARN. Όπως εμφανίζεται στο Σχήμα 62 η διεπαφή Spark SQL CLI μοιάζει με αυτή του Ηive CLI. Σχήμα 62: Εκκίνηση Spark SQL. 106

114 Ακολουθούν οι εντολές SQL που η εκτέλεσή τους δίνει ίδια αποτελέσματα με τα δύο προγράμματα μέτρησης και ανίχνευσης σφαλμάτων. Οι SQL εντολές είναι ίδιες με αυτές που δόθηκαν στο Hive ωστόσο εκτελούνται διαφορετικά. Για την εύρεση του αριθμού εμφάνισης του κάθε σφάλματος ο κώδικας SQL είναι : SELECT status, count(*) FROM apacheweblogs GROUP BY status HAVING status > 300; Ο παραπάνω κώδικας εκτελείται στο cluster του Spark σε standalone mode. Τα αποτελέσματα που προκύπτουν και φαίνονται στο Σχήμα 63 επιβεβαιώνουν την ορθή λειτουργία του. Σχήμα 63: Εκτέλεση ερωτημάτων SQL εύρεσης πλήθους σφαλμάτων στο Spark SQL. 107

115 Στη συνέχεια εκτελέστηκαν και οι εντολές SQL προκειμένου να βρεθούν τα αίτια που προκαλούν τα σημαντικότερα σφάλματα, τα αποτελέσματα φαίνονται στο Σχήμα 64. SELECT request, COUNT(status) AS count FROM ApacheWebLogs WHERE status=404 GROUP BY request HAVING count > 1000; Σχήμα 64: Εκτέλεση ερωτήματος SQL εύρεσης αιτήσεων που προκαλούν πάνω από χίλια σφάλματα 404 σε SQL. 108

116 Δευτερόλεπτα Στο Σχήμα 65 γίνεται σύγκριση της απόδοσης του Hadoop Hive με το Spark SQL. Οι μετρήσεις έγιναν ενδεικτικά για το πρόγραμμα μέτρησης σφαλμάτων και το Spark SQL έτρεχε σε standalone λειτουργία. Οι χρόνοι εκτέλεσης του Spark SQL βελτιώνονται σημαντικά όταν γίνει αποθήκευση του πίνακα και παραμονή στη μνήμη με την εντολή CACHE TABLE tablename. Η απόδοση του Spark SQL είναι καλύτερη σε σχέση με του Hive λόγω των βελτιώσεων που έχουν γίνει για την αποφυγή εγγραφής και ανάγνωσης στον δίσκο, την αποθήκευση (caching) των πινάκων στη μνήμη αλλά και από ένα σύνολο τεχνικών που έχουν χρησιμοποιηθεί για τη βελτιστοποίηση της απόδοσης. Εκτέλεση προγράμματος εύρεσης σφαλμάτων GB 11 GB Αρχεία καταγραφής 198 Hadoop Hive Spark SQL Σχήμα 65: Σύγκρισης απόδοσης Hadoop Hive και Spark SQL. 109

117 8 ΣΥΜΠΕΡΑΣΜΑΤΑ 8.1 ΣΥΓΚΡΙΣΗ ΑΠΟΔΟΣΗΣ ΠΡΟΓΡΑΜΜΑΤΙΣΤΙΚΩΝ ΠΛΑΙΣΙΩΝ Οι μετρήσεις που έγιναν έδειξαν πως αντιδρά το κάθε σύστημα σε διάφορες αλλαγές του μεγέθους του αρχείου εισόδου, του τύπου προγράμματος και των διαθέσιμων κόμβων στο cluster. Τα δύο πλαίσια είναι άκρως παραμετροποιήσημα και η απόδοση του καθενός μπορεί να διαφέρει ανάλογα με τις ρυθμίσεις που έχουν γίνει. Ωστόσο διατηρώντας σε μεγάλο βαθμό τις προκαθορισμένες ρυθμίσεις και εκτελώντας το ίδιο πρόγραμμα για τα ίδια δεδομένα εισόδου, μπορούμε να εξάγουμε κάποιο συμπέρασμα. Για να συγκριθούν άμεσα τα δύο πλαίσια εκτελέστηκαν και στα δύο, τα προγράμματα που αφορούν την μέτρηση και την εύρεση των σφαλμάτων. Στο Σχήμα 66 φαίνεται η απόδοση των πλαισίων για το πρώτο πρόγραμμα, για αρχεία εισόδου 1.1 GB και 11 GB. Καλύτερη απόδοση παρουσιάζει το Spark, ακολουθεί το Spark SQL, και μετά με μικρή διαφορά μεταξύ τους το Hadoop και Hadoop Hive. Αυτά τα αποτελέσματα έρχονται σε πλήρη συμφωνία με όσα έχουν περιγραφεί και επιβεβαιώνουν ότι η απόδοση του Spark στη πλειοψηφία των περιπτώσεων είναι καλύτερη από αυτή του Hadoop. Το ίδιο συμπέρασμα βγαίνει και από το Σχήμα 67 όπου φαίνεται η απόδοση του δεύτερου προγράμματος για τα δύο πλαίσια. 110

118 Δευτερόλεπτα Δευτερόλεπτα Πρόγραμμα εύρεσης πλήθους λαθών Hadoop Spark Hadoop Hive Spark SQL Μέγεθος αρχείου εισόδου: 1.1 GB 11GB Σχήμα 66: Συγκριτικοί χρόνοι εκτέλεσης προγράμματος μέτρησης σφαλμάτων. Πρόγραμμα εντοπισμού σφαλμάτων Hadoop Spark Hadoop Hive Spark SQL Μέγεθος αρχείου εισόδου 1.1 GB 11GB Σχήμα 67: Συγκριτικοί χρόνοι εκτέλεσης προγράμματος εντοπισμού σφαλμάτων. 111