Μια γρήγορη ματιά στο Spark Structured Streaming + Kafka

Μάθετε τα βασικά για το πώς να χρησιμοποιείτε αυτό το ισχυρό δίδυμο για εργασίες επεξεργασίας ροής

Πρόσφατα άρχισα να μελετώ πολύ για το Apache Kafka και το Apache Spark, δύο κορυφαίες τεχνολογίες στον κόσμο της μηχανικής δεδομένων.

Έχω κάνει πολλά έργα χρησιμοποιώντας τα τους τελευταίους μήνες. "Μηχανική μάθηση ροής με Kafka, Debezium και BentoML” είναι ένα παράδειγμα. Η εστίασή μου είναι να μάθω πώς να δημιουργώ ισχυρές γραμμές δεδομένων με αυτά τα σύγχρονα διάσημα εργαλεία και να κατανοήσω τα πλεονεκτήματα και τα μειονεκτήματά τους.

Τους τελευταίους μήνες, έχω ήδη καλύψει πώς να δημιουργήσω αγωγούς ETL χρησιμοποιώντας και τα δύο εργαλεία, αλλά ποτέ χρησιμοποιώντας τα μαζί, και αυτό είναι το κενό που θα καλύψω σήμερα.

Στόχος μας είναι να μάθουμε τη γενική ιδέα πίσω από τη δημιουργία μιας εφαρμογής ροής με το Spark+Kafka και να δώσουμε μια γρήγορη ματιά στις κύριες έννοιές της χρησιμοποιώντας πραγματικά δεδομένα.

Η ιδέα είναι απλή — το Apache Kafka είναι ένα εργαλείο ροής μηνυμάτων, όπου οι παραγωγοί γράφουν μηνύματα στο ένα άκρο μιας ουράς (που ονομάζεται τοπικός) για να διαβαστεί από τους καταναλωτές από την άλλη.

Αλλά είναι ένα πολύ περίπλοκο εργαλείο, κατασκευασμένο για να είναι μια ευέλικτη υπηρεσία διανομής μηνυμάτων, με όλα τα είδη εγγυήσεων παράδοσης (ακριβώς μία φορά, μία φορά, οποιαδήποτε), αποθήκευση μηνυμάτων και αναπαραγωγή μηνυμάτων, ενώ επιτρέπει επίσης ευελιξία, επεκτασιμότητα και υψηλή απόδοση. Έχει ένα ευρύτερο σύνολο περιπτώσεων χρήσης, όπως επικοινωνία μικροϋπηρεσιών, συστήματα συμβάντων σε πραγματικό χρόνο και αγωγούς ροής ETL.

Το Apache Spark είναι μια μηχανή μετασχηματισμού δεδομένων που βασίζεται σε κατανεμημένη μνήμη.

Είναι επίσης ένα πολύ περίπλοκο εργαλείο, ικανό να συνδεθεί με κάθε είδους βάσεις δεδομένων, συστήματα αρχείων και υποδομές cloud. Είναι σχεδιασμένο να λειτουργεί σε κατανεμημένα περιβάλλοντα για να παραλληλίζει την επεξεργασία μεταξύ των μηχανών, επιτυγχάνοντας μετασχηματισμούς υψηλής απόδοσης χρησιμοποιώντας τη φιλοσοφία της τεμπέλης αξιολόγησης και τις βελτιστοποιήσεις ερωτημάτων.

Το ωραίο μέρος του είναι ότι, στο τέλος της ημέρας, ο κώδικας είναι απλώς το συνηθισμένο σας ερώτημα SQL ή (σχεδόν) το σενάριο Python+pandas, με όλη τη μαγεία να είναι αφηρημένη κάτω από ένα ωραίο φιλικό προς το χρήστη API υψηλού επιπέδου.

Ενώστε αυτές τις δύο τεχνολογίες και έχουμε το τέλειο ταίρι για τη δημιουργία ενός αγωγού ροής ETL.

Θα χρησιμοποιήσουμε τα δεδομένα από τους αισθητήρες κυκλοφορίας στην πόλη Belo Horizonte (BH), την πρωτεύουσα του Minas Gerais (Βραζιλία). Είναι ένα τεράστιο σύνολο δεδομένων που περιέχει μετρήσεις της ροής της κυκλοφορίας σε πολλά σημεία της πόλης. Κάθε αισθητήρας ανιχνεύει περιοδικά τον τύπο του οχήματος που οδηγεί σε αυτήν την τοποθεσία (αυτοκίνητο, μοτοσικλέτα, λεωφορείο/φορτηγό), την ταχύτητα και το μήκος του (και άλλες πληροφορίες που δεν πρόκειται να χρησιμοποιήσουμε).

Αυτό το σύνολο δεδομένων αντιπροσωπεύει ακριβώς μια από τις κλασικές εφαρμογές για συστήματα ροής — μια ομάδα αισθητήρων που στέλνουν τις μετρήσεις τους συνεχώς από το πεδίο.

Σε αυτό το σενάριο, το Apache Kafka μπορεί να χρησιμοποιηθεί ως στρώμα αφαίρεσης μεταξύ των αισθητήρων και των εφαρμογών που καταναλώνουν τα δεδομένα τους.

Με αυτό το είδος υποδομής, είναι δυνατή η κατασκευή όλων των ειδών (τα λεγόμενα) συστήματα που βασίζονται σε γεγονότα σε πραγματικό χρόνο, όπως ένα πρόγραμμα για τον εντοπισμό και την ειδοποίηση για κυκλοφοριακή συμφόρηση όταν ο αριθμός των οχημάτων αυξάνεται ξαφνικά με μείωση της μέσης ταχύτητας.

Και εκεί είναι που το Apache Spark μπαίνει στο παιχνίδι.

Έχει μια εγγενή ενότητα για επεξεργασία ροής που ονομάζεται Spark Structured Streaming, που μπορεί να συνδεθεί με τον Κάφκα και να επεξεργαστεί τα μηνύματά του.

Ρύθμιση του περιβάλλοντος

Το μόνο που χρειάζεστε είναι docker και docker-compose.

Θα χρησιμοποιήσουμε μια διαμόρφωση αρχείου docker-compose που βασίζεται στα ακόλουθα αποθετήρια: σύνδεσμος σπινθήρας, σύνδεσμος kafka.

Η ./src Ο τόμος είναι όπου θα βάλουμε τα σενάρια μας.

Για να ξεκινήσετε το περιβάλλον, απλώς τρέξτε

docker-συνθέστε επάνω

Όλος ο κώδικας είναι διαθέσιμος σε αυτό Αποθετήριο GitHub.

Ένα από τα πράγματα που μου άρεσε περισσότερο όταν ξεκίνησα να μελετώ το Spark ήταν η ομοιότητα μεταξύ του γραπτού κώδικα για αυτό και των συνηθισμένων μου σεναρίων python+panda. Η μετανάστευση ήταν πολύ εύκολη.

Ακολουθώντας την ίδια λογική, η ενότητα ροής του Spark μοιάζει πολύ με τον συνηθισμένο κώδικα σπινθήρα, καθιστώντας εύκολη τη μετάβαση από τις εφαρμογές παρτίδας στις εφαρμογές ροής.

Με αυτά τα λόγια, στις επόμενες ενότητες, θα επικεντρωθούμε στην εκμάθηση των ιδιαιτεροτήτων της δομημένης ροής Spark, δηλαδή, ποιες νέες δυνατότητες διαθέτει.

Η πρώτη μας δουλειά

Ας ξεκινήσουμε αργά και ας φτιάξουμε ένα παράδειγμα παιχνιδιού

Το πρώτο πράγμα που πρέπει να κάνουμε είναι να δημιουργήσουμε ένα θέμα Κάφκα από όπου η δουλειά μας θα καταναλώσει τα μηνύματα.

Αυτό γίνεται από πρόσβαση στον τερματικό σταθμό εμπορευματοκιβωτίων Kafka και εκτελώντας:

kafka-topics.sh --create --bootstrap-server localhost:9092 --topic test_topic

Για να προσομοιώσουμε έναν παραγωγό που γράφει μηνύματα για αυτό το θέμα, ας χρησιμοποιήσουμε το καφκα-κονσόλα-παραγωγός. Επίσης μέσα στο δοχείο:

kafka-console-producer.sh --bootstrap-server localhost:9092 --topic test_topic --ιδιότητα "parse.key=true" --ιδιότητα "key.separator=:"

Από τώρα, κάθε γραμμή που πληκτρολογείται στο τερματικό θα αποστέλλεται ως μήνυμα στο θέμα της δοκιμής. Ο χαρακτήρας “:” χρησιμοποιείται για να διαχωρίσει το κλειδί και την τιμή του μηνύματος (κλειδί:τιμή).

Ας δημιουργήσουμε μια δουλειά Spark για να καταναλώσουμε αυτό το θέμα.

Ο κωδικός πρέπει να μπει μέσα στο /src/streaming φάκελο (τίποτα ιδιαίτερο, μόνο ο φάκελος που επέλεξα).

Το βασικό πράγμα που πρέπει να σημειωθεί είναι ότι χρησιμοποιούμε τα χαρακτηριστικά readStream και writeStream, αντί για κανονική ανάγνωση και γραφή. Αυτή είναι η κύρια πτυχή που κάνει το Spark να αντιμετωπίζει τη δουλειά μας ως εφαρμογή ροής.

Για να συνδεθείτε στο Kafka, είναι απαραίτητο να καθορίσετε τον διακομιστή και το θέμα. Η επιλογή startingOffsets=“πιο νωρίς» λέει στο Spark να διαβάσει το θέμα από την αρχή. Επίσης, επειδή ο Κάφκα αποθηκεύει τα μηνύματά του δυαδικό μορφή, πρέπει να αποκωδικοποιηθούν κορδόνι.

Οι άλλες επιλογές θα διερευνηθούν περαιτέρω.

Τώρα, ας αποκτήσουμε πρόσβαση στο κοντέινερ Spark και ας εκτελέσουμε την εργασία.

spark-submit --packages org.apache.spark:spark-sql-kafka-0-10_2.12:3.3.0 /src/streaming/read_test_stream.py

Μετά από μερικά δευτερόλεπτα διαμόρφωσης, θα αρχίσει να καταναλώνει το θέμα.

Το Spark Streaming λειτουργεί μικρο-παρτίδα mode, και γι' αυτό βλέπουμε τις πληροφορίες "παρτίδας" όταν καταναλώνει τα μηνύματα.

Η μικροομάδα είναι κάπως μεταξύ της πλήρους «αληθινής» ροής, όπου όλα τα μηνύματα επεξεργάζονται μεμονωμένα καθώς φτάνουν, και της συνηθισμένης παρτίδας, όπου τα δεδομένα παραμένουν στατικά και καταναλώνονται κατ' απαίτηση. Το Spark θα περιμένει λίγο χρόνο προσπαθώντας να συγκεντρώσει μηνύματα για να τα επεξεργαστεί μαζί, μειώνοντας τα γενικά έξοδα και αυξάνοντας τον λανθάνοντα χρόνο. Αυτό μπορεί να προσαρμοστεί στις ανάγκες σας.

Δεν είμαι πολύ γρήγορος πληκτρολογητής, επομένως το Spark επεξεργάζεται το μήνυμα προτού μπορέσω να συμπεριλάβω νέα στην τρέχουσα παρτίδα.

Και αυτή ήταν η πρώτη μας δουλειά ροής!

Ελπίζω να έχετε την αίσθηση: δεν είναι δύσκολο να κωδικοποιήσετε μια εργασία επεξεργασίας ροής, αλλά υπάρχουν μερικά λάθη.

Εγγραφή δεδομένων σε ροή του Κάφκα

Τώρα είναι ώρα να αρχίσετε να παίζετε με τα δεδομένα του αισθητήρα.

Μπορείτε να κατεβάσετε το θέμα zip αρχείο από ΑΥΓΟΥΣΤΟΣ 2022 και εξαγάγετε το στο /δεδομένα Ενταση ΗΧΟΥ. Τα δεδομένα είναι αρχικά σε JSON και καταλαμβάνουν περίπου 23 Gb χώρου. Το πρώτο πράγμα που πρέπει να κάνετε είναι να το μετατρέψετε σε παρκέ για βελτιστοποίηση του χώρου στο δίσκο και του χρόνου ανάγνωσης.

Οι εργασίες spark για να το κάνετε αυτό περιγράφονται λεπτομερώς στο αποθετήριο GitHub, το μόνο που χρειάζεται να κάνετε είναι να τις εκτελέσετε:

spark-submit /src/transform_json_to_parquet.pyspark-submit /src/join_parquet_files.py

Ανάλογα με το μηχάνημά σας, η εκτέλεση μπορεί να διαρκέσει κάποιο χρόνο. Αλλά πληρώνει, το τελικό μέγεθος αρχείου παρκέ είναι ~1Gb (περισσότερο από 20 φορές μικρότερο) και πολύ πιο γρήγορο στην ανάγνωση.

Πρέπει επίσης να δημιουργήσουμε το θέμα Κάφκα για να λαμβάνουμε τα μηνύματά μας:

kafka-topics.sh --create --replication-factor 1 --bootstrap-server localhost:9092 --topic traffic_sensor

Προαιρετικά, εάν θέλετε να εμφανίσετε τα μηνύματα που φτάνουν, μπορείτε να ρυθμίσετε έναν καταναλωτή κονσόλας.

kafka-console-consumer.sh --topic traffic_sensor --bootstrap-server localhost:9092

Η σύνταξη δεδομένων για ένα θέμα του Κάφκα είναι εύκολη, αλλά έχει κάποιες λεπτομέρειες.

Στη δομημένη ροή, η προεπιλεγμένη συμπεριφορά είναι να μην προσπαθήσουμε να συμπεράνουμε το σχήμα δεδομένων (στήλες και τους τύπους τους), επομένως πρέπει να περάσουμε ένα.

Τα μηνύματα του Κάφκα είναι απλώς ζεύγη δυαδικών συμβολοσειρών κλειδιού-τιμής, επομένως πρέπει να αναπαραστήσουμε τα δεδομένα μας σε αυτήν τη μορφή. Αυτό μπορεί να επιτευχθεί εύκολα μετατρέποντας όλες τις σειρές σε συμβολοσειρές JSON, κωδικοποιώντας τες σε δυαδικό και αποθηκεύοντας το αποτέλεσμα στη στήλη "τιμή".

Τα πλήκτρα μηνυμάτων είναι πολύ σημαντικά στον Κάφκα, αλλά δεν θα είναι χρήσιμα στις δοκιμές μας, επομένως όλα τα μηνύματα θα έχουν το ίδιο.

Όπως αναφέρθηκε προηγουμένως, αυτό το σύνολο δεδομένων είναι ΤΕΡΑΣΤΙΟ, επομένως περιόρισα τον αριθμό των μηνυμάτων που εισήχθησαν σε 500,000.

Τέλος, περνάμε τον διακομιστή και το θέμα Kafka και ένα "Σημείο ελέγχου Τοποθεσία" όπου ο σπινθήρας θα αποθηκεύσει την πρόοδο της εκτέλεσης, χρήσιμη για την ανάκτηση από σφάλματα.

Εκτέλεση της εργασίας:

spark-submit --packages org.apache.spark:spark-sql-kafka-0-10_2.12:3.3.0 /src/streaming/insert_traffic_topic.py

Στα αριστερά, η εργασία Spark διαβάζει το αρχείο, στα δεξιά, α καφκα-κονσόλα-καταναλωτής εμφανίζει τα μηνύματα που φτάνουν.

Το θέμα επισκεψιμότητας είναι συμπληρωμένο και σχεδόν έτοιμο για επεξεργασία.

Είναι σημαντικό να θυμάστε ότι χρησιμοποιήσαμε μια εργασία σπινθήρα για να συμπληρώσουμε το θέμα μας μόνο για μαθησιακούς σκοπούς. Σε ένα πραγματικό σενάριο, οι ίδιοι οι αισθητήρες θα στείλουν μετρήσεις απευθείας στον Κάφκα.

Για την προσομοίωση αυτής της δυναμικής συμπεριφοράς, το παρακάτω σενάριο γράφει 1 σειρά στο θέμα κάθε 2.5 δευτερόλεπτα.

Λειτουργίες εξόδου — Μέτρηση του αριθμού των οχημάτων ανά τύπο

Προχωρώντας, ας δημιουργήσουμε μια εργασία για να μετρήσουμε τον αριθμό των οχημάτων ανά τύπο.

Η στήλη «Classificação» (Ταξινόμηση) περιέχει τον τύπο οχήματος που εντοπίστηκε.

Καθώς διαβάζουμε από το θέμα, πρέπει να μετατρέψουμε τις δυαδικές συμβολοσειρές JSON στη μορφή στήλης.

Μόλις γίνει αυτό, το ερώτημα μπορεί να δημιουργηθεί ως συνήθως. Είναι ενδιαφέρον να σημειωθεί ότι η καρδιά του ερωτήματος είναι απλώς το επιλέξτε().groupBy().μετράνε() ακολουθία, όλα τα υπόλοιπα είναι σχετικά με τη λογική ροής.

Ήρθε λοιπόν η ώρα να αντιμετωπίσουμε το OutputMode() επιλογή.

Η λειτουργία εξόδου μιας εφαρμογής ροής καθορίζει πώς θέλουμε να (επανα)υπολογίσουμε και να γράψουμε τα αποτελέσματα καθώς φτάνουν νέα δεδομένα.

Μπορεί να λάβει τρεις διαφορετικές τιμές:

• Προσαρτώ: Προσθέστε μόνο νέες εγγραφές στην έξοδο.
• Πλήρης: Υπολογίστε ξανά το πλήρες αποτέλεσμα για κάθε νέα εγγραφή.
• Ενημέρωση: Ενημέρωση αλλαγμένων εγγραφών.

Αυτές οι λειτουργίες μπορεί ή δεν μπορούν να έχουν νόημα ανάλογα με την εφαρμογή που έχει γραφτεί. Για παράδειγμα, η λειτουργία "πλήρης" μπορεί να μην έχει νόημα εάν εκτελείται οποιαδήποτε ομαδοποίηση ή ταξινόμηση.

Ας εκτελέσουμε την εργασία σε λειτουργία "πλήρης" και ας δούμε τα αποτελέσματα.

spark-submit --packages org.apache.spark:spark-sql-kafka-0-10_2.12:3.3.0 /src/streaming/group_by_vehicle_type.py

Καθώς εισάγονται νέες εγγραφές στη ροή (δείτε το τερματικό στα δεξιά), η εργασία επαναυπολογίζει το πλήρες αποτέλεσμα. Αυτό μπορεί να είναι χρήσιμο σε καταστάσεις όπου η ταξινόμηση σειρών είναι σημαντική, όπως η κατάταξη ή ο ανταγωνισμός.

Ωστόσο, αυτή η προσέγγιση μπορεί να μην είναι η βέλτιστη εάν ο αριθμός των ομάδων είναι πολύ μεγάλος ή οι μεμονωμένες αλλαγές δεν επηρεάζουν το συνολικό αποτέλεσμα.

Έτσι, μια άλλη επιλογή είναι να χρησιμοποιήσετε τη λειτουργία εξόδου "ενημέρωση", η οποία δημιουργεί ένα νέο μήνυμα μόνο για τις ομάδες που έχουν αλλάξει. Δες παρακάτω:

Η λειτουργία "προσάρτηση" δεν είναι διαθέσιμη σε ερωτήματα με ομαδοποίηση, επομένως δεν θα μπορώ να εμφανιστώ χρησιμοποιώντας την ίδια εργασία. Αλλά νομίζω ότι είναι η πιο απλή λειτουργία, αυτό πάντοτε προσθέτει μια νέα εγγραφή στην έξοδο.

Αυτές οι λειτουργίες εξόδου είναι πιο εύκολο να κατανοηθούν εάν σκέφτεστε να αποθηκεύσετε τα αποτελέσματα σε έναν πίνακα. Στη λειτουργία πλήρους εξόδου, ο πίνακας θα ξαναγραφεί για κάθε νέο μήνυμα που υποβάλλεται σε επεξεργασία, στη λειτουργία ενημέρωσης, μόνο οι γραμμές όπου έγινε κάποια ενημέρωση και το προσάρτημα θα προσθέτει πάντα μια νέα γραμμή στο τέλος.

Παράθυρο χρόνου ανατροπής — Συγκέντρωση με χρήση χρονικών διαστημάτων

Στα συστήματα ροής, τα μηνύματα έχουν δύο διαφορετικές χρονικές σημάνσεις που σχετίζονται με αυτά: Ώρα συμβάντος — Η ώρα δημιουργίας του μηνύματος, στην περίπτωσή μας ο χρόνος ανάγνωσης του αισθητήρα και χρόνος επεξεργασίας — Όταν το μήνυμα διαβάζεται από τον παράγοντα επεξεργασίας, στην περίπτωσή μας όταν φτάνει στο Spark.

Ένα σημαντικό χαρακτηριστικό των εργαλείων επεξεργασίας ροής είναι η ικανότητα χειρισμού της επεξεργασίας χρόνου συμβάντων. Τα αναδιπλούμενα παράθυρα είναι μη επικαλυπτόμενα σταθερά χρονικά διαστήματα που χρησιμοποιούνται για τη δημιουργία συναθροίσεων χρησιμοποιώντας στήλες χρόνου συμβάντων. Για να το θέσω πιο απλά, κόβουν τη γραμμή χρόνου σε φέτες ίδιου μεγέθους, ώστε κάθε συμβάν να ανήκει σε ένα μόνο διάστημα.

Για παράδειγμα, μετρήστε, κάθε 5 λεπτά, πόσα οχήματα εντοπίστηκαν τα τελευταία 5 λεπτά.

Ο παρακάτω κώδικας το δείχνει αυτό:

Αυτό το είδος επεξεργασίας μπορεί να είναι εξαιρετικά χρήσιμο σε πολλές περιπτώσεις. Επιστρέφοντας στον ανιχνευτή κυκλοφοριακής συμφόρησης που προτάθηκε νωρίτερα, μια πιθανή προσέγγιση είναι να μετρήσετε τη μέση ταχύτητα των οχημάτων σε ένα παράθυρο 10 λεπτών και να δείτε εάν είναι κάτω από ένα συγκεκριμένο όριο.

Η επεξεργασία σε χρόνο εκδήλωσης είναι ένα σύνθετο θέμα. Όλα μπορούν να συμβούν όταν το αντιμετωπίζετε, όπως χάνονται μηνύματα, φτάνουν πολύ αργά ή βγαίνουν εκτός λειτουργίας. Το Spark έχει αρκετούς μηχανισμούς για να προσπαθήσει να μετριάσει τα προβλήματα, όπως υδατογραφήματα, στα οποία δεν θα εστιάσουμε.

Τα παράθυρα χρόνου μπορούν επίσης να χρησιμοποιηθούν σε συνδυασμό με άλλες στήλες στο groupBy(). Το παρακάτω παράδειγμα μετράει τον αριθμό των οχημάτων ανά τύπο σε ένα παράθυρο 5 λεπτών.

Συρόμενο χρονικό παράθυρο — Ευελιξία στα χρονικά διαστήματα

Τα συρόμενα παράθυρα χρόνου είναι μια ευελιξία των αναδιπλούμενων παραθύρων. Αντί να δημιουργούν μη επικαλυπτόμενα διαστήματα, επιτρέπουν τον καθορισμό της συχνότητας δημιουργίας κάθε διαστήματος.

Για παράδειγμα, κάθε 5 λεπτά, μετρήστε πόσα οχήματα εντοπίστηκαν τα τελευταία 30 λεπτά.

Εξαιτίας αυτού, τα γεγονότα μπορούν να ανήκουν σε πολλά διαστήματα και να μετρηθούν όσες φορές χρειάζεται.

Για να ορίσετε ένα συρόμενο παράθυρο, απλώς περάστε το διάστημα ενημέρωσης στο παράθυρο() λειτουργία.

Ας δούμε την έξοδο.

Όπως μπορούμε να δούμε, έχουμε παράθυρα 30 λεπτών που δημιουργούνται κάθε 5 λεπτά.

Αυτή η ευελιξία μπορεί να είναι πολύ χρήσιμη για τον καθορισμό πιο συγκεκριμένων επιχειρηματικών κανόνων και πιο σύνθετων ενεργειών. Για παράδειγμα, ο ανιχνευτής κυκλοφοριακής συμφόρησης μπορεί να στέλνει απαντήσεις κάθε 5 δευτερόλεπτα περίπου τα τελευταία 10 λεπτά και να δημιουργεί μια ειδοποίηση όταν η μέση ταχύτητα του αυτοκινήτου πέσει κάτω από τα 20 χλμ/ώρα.

Αυτή ήταν μια γρήγορη ματιά στις κύριες έννοιες του Spark Structured Streaming και πώς μπορούν να εφαρμοστούν με τον Kafka.

Το Apache Kafka και το Apache Spark είναι αξιόπιστα και ισχυρά εργαλεία που χρησιμοποιούνται από πολλές εταιρείες για την καθημερινή επεξεργασία απίστευτων ποσοτήτων δεδομένων, καθιστώντας τα ένα από τα ισχυρότερα ζεύγη στην εργασία επεξεργασίας ροής.

Μάθαμε πώς να συμπληρώνουμε, να καταναλώνουμε και να επεξεργαζόμαστε θέματα Κάφκα χρησιμοποιώντας θέσεις εργασίας Spark. Αυτό δεν ήταν δύσκολο έργο, όπως αναφέρθηκε στην ανάρτηση, το API επεξεργασίας ροής είναι σχεδόν ίσο με το συνηθισμένο API παρτίδας, με μερικές μόνο μικρές προσαρμογές.

Συζητήσαμε επίσης διαφορετικές λειτουργίες εξόδου, κάτι συγκεκριμένο για εφαρμογές ροής και πώς μπορεί να χρησιμοποιηθεί η καθεμία. Τελευταίο αλλά εξίσου σημαντικό, εξερευνήσαμε συναθροίσεις με χρονικά παράθυρα, μια από τις κύριες δυνατότητες επεξεργασίας ροής.

Και πάλι, αυτή ήταν μια απλά γρήγορη ματιά, και θα αφήσω μερικές αναφορές παρακάτω εάν θέλετε να εξερευνήσετε βαθύτερα.

Ελπίζω να βοήθησα κάπως, σας ευχαριστώ που διαβάσατε! 🙂

Όλος ο κώδικας είναι διαθέσιμος σε αυτό Αποθετήριο GitHub.
Δεδομένα που χρησιμοποιούνται — Contagens Volumétricas de Radares, Άνοιγμα δεδομένων, Κυβερνήτης της Βραζιλίας.

[1] Χαρακτηριστικό Deep Dive: Watermarking στο Apache Spark Structured Streaming — Ο Max Fisher στο ιστολόγιο Databricks
[2] Chambers, B., & Zaharia, M. (2018). Spark: Ο οριστικός οδηγός: Η επεξεργασία μεγάλων δεδομένων έγινε απλή. “O'Reilly Media, Inc.”.
[3] Logistics, αποστολή και μεταφορά σε πραγματικό χρόνο με τον Apache Kafka— Kai Waehner
[4] Συμμετέχει ο Apache Kafka στο Netflix Studio and Finance World — Συνεχές ιστολόγιο
[5] Spark Streaming & Kafka — https://sparkbyexamples.com/

Μια γρήγορη ματιά στο Spark Structured Streaming + Kafka Αναδημοσίευση από την Πηγή https://towardsdatascience.com/a-fast-look-at-spark-structured-streaming-kafka-f0ff64107325?source=rss—-7f60cf5620c9—4 via /towardsdatascience.com/feed

Si al principi no tens èxit, aleshores el paracaigudisme no és per a tu.

->