स्पार्क स्ट्रिमिङको साथ अपाचे काफ्का र स्ट्रिमिङ डाटा प्रोसेसिङ

नमस्ते, Habr! आज हामी स्पार्क स्ट्रिमिङ प्रयोग गरेर Apache Kafka सन्देश स्ट्रिमहरू प्रशोधन गर्ने प्रणाली निर्माण गर्नेछौं र AWS RDS क्लाउड डाटाबेसमा प्रशोधन परिणामहरू लेख्नेछौं।

कल्पना गरौं कि एक निश्चित क्रेडिट संस्थाले हामीलाई यसको सबै शाखाहरूमा "उडानमा" आगमन लेनदेनहरू प्रशोधन गर्ने कार्य सेट गर्दछ। यो तुरुन्तै ट्रेजरी को लागी एक खुला मुद्रा स्थिति, सीमा वा लेनदेन को लागी वित्तीय परिणाम, आदि को लागी गणना को उद्देश्य को लागी गर्न सकिन्छ।

जादू र जादुई मन्त्र को प्रयोग बिना यो मामला कसरी लागू गर्न - काट अन्तर्गत पढ्नुहोस्! जाउ!

(छवि स्रोत)

परिचय

निस्सन्देह, वास्तविक समयमा डाटाको ठूलो मात्रा प्रशोधनले आधुनिक प्रणालीहरूमा प्रयोगको लागि पर्याप्त अवसरहरू प्रदान गर्दछ। यसको लागि सबैभन्दा लोकप्रिय संयोजनहरू मध्ये एक अपाचे काफ्का र स्पार्क स्ट्रिमिङको टेन्डम हो, जहाँ काफ्काले आगमन सन्देश प्याकेटहरूको स्ट्रिम सिर्जना गर्दछ, र स्पार्क स्ट्रिमिङले यी प्याकेटहरूलाई निश्चित समय अन्तरालमा प्रशोधन गर्दछ।

एप्लिकेसनको गल्ती सहिष्णुता बढाउन, हामी चेकपोइन्टहरू प्रयोग गर्नेछौं। यस मेकानिजमको साथ, जब स्पार्क स्ट्रिमिङ इन्जिनले हराएको डाटा रिकभर गर्न आवश्यक छ, यो केवल अन्तिम चेकपोइन्टमा फर्केर त्यहाँबाट गणनाहरू पुन: सुरु गर्न आवश्यक छ।

विकसित प्रणाली को वास्तुकला

प्रयोग गरिएका अवयवहरू:

• अपाचे काफ्का एक वितरित प्रकाशन-सदस्यता सन्देश प्रणाली हो। अफलाइन र अनलाइन सन्देश खपत दुवै लागि उपयुक्त। डाटा हानि रोक्नको लागि, काफ्का सन्देशहरू डिस्कमा भण्डारण गरिन्छ र क्लस्टर भित्र प्रतिकृति गरिन्छ। काफ्का प्रणाली ZooKeeper सिंक्रोनाइजेसन सेवाको शीर्षमा बनाइएको छ;
• अपाचे स्पार्क स्ट्रिमिङ - स्ट्रिमिङ डाटा प्रशोधनका लागि स्पार्क घटक। स्पार्क स्ट्रिमिङ मोड्युललाई माइक्रो-ब्याच आर्किटेक्चर प्रयोग गरेर बनाइएको छ, जहाँ डाटा स्ट्रिमलाई साना डाटा प्याकेटहरूको निरन्तर अनुक्रमको रूपमा व्याख्या गरिन्छ। स्पार्क स्ट्रिमिङले विभिन्न स्रोतहरूबाट डाटा लिन्छ र यसलाई साना प्याकेजहरूमा मिलाउँछ। नयाँ प्याकेजहरू नियमित अन्तरालहरूमा सिर्जना गरिन्छन्। प्रत्येक समय अन्तरालको सुरुमा, नयाँ प्याकेट सिर्जना गरिन्छ, र त्यो अन्तरालमा प्राप्त भएको कुनै पनि डाटा प्याकेटमा समावेश गरिन्छ। अन्तरालको अन्त्यमा, प्याकेट वृद्धि रोकिन्छ। अन्तरालको आकार ब्याच अन्तराल भनिने प्यारामिटर द्वारा निर्धारण गरिन्छ;
• Apache Spark SQL - स्पार्क कार्यात्मक प्रोग्रामिंग संग रिलेशनल प्रोसेसिंग को संयोजन गर्दछ। संरचित डेटा भनेको स्किमा भएको डेटा हो, त्यो हो, सबै रेकर्डहरूको लागि फिल्डहरूको एकल सेट। Spark SQL ले विभिन्न संरचित डेटा स्रोतहरूबाट इनपुटलाई समर्थन गर्दछ र, स्किमा जानकारीको उपलब्धताको लागि धन्यवाद, यसले कुशलतापूर्वक रेकर्डहरूको आवश्यक क्षेत्रहरू मात्र पुन: प्राप्त गर्न सक्छ, र DataFrame API हरू पनि प्रदान गर्दछ;
• AWS RDS एक अपेक्षाकृत सस्तो क्लाउड-आधारित रिलेसनल डाटाबेस हो, वेब सेवा जसले सेटअप, सञ्चालन र स्केलिंगलाई सरल बनाउँछ, र सीधा Amazon द्वारा प्रशासित हुन्छ।

काफ्का सर्भर स्थापना र चलाउँदै

काफ्का सिधै प्रयोग गर्नु अघि, तपाइँसँग जाभा छ भनेर निश्चित गर्न आवश्यक छ, किनकि... JVM कामको लागि प्रयोग गरिन्छ:

sudo apt-get update 
sudo apt-get install default-jre
java -version

काफ्कासँग काम गर्न नयाँ प्रयोगकर्ता सिर्जना गरौं:

sudo useradd kafka -m
sudo passwd kafka
sudo adduser kafka sudo

अर्को, आधिकारिक अपाचे काफ्का वेबसाइटबाट वितरण डाउनलोड गर्नुहोस्:

wget -P /YOUR_PATH "http://apache-mirror.rbc.ru/pub/apache/kafka/2.2.0/kafka_2.12-2.2.0.tgz"

डाउनलोड गरिएको अभिलेख अनप्याक गर्नुहोस्:

tar -xvzf /YOUR_PATH/kafka_2.12-2.2.0.tgz
ln -s /YOUR_PATH/kafka_2.12-2.2.0 kafka

अर्को चरण वैकल्पिक छ। तथ्य यो हो कि पूर्वनिर्धारित सेटिङहरूले तपाईंलाई Apache Kafka को सबै क्षमताहरू पूर्ण रूपमा प्रयोग गर्न अनुमति दिँदैन। उदाहरणका लागि, सन्देशहरू प्रकाशित गर्न सकिने विषय, कोटी, समूह मेटाउनुहोस्। यसलाई परिवर्तन गर्न, कन्फिगरेसन फाइल सम्पादन गरौं:

vim ~/kafka/config/server.properties

फाइलको अन्त्यमा निम्न थप्नुहोस्:

delete.topic.enable = true

काफ्का सर्भर सुरु गर्नु अघि, तपाईंले ZooKeeper सर्भर सुरु गर्न आवश्यक छ; हामी काफ्का वितरणको साथ आउने सहायक लिपि प्रयोग गर्नेछौं:

Cd ~/kafka
bin/zookeeper-server-start.sh config/zookeeper.properties

ZooKeeper सफलतापूर्वक सुरु भएपछि, काफ्का सर्भरलाई छुट्टै टर्मिनलमा सुरु गर्नुहोस्:

bin/kafka-server-start.sh config/server.properties

लेनदेन नामक नयाँ विषय सिर्जना गरौं:

bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 3 --topic transaction

निश्चित गर्नुहोस् कि विभाजन र प्रतिकृतिको आवश्यक संख्याको साथ एक विषय सिर्जना गरिएको छ:

bin/kafka-topics.sh --describe --zookeeper localhost:2181

नयाँ सिर्जना गरिएको विषयको लागि निर्माता र उपभोक्ता परीक्षणको क्षणहरू सम्झौं। तपाईं कसरी सन्देशहरू पठाउन र प्राप्त गर्ने परीक्षण गर्न सक्नुहुन्छ भन्ने बारे थप विवरणहरू आधिकारिक कागजातहरूमा लेखिएका छन् - केही सन्देश पठाउनुहोस्। खैर, हामी KafkaProducer API प्रयोग गरेर पाइथनमा निर्माता लेख्न अगाडि बढ्छौं।

निर्माता लेखन

निर्माताले अनियमित डाटा उत्पन्न गर्नेछ - 100 सन्देशहरू प्रत्येक सेकेन्डमा। यादृच्छिक डेटा द्वारा हामीले तीन क्षेत्रहरू मिलेर बनेको शब्दकोशलाई बुझाउँछौं:

• साखा - क्रेडिट संस्थाको बिक्री बिन्दुको नाम;
• मुद्रा - लेनदेन मुद्रा;
• रकम - लेनदेन रकम। बैंक द्वारा मुद्रा खरिद गर्दा रकम धनात्मक संख्या हुनेछ, र यदि यो एक बिक्री हो भने ऋणात्मक संख्या हुनेछ।

निर्माताको लागि कोड यस्तो देखिन्छ:

from numpy.random import choice, randint

def get_random_value():
    new_dict = {}

    branch_list = ['Kazan', 'SPB', 'Novosibirsk', 'Surgut']
    currency_list = ['RUB', 'USD', 'EUR', 'GBP']

    new_dict['branch'] = choice(branch_list)
    new_dict['currency'] = choice(currency_list)
    new_dict['amount'] = randint(-100, 100)

    return new_dict

अर्को, पठाउने विधि प्रयोग गरेर, हामी JSON ढाँचामा हामीलाई आवश्यक विषयको लागि सर्भरमा सन्देश पठाउँछौं:

from kafka import KafkaProducer    

producer = KafkaProducer(bootstrap_servers=['localhost:9092'],
                             value_serializer=lambda x:dumps(x).encode('utf-8'),
                             compression_type='gzip')
my_topic = 'transaction'
data = get_random_value()

try:
    future = producer.send(topic = my_topic, value = data)
    record_metadata = future.get(timeout=10)
    
    print('--> The message has been sent to a topic: 
            {}, partition: {}, offset: {}' 
            .format(record_metadata.topic,
                record_metadata.partition,
                record_metadata.offset ))   
                             
except Exception as e:
    print('--> It seems an Error occurred: {}'.format(e))

finally:
    producer.flush()

स्क्रिप्ट चलाउँदा, हामीले टर्मिनलमा निम्न सन्देशहरू प्राप्त गर्छौं:

यसको मतलब यो हो कि हामीले चाहेजस्तै सबै काम गर्छ - निर्माताले हामीलाई चाहिने विषयमा सन्देशहरू उत्पन्न गर्छ र पठाउँछ।
अर्को चरण Spark स्थापना र यो सन्देश स्ट्रिम प्रक्रिया गर्न छ।

Apache Spark स्थापना गर्दै

अपाचे स्पार्क एक सार्वभौमिक र उच्च प्रदर्शन क्लस्टर कम्प्युटिङ प्लेटफर्म हो।

अन्तर्क्रियात्मक प्रश्नहरू र स्ट्रिम प्रशोधन सहित गणना प्रकारहरूको फराकिलो दायरालाई समर्थन गर्दा स्पार्कले MapReduce मोडेलको लोकप्रिय कार्यान्वयनहरू भन्दा राम्रो प्रदर्शन गर्दछ। ठूलो मात्रामा डाटा प्रशोधन गर्दा गतिले महत्त्वपूर्ण भूमिका खेल्छ, किनकि यो गति हो जसले तपाईंलाई मिनेट वा घण्टा पर्खाइ बिना अन्तरक्रियात्मक रूपमा काम गर्न अनुमति दिन्छ। स्पार्कको सबैभन्दा ठूलो शक्ति मध्ये एक जसले यसलाई यति छिटो बनाउँछ यसको इन-मेमोरी गणनाहरू प्रदर्शन गर्ने क्षमता हो।

यो फ्रेमवर्क Scala मा लेखिएको छ, त्यसैले तपाईंले यसलाई पहिले स्थापना गर्न आवश्यक छ:

sudo apt-get install scala

आधिकारिक वेबसाइटबाट स्पार्क वितरण डाउनलोड गर्नुहोस्:

wget "http://mirror.linux-ia64.org/apache/spark/spark-2.4.2/spark-2.4.2-bin-hadoop2.7.tgz"

अभिलेख अनप्याक गर्नुहोस्:

sudo tar xvf spark-2.4.2/spark-2.4.2-bin-hadoop2.7.tgz -C /usr/local/spark

ब्यास फाइलमा स्पार्कको मार्ग थप्नुहोस्:

vim ~/.bashrc

सम्पादक मार्फत निम्न लाइनहरू थप्नुहोस्:

SPARK_HOME=/usr/local/spark
export PATH=$SPARK_HOME/bin:$PATH

bashrc मा परिवर्तन गरेपछि तलको आदेश चलाउनुहोस्:

source ~/.bashrc

AWS PostgreSQL तैनात गर्दै

हामीले स्ट्रिमहरूबाट प्रशोधित जानकारी अपलोड गर्ने डाटाबेस प्रयोग गर्न बाँकी छ। यसका लागि हामी AWS RDS सेवा प्रयोग गर्नेछौं।

AWS कन्सोलमा जानुहोस् -> AWS RDS -> डाटाबेस -> डाटाबेस सिर्जना गर्नुहोस्:

PostgreSQL चयन गर्नुहोस् र अर्को क्लिक गर्नुहोस्:

किनभने यो उदाहरण शैक्षिक उद्देश्यका लागि मात्र हो; हामी "न्यूनतम" (नि: शुल्क टियर) नि: शुल्क सर्भर प्रयोग गर्नेछौं:

अर्को, हामीले फ्रि टियर ब्लकमा टिक राख्छौं, र त्यस पछि हामीलाई स्वचालित रूपमा t2.micro वर्गको उदाहरण प्रस्ताव गरिनेछ - कमजोर भए पनि, यो नि: शुल्क छ र हाम्रो कार्यको लागि एकदम उपयुक्त छ:

अर्को धेरै महत्त्वपूर्ण चीजहरू आउँछन्: डाटाबेस उदाहरणको नाम, मास्टर प्रयोगकर्ताको नाम र उसको पासवर्ड। उदाहरणको नाम दिऔं: myHabrTest, मास्टर प्रयोगकर्ता: habr, पासवर्ड: habr12345 र अर्को बटनमा क्लिक गर्नुहोस्:

अर्को पृष्ठमा बाहिरबाट हाम्रो डाटाबेस सर्भरको पहुँच (सार्वजनिक पहुँच) र पोर्ट उपलब्धताको लागि जिम्मेवार प्यारामिटरहरू छन्:

VPC सुरक्षा समूहको लागि नयाँ सेटिङ सिर्जना गरौं, जसले पोर्ट ५४३२ (PostgreSQL) मार्फत हाम्रो डाटाबेस सर्भरमा बाह्य पहुँचलाई अनुमति दिनेछ।
AWS कन्सोलमा छुट्टै ब्राउजर विन्डोमा VPC ड्यासबोर्डमा जाऔं -> सुरक्षा समूहहरू -> सुरक्षा समूह खण्ड सिर्जना गर्नुहोस्:

हामीले सुरक्षा समूहको लागि नाम सेट गर्‍यौं - PostgreSQL, एउटा विवरण, यो समूह कुन VPC सँग सम्बन्धित हुनुपर्छ र सिर्जना बटनमा क्लिक गर्नुहोस्:

नयाँ सिर्जना गरिएको समूहको लागि पोर्ट 5432 को लागि इनबाउन्ड नियमहरू भर्नुहोस्, जस्तै तलको चित्रमा देखाइएको छ। तपाईंले पोर्ट म्यानुअल रूपमा निर्दिष्ट गर्न सक्नुहुन्न, तर प्रकार ड्रप-डाउन सूचीबाट PostgreSQL चयन गर्नुहोस्।

कडा शब्दमा भन्नुपर्दा, मान ::/0 भनेको संसारभरबाट सर्भरमा आगमन ट्राफिकको उपलब्धता हो, जुन क्यानोनिक रूपमा पूर्ण रूपमा सत्य होइन, तर उदाहरणको विश्लेषण गर्न, हामी आफैलाई यो दृष्टिकोण प्रयोग गर्न अनुमति दिऔं:

हामी ब्राउजर पृष्ठमा फर्कन्छौं, जहाँ हामीसँग "उन्नत सेटिङहरू कन्फिगर गर्नुहोस्" खुला छ र VPC सुरक्षा समूह खण्डमा चयन गर्नुहोस् -> अवस्थित VPC सुरक्षा समूहहरू छनौट गर्नुहोस् -> PostgreSQL:

अर्को, डाटाबेस विकल्पहरूमा -> डाटाबेस नाम -> नाम सेट गर्नुहोस् - habrDB.

पूर्वनिर्धारित रूपमा ब्याकअप (ब्याकअप रिटेन्सन अवधि - ० दिन), निगरानी र कार्यसम्पादन अन्तर्दृष्टिहरू असक्षम गर्ने अपवादको साथ हामी बाँकी प्यारामिटरहरू छोड्न सक्छौं। बटनमा क्लिक गर्नुहोस् डाटाबेस सिर्जना गर्नुहोस्:

थ्रेड ह्यान्डलर

अन्तिम चरण स्पार्क कार्यको विकास हुनेछ, जसले प्रत्येक दुई सेकेन्डमा काफ्काबाट आउने नयाँ डाटालाई प्रशोधन गर्नेछ र परिणाम डाटाबेसमा प्रविष्ट गर्नेछ।

माथि उल्लेख गरिए अनुसार, चेकपोइन्टहरू SparkStreaming मा एक मुख्य संयन्त्र हो जुन त्रुटि सहिष्णुता सुनिश्चित गर्न कन्फिगर गरिनु पर्छ। हामी चेकपोइन्टहरू प्रयोग गर्नेछौं र, यदि प्रक्रिया असफल भयो भने, स्पार्क स्ट्रिमिङ मोड्युलले अन्तिम चेकपोइन्टमा फर्कन र हराएको डाटा पुन: प्राप्ति गर्न त्यहाँबाट गणनाहरू पुन: सुरु गर्न आवश्यक हुनेछ।

चेकपोइन्टिङलाई दोष-सहिष्णु, भरपर्दो फाइल प्रणाली (जस्तै HDFS, S3, आदि) मा डाइरेक्टरी सेट गरेर सक्षम गर्न सकिन्छ जसमा चेकपोइन्ट जानकारी भण्डारण गरिनेछ। यो प्रयोग गरी गरिन्छ, उदाहरणका लागि:

streamingContext.checkpoint(checkpointDirectory)

हाम्रो उदाहरणमा, हामी निम्न दृष्टिकोण प्रयोग गर्नेछौं, अर्थात्, यदि checkpointDirectory अवस्थित छ भने, त्यसपछि सन्दर्भ चेकपोइन्ट डेटाबाट पुन: सिर्जना गरिनेछ। यदि डाइरेक्टरी अवस्थित छैन (अर्थात् पहिलो पटक निष्पादित), त्यसपछि functionToCreateContext लाई नयाँ सन्दर्भ सिर्जना गर्न र DStreams कन्फिगर गर्न बोलाइन्छ:

from pyspark.streaming import StreamingContext

context = StreamingContext.getOrCreate(checkpointDirectory, functionToCreateContext)

हामीले KafkaUtils पुस्तकालयको createDirectStream विधि प्रयोग गरेर "लेनदेन" विषयसँग जडान गर्न DirectStream वस्तु सिर्जना गर्छौं:

from pyspark.streaming.kafka import KafkaUtils
    
sc = SparkContext(conf=conf)
ssc = StreamingContext(sc, 2)

broker_list = 'localhost:9092'
topic = 'transaction'

directKafkaStream = KafkaUtils.createDirectStream(ssc,
                                [topic],
                                {"metadata.broker.list": broker_list})

JSON ढाँचामा आगमन डेटा पार्सिङ:

rowRdd = rdd.map(lambda w: Row(branch=w['branch'],
                                       currency=w['currency'],
                                       amount=w['amount']))
                                       
testDataFrame = spark.createDataFrame(rowRdd)
testDataFrame.createOrReplaceTempView("treasury_stream")

स्पार्क SQL प्रयोग गरेर, हामी एक साधारण समूह बनाउँछौं र परिणाम कन्सोलमा प्रदर्शन गर्छौं:

select 
    from_unixtime(unix_timestamp()) as curr_time,
    t.branch                        as branch_name,
    t.currency                      as currency_code,
    sum(amount)                     as batch_value
from treasury_stream t
group by
    t.branch,
    t.currency

क्वेरी पाठ प्राप्त गर्दै र यसलाई स्पार्क SQL मार्फत चलाउँदै:

sql_query = get_sql_query()
testResultDataFrame = spark.sql(sql_query)
testResultDataFrame.show(n=5)

र त्यसपछि हामी AWS RDS मा तालिकामा नतिजा एकत्रित डाटा बचत गर्छौं। डाटाबेस तालिकामा एकत्रित परिणामहरू बचत गर्न, हामी DataFrame वस्तुको लेखन विधि प्रयोग गर्नेछौं:

testResultDataFrame.write 
    .format("jdbc") 
    .mode("append") 
    .option("driver", 'org.postgresql.Driver') 
    .option("url","jdbc:postgresql://myhabrtest.ciny8bykwxeg.us-east-1.rds.amazonaws.com:5432/habrDB") 
    .option("dbtable", "transaction_flow") 
    .option("user", "habr") 
    .option("password", "habr12345") 
    .save()

AWS RDS मा जडान सेटअप गर्ने बारे केही शब्दहरू। हामीले "AWS PostgreSQL डिप्लोइङ" चरणमा यसको लागि प्रयोगकर्ता र पासवर्ड सिर्जना गर्यौं। तपाईंले डाटाबेस सर्भर url को रूपमा Endpoint प्रयोग गर्नुपर्छ, जुन जडान र सुरक्षा खण्डमा प्रदर्शित हुन्छ:

स्पार्क र काफ्कालाई सही रूपमा जडान गर्नको लागि, तपाईंले आर्टिफ्याक्ट प्रयोग गरेर smark-submit मार्फत काम चलाउनु पर्छ। spark-streaming-kafka-0-8_2.11। थप रूपमा, हामी PostgreSQL डाटाबेससँग अन्तर्क्रिया गर्नको लागि एउटा कलाकृति पनि प्रयोग गर्नेछौं; हामी तिनीहरूलाई --packages मार्फत स्थानान्तरण गर्नेछौं।

स्क्रिप्टको लचिलोपनको लागि, हामी सन्देश सर्भरको नाम र हामीले डेटा प्राप्त गर्न चाहने विषयलाई इनपुट प्यारामिटरहरूको रूपमा पनि समावेश गर्नेछौं।

त्यसोभए, यो प्रणालीको कार्यक्षमता सुरु गर्न र जाँच गर्ने समय हो:

spark-submit 
--packages org.apache.spark:spark-streaming-kafka-0-8_2.11:2.0.2,
org.postgresql:postgresql:9.4.1207 
spark_job.py localhost:9092 transaction

सबै काम भयो! तपाईले तलको तस्विरमा देख्न सक्नुहुन्छ, एप्लिकेसन चलिरहेको बेला, नयाँ एकत्रीकरण परिणामहरू प्रत्येक 2 सेकेन्डमा आउटपुट हुन्छन्, किनकि हामीले StreamingContext वस्तु सिर्जना गर्दा ब्याचिङ अन्तराललाई 2 सेकेन्डमा सेट गर्छौं:

अर्को, हामी तालिकामा रेकर्डहरूको उपस्थिति जाँच गर्नको लागि डाटाबेसमा एक साधारण क्वेरी बनाउँछौं लेनदेन_प्रवाह:

निष्कर्षमा

यस लेखले Apache Kafka र PostgreSQL सँग संयोजनमा स्पार्क स्ट्रिमिङ प्रयोग गरेर जानकारीको स्ट्रिम प्रशोधनको उदाहरण हेर्यो। विभिन्न स्रोतहरूबाट डेटाको वृद्धिको साथ, स्ट्रिमिङ र वास्तविक-समय अनुप्रयोगहरू सिर्जना गर्न स्पार्क स्ट्रिमिङको व्यावहारिक मूल्यलाई बढावा दिन गाह्रो छ।

तपाईंले मेरो भण्डारमा पूर्ण स्रोत कोड फेला पार्न सक्नुहुन्छ GitHub.

म यस लेखमा छलफल गर्न पाउँदा खुसी छु, म तपाईंका टिप्पणीहरूको अपेक्षा गर्दछु, र म सबै हेरचाह गर्ने पाठकहरूबाट रचनात्मक आलोचनाको आशा गर्दछु।

म तपाईंलाई सफलताको कामना गर्दछु!

PS प्रारम्भमा यो स्थानीय PostgreSQL डाटाबेस प्रयोग गर्ने योजना थियो, तर AWS को लागी मेरो माया दिएर, मैले डाटाबेसलाई क्लाउडमा सार्ने निर्णय गरें। यस विषयमा अर्को लेखमा, म AWS Kinesis र AWS EMR प्रयोग गरेर AWS मा माथि वर्णन गरिएको सम्पूर्ण प्रणाली कसरी कार्यान्वयन गर्ने भनेर देखाउनेछु। समाचार पछ्याउनुहोस्!

स्रोत: www.habr.com