🥇Aviasales API integreerimine Amazon Kinesis'esse ja serverless lihtsus

Tere, Habr!

Kas teile meeldib lennata? Mulle meeldib, kuid isoleerimise ajal olen hakanud ka analüüsima andmeid tuntud lennupiletite portaalist — Aviasales.

Täna vaatame Amazon Kinesis’i tööpõhimõtteid, loome voogedastuse süsteemi reaalajas analüüsiga, seadistame NoSQL andmebaasi Amazon DynamoDB peamiseks andmehoidla ning seadistame SMS-teavituse huvitavate piletite kohta.

Kõik detailid allpool! Lähme!

Sissejuhatus

Näiteks vajame ligipääsu Aviasales API-le. Ligipääs sellele on tasuta ja piiranguteta, tuleb lihtsalt registreeruda ja saada oma API token andmete saamiseks jaotises „Arendajatele“.

Selle artikli peamine eesmärk on anda üldine ülevaade andmete voogedastuse kasutamisest AWS-is. Jätame kõrvale, et API kaudu tagasi saadud andmed ei pruugi olla praegused ja need edastatakse vahemälust, mis moodustatakse Aviasales.ru ja Jetradar.com kasutajate otsingute põhjal viimase 48 tunni jooksul.

API kaudu saadud lennupiletite andmed (Kinesis-agent, mis on paigaldatud tootmismasinale) analüüsib automaatselt ja edastab vajalikku voogu Kinesis Data Analytics kaudu. Tootmisvoog kirjutatakse otse andmehoidlasse. DynamoDB-s rakendatud „toožit“ andmehoidla võimaldab läbi viia sügavamat analüüsi piletite kohta BI tööriistade kaudu, näiteks AWS Quick Sight.

Käsitleme kahte infrastruktuuri juurutamise varianti:

Käsitsi — läbi AWS Management Console;
Koodi Terraformi alusel — lenijatele automatiseerijatele;

Arendatava süsteemi arhitektuur

Kasutatavad komponendid:

Aviasales API — selle API kaudu tagastatud andmeid kasutatakse kogu edasise töötlemise jaoks;
EC2 tootmisinstants — tavaline virtuaalne masin pilves, kus genereeritakse sisendvoog;
- Kinesis Agent — Java-rakendus, mis paigaldatakse kohalikult masinale ja mis pakub lihtsat viisi andmete kogumiseks ja edastamiseks Kinesis'esse (Kinesis Data Streams või Kinesis Firehose). Agent jälgib pidevalt määratud kaustade failide kogumeid ja edastab uusi andmeid Kinesis'esse;
- API Caller skript — Python-skript, mis teeb API päringuid ja salvestab vastuse kausta, mida jälgib Kinesis Agent;
Kinesis Data Streams — reaalajas andmete voogude edastamise teenus, millel on ulatuslikud skaleerimisvõimalused;
Kinesis Analytics — serverita teenus, mis lihtsustab reaalajas voogandmete analüüsi. Amazon Kinesis Data Analytics konfigureerib rakenduste tööks vajalikud ressursid ja skaleerib automaatselt, et hallata mis tahes andmevooge;
AWS Lambda — teenus, mis võimaldab käivitada koodi ilma serverite reserveerimise ja seadistamiseta. Kõik arvutusvõimsused skaleeruvad automaatselt iga väljakutse jaoks;
Amazon DynamoDB — paaride "võti-väärtus" ja dokumentide andmebaas, mis tagab alla 10 millisekundi latentsuse igas mõõtkavas. DynamoDB kasutamine ei nõua serverite jaotamist, nende värskendamist ega haldamist. DynamoDB skaleerib tabeleid automaatselt, kohandades saadavalolevate ressursside mahtu ja säilitades kõrge jõudluse. Süsteemi haldamise tegevusi ei ole vaja;
Amazon SNS — täielikult hallatav sõnumite saatmise teenus, mis põhineb "väljaandja - tellija" (Pub/Sub) mudelil, mille kaudu saab isoleerida mikroteenuseid, jaotatud süsteeme ja serverita rakendusi. SNS-i saab kasutada teabe saatmiseks lõppkasutajatele mobiilsete push-teate, SMS-i ja e-kirjade kaudu.

Algne ettevalmistus

Andmevoo simuleerimiseks otsustasin kasutada lennupiletite teavet, mille tagastab Aviasalesi API. dokumentatsioon suur hulk erinevaid meetodeid, võtame ühe neist — "Hinnakalender kuuks", mis tagastab igapäevased hinnad, grupeerituna ümberistumiste arvu. Kui otsingus kuud ei edastata, tagastatakse järgmise kuu teave.

Nii et registreerime end, saame oma tokeni.

Allpool on näide päringust:

http://api.travelpayouts.com/v2/prices/month-matrix?currency=rub&origin=LED&destination=HKT&show_to_affiliates=true&token=TOKEN_API

Ülaltoodud meetod API-st andmete saamiseks, kasutades päringus tokenit, töötab, kuid ma eelistan edastada juurdepääsutokeni läbi päise, seega kasutame skripti api_caller.py jaoks just seda meetodit.

Näide vastusest:

{{
   "success":true,
   "data":[{
      "show_to_affiliates":true,
      "trip_class":0,
      "origin":"LED",
      "destination":"HKT",
      "depart_date":"2015-10-01",
      "return_date":"",
      "number_of_changes":1,
      "value":29127,
      "found_at":"2015-09-24T00:06:12+04:00",
      "distance":8015,
      "actual":true
   }]
}

Ülaltoodud API vastuse näites on pilet Peterburist Phuketti... Ah, milleks unistada...
Kuna ma olen Kazanist ja Phukett on meil praegu "ainult unistus", otsime pileteid Peterburist Kazani.

Eeldatakse, et teil on juba AWSi konto. Soovin kohe eraldi tähelepanu juhtida, et Kinesis ja SMS-ide saatmine ei kuulu aastase Free Tier (tasuta kasutamine). Kuid isegi sel juhul, pidades meeles paar dollarit, on täiesti võimalik luua soovitatud süsteem ja sellega mängida. Ja muidugi, ärge unustage eemaldada kõiki ressursse pärast nende vajaduse lõppemist.

Õnneks on DynamoDb ja lambda-funktsioonid meie jaoks tinglikult tasuta, kui jääme kuueelarve tasuta piiridesse. Näiteks DynamoDB puhul: 25 GB salvestusruumi, 25 WCU/RCU ja 100 miljonit päringut. Ja miljon lambda funktsiooni kutsumist kuus.

Süsteemi käsitsi juurutamine

Kinesis Data Streamsi seadistamine

Liigume Kinesis Data Streamsi teenusesse ja loome kaks uut voogu, igaühel üks shard.

Mis on shard?
Shard on Amazon Kinesis voogude andmete edastamise põhielement. Üks shard tagab sisendandmete edastamise kiirusel 1 MB/s ja väljundandmete edastamise kiirusel 2 MB/s. Üks shard toetab kuni 1000 PUT faili sekundis. Andmevoo loomisel tuleb määrata vajalik shardide arv. Näiteks saab luua andmevoo kahe shardiga. See andmevoog tagab sisendandmete edastamise kiirusel 2 MB/s ja väljundandmete edastamise kiirusel 4 MB/s, toetades kuni 2000 PUT faili sekundis.

Mida rohkem shard'e teie voos on, seda suurem on selle läbilaskevõime. Üldiselt skaleeritakse vooge shardide lisamise kaudu. Aga mida rohkem shard'e teil on, seda kallim see on. Iga shard maksab 1,5 senti tunnis ja lisaks 1,4 senti iga miljoni vookuulutuse (PUT payload units) kohta.

Loome uue voolu nimega airline_tickets, talle piisab täiesti ühest shardist:

Nüüd loome veel ühe voolu nimega special_stream:

Tootja seadistamine

Andmete tootjana piisab ülesande lahendamiseks tavalise EC2 instantsi kasutamisest. See ei pea olema võimas kallis virtuaalmasin, piisab täiesti spottest t2.micro-st.

Oluline märkus: näidisena tuleks kasutada image'i — Amazon Linux AMI 2018.03.0, millel on vähem seadistusi Kinesis Agendi kiireks käivitamiseks.

Liigume EC2 teenusse, loome uue virtuaalmasina, valime sobiva AMI tüübi t2.micro, mis kuulub Free Tier'i:

Kuna uus virtuaalmasin peab Kinesis teenusega suhtlema, tuleb talle anda selleks õigused. Parim viis seda teha on määrata IAM Role. Seetõttu tuleks ekraanil Step 3: Configure Instance Details valida Loo uus IAM Roll:

IAM rolli loomine EC2 jaoks

Avanenud aknas valime, et loome uue rolli EC2 jaoks ja liigume jaotisse Permissions:

Õppemudeli puhul ei ole vajalik igasse detaili süveneda, seetõttu valime Amazoni eelmääratud poliisid: AmazonKinesisFullAccess ja CloudWatchFullAccess.

Anname sellele rollile mõne mõistliku nime, näiteks: EC2-KinesisStreams-FullAccess. Tulemuseks peaks olema sama, mis on kujutisel allpool:

Pärast uue rolli loomist ärge unustage seda kinnitada loodavale virtuaalmasina instantsile:

Selles ekraanil ei muuda me enam midagi ja liigume järgmistele akendele.

Karmide ketaste parameetrid võib jätta vaikeväärtustele, sildid samuti (kuigi hea tava on silte kasutada, vähemalt anda instantsile nimi ja märkida keskkond).

Nüüd on meil avatud Step 6: Configure Security Group vahekaart, kus tuleb luua uus või näidata olemasolevat Security group, mis võimaldab SSH (port 22) ühendust instantsiga. Valige seal Source —> My IP ja saate instantsi käivitada.

Kui see läheb staatuseks running, saab proovida selle ssh kaudu ühendust saada.

Kinesis Agendi kasutamiseks, pärast masina edukat ühendamist, tuleb terminalis sisestada järgmised käsud:

sudo yum -y update
sudo yum install -y python36 python36-pip
sudo /usr/bin/pip-3.6 install --upgrade pip
sudo yum install -y aws-kinesis-agent

Loome kausta API vastuste salvestamiseks:

sudo mkdir /var/log/airline_tickets

Enne agendi käivitamist tuleb selle konfiguratsioon seadistada:

sudo vim /etc/aws-kinesis/agent.json

Faili agent.json sisu peaks olema järgmine:

{
  "cloudwatch.emitMetrics": true,
  "kinesis.endpoint": "",
  "firehose.endpoint": "",

  "flows": [
    {
      "filePattern": "\/var\/log\/airline_tickets\/*log",
      "kinesisStream": "airline_tickets",
      "partitionKeyOption": "RANDOM",
      "dataProcessingOptions": [
         {
            "optionName": "CSVTOJSON",
            "customFieldNames": ["cost","trip_class","show_to_affiliates",
                "return_date","origin","number_of_changes","gate","found_at",
                "duration","distance","destination","depart_date","actual","record_id"]
         }
      ]
    }
  ]
}

Nagu nähtub konfiguratsioonifailist, jälgib agent kataloogis /var/log/airline_tickets/ .log laiendiga faile, parsib need ja edastab airline_tickets streaming.

Taaskäivitame teenuse ja veendume, et see on käivitatud ja töötab:

sudo service aws-kinesis-agent restart

Nüüd laeme alla Python-skripti, mis pärib andmeid API-lt:

REPO_PATH=https:\/\/raw.githubusercontent.com\/igorgorbenko\/aviasales_kinesis\/master\/producer

wget $REPO_PATH\/api_caller.py -P \/home\/ec2-user\/
wget $REPO_PATH\/requirements.txt -P \/home\/ec2-user\/
sudo chmod a+x \/home\/ec2-user\/api_caller.py
sudo \/usr\/local\/bin\/pip3 install -r \/home\/ec2-user\/requirements.txt

Skript api_caller.py pärib andmeid Aviasales'ilt ja salvestab saadud vastuse katalooge, mida skannib Kinesis agent. Selle skripti rakendamine on üsna standardne, on olemas klass TicketsApi, mis võimaldab asünkroonselt API-kutsed teha. Selle klassi määrame päise koos tokeniga ja päringu parameetrid:

class TicketsApi:
    """API kutsuja klass."""

    def __init__(self, headers):
        """Algmeetod."""
        self.base_url = BASE_URL
        self.headers = headers

    async def get_data(self, data):
        """Hangi andmed API päringust."""
        response_json = {}
        async with ClientSession(headers=self.headers) as session:
            try:
                response = await session.get(self.base_url, data=data)
                response.raise_for_status()
                LOGGER.info('Vastuse olek %s: %s',
                            self.base_url, response.status)
                response_json = await response.json()
            except HTTPError as http_err:
                LOGGER.error('Ops! HTTP viga sündis: %s', str(http_err))
            except Exception as err:
                LOGGER.error('Ops! Sündis viga: %s', str(err))
            return response_json


def prepare_request(api_token):
    """Tagasta päised ja päring API päringu jaoks."""
    headers = {'X-Access-Token': api_token,
               'Accept-Encoding': 'gzip'}

    data = FormData()
    data.add_field('currency', CURRENCY)
    data.add_field('origin', ORIGIN)
    data.add_field('destination', DESTINATION)
    data.add_field('show_to_affiliates', SHOW_TO_AFFILIATES)
    data.add_field('trip_duration', TRIP_DURATION)
    return headers, data


async def main():
    """Käivita kood."""
    if len(sys.argv) != 2:
        print('Kasutamine: api_caller.py <teie_api_token>')
        sys.exit(1)
        return
    api_token = sys.argv[1]
    headers, data = prepare_request(api_token)

    api = TicketsApi(headers)
    response = await api.get_data(data)
    if response.get('success', None):
        LOGGER.info('API on tagastanud %s elementi', len(response['data']))
        try:
            count_rows = log_maker(response)
            LOGGER.info('%s rida on salvestatud faili %s',
                        count_rows,
                        TARGET_FILE)
        except Exception as e:
            LOGGER.error('Ops! Päringu tulemust ei salvestatud faili. %s',
                         str(e))
    else:
        LOGGER.error('Ops! API päring ebaõnnestus %s!', response)

Pärast sätete õigsuse ja agendi töö kontrollimist teeme testkäivituse skripti api_caller.py jaoks:

sudo .\/api_caller.py TOKEN

Ja vaatame tulemusi Avari Logfailides ja Monitoring vahekaardil andmevoos airline_tickets:

tail -f \/var\/log\/aws-kinesis-agent\/aws-kinesis-agent.log

Nagu näha, töötab kõik ja Kinesis Agent saadab edukalt andmeid voogu. Nüüd seadistame consumer'i.

Kinesis Data Analytics konfigureerimine

Liigume kogu süsteemi keskse komponendi juurde — loon uue rakenduse Kinesis Data Analytics nimelt kinesis_analytics_airlines_app:

Kinesis Data Analytics võimaldab analüüsida andmeid reaalajas Kinesis Streams'i kaudu SQL keeles. See on täielikult automaatne teenus (erinevalt Kinesis Streams'ist), mis:

lubab luua uusi vooge (Output Stream) lähtudes päringutest algandmetele;
pakub tõrkevoogu, mis ilmnes rakenduste töö käigus (Error Stream);
oskab automaatselt määrata algandmete skeemi (seda saab vajadusel käsitsi ümber määrata).

See teenus ei ole odav — 0,11 USD tunni eest, seega tuleks seda kasutada ettevaatlikult ja kustutada pärast kasutamise lõpetamist.

Ühendame rakenduse andmeallikaga:

Valime voolu, millega plaanime ühendust luua (airline_tickets):

Järgmiseks tuleb rakendusele lisada uus IAM roll, et see saaks voost lugeda ja voogu kirjutada. Selleks ei pea Access permissions blokis midagi muutma:

Nüüd küsime andmeskeemi avastamist voos, selleks kliki nuppu «Discover schema». Selle tulemusena uuendatakse (loodakse uus) IAM roll ja käivitatakse andmeskeemi avastamine, kasutades andmeid, mis on voogu juba saabunud:

Nüüd on vajalik minna SQL redaktorisse. Nüüdse nupu vajutamisel ilmub aken küsimusega rakenduse käivitamise kohta — valige, mida soovite käivitada:

SQL redaktori aknasse lisame sellise lihtsa päringu ja vajutame Save and Run SQL:

CREATE OR REPLACE STREAM "DESTINATION_SQL_STREAM" ("cost" DOUBLE, "gate" VARCHAR(16));

CREATE OR REPLACE PUMP "STREAM_PUMP" AS INSERT INTO "DESTINATION_SQL_STREAM"
SELECT STREAM "cost", "gate"
FROM "SOURCE_SQL_STREAM_001"
WHERE "cost" < 5000
    and "gate" = 'Aeroflot';

Relatsioonilistes andmebaasides töötate te tabelitega, kasutades INSERT-lauseid kirje lisamiseks ja SELECT-lauseid andmete pärimiseks. Amazon Kinesis Data Analytics'is töötate te voogude (STREAM) ja 'pump' (PUMP) - pidevate sisestuspäringutega, mis sisestavad andmed ühest voost teise rakenduses.

Ülaltoodud SQL päringus otsitakse Aerofloti pileteid, mille hind on alla viie tuhande rubla. Kõik kirjed, mis vastavad nendele tingimustele, lisatakse voogu DESTINATION_SQL_STREAM.

Sihtosakonna all valime voolu special_stream ja rippmenüüs In-application stream name DESTINATION_SQL_STREAM:

Kõigi manipuleerimiste tulemuseks peaks olema midagi sarnast alloleva pildiga:

SNS teema loomine ja tellimine

Liigume Simple Notification Service teenusesse ja loome seal uue teema nimega Airlines:

Oleme selle teema tellimise vormistamisel, seal määrame mobiiltelefoni numbri, kuhu saadetakse SMS-teavitused:

DynamoDB-s tabeli loomine

Käivitatud andmete salvestamiseks voost airline_tickets loome DynamoDB-s tabeli sama nimega. Peamiseks võtmeväiks on record_id:

Loomine lambdafunktsioon collector

Loome lambda-funktsioon nimega Collector, mille ülesandeks on küsida airline_tickets voogust ja, kui seal leitakse uusi kirjeid, sisestada need kirjed DynamoDB tabelisse. Ilmselgelt peab sellel lambdal lisaks vaikeõigustele olema juurdepääs Kinesi andmevoo lugemisele ja kirjutamisele DynamoDB-sse.

IAM-rolli loomine lambda-funktsioonile collector
Alustuseks loome uue IAM rolli lambdaks nimega Lambda-TicketsProcessingRole:

Testimise näitena sobivad eel seadistatud poliitikad AmazonKinesisReadOnlyAccess ja AmazonDynamoDBFullAccess, nagu on kujutatud alloleval pildil:

See lambda tuleb käivitada Kinesi käivituse tõttu uute kirjeid saabumise korral airline_stream voogu, seetõttu tuleb lisada uus käivitaja:

Nüüd tuleb lisada kood ja salvestada lambda.

"""Voogu analüüsides ja DynamoDB tabelisse sisestades."""
import base64
import json
import boto3
from decimal import Decimal

DYNAMO_DB = boto3.resource('dynamodb')
TABLE_NAME = 'airline_tickets'

class TicketsParser:
    """Voogust info analüüsimine."""

    def __init__(self, table_name, records):
        """Algusmeetod."""
        self.table = DYNAMO_DB.Table(table_name)
        self.json_data = TicketsParser.get_json_data(records)

    @staticmethod
    def get_json_data(records):
        """Tagastab deserialiseeritud andmed voost."""
        decoded_record_data = ([base64.b64decode(record['kinesis']['data'])
                                for record in records])
        json_data = ([json.loads(decoded_record)
                      for decoded_record in decoded_record_data])
        return json_data

    @staticmethod
    def get_item_from_json(json_item):
        """Eelprotsessib json andmed."""
        new_item = {
            'record_id': json_item.get('record_id'),
            'cost': Decimal(json_item.get('cost')),
            'trip_class': json_item.get('trip_class'),
            'show_to_affiliates': json_item.get('show_to_affiliates'),
            'origin': json_item.get('origin'),
            'number_of_changes': int(json_item.get('number_of_changes')),
            'gate': json_item.get('gate'),
            'found_at': json_item.get('found_at'),
            'duration': int(json_item.get('duration')),
            'distance': int(json_item.get('distance')),
            'destination': json_item.get('destination'),
            'depart_date': json_item.get('depart_date'),
            'actual': json_item.get('actual')
        }
        return new_item

    def run(self):
        """Tabelisse massilisamine."""
        with self.table.batch_writer() as batch_writer:
            for item in self.json_data:
                dynamodb_item = TicketsParser.get_item_from_json(item)
                batch_writer.put_item(dynamodb_item)

        print('Lisatud on ', len(self.json_data), 'eset')

def lambda_handler(event, context):
    """Analüüsi voogu ja sisestage DynamoDB tabelisse."""
    print('Sain sündmuse:', event)
    parser = TicketsParser(TABLE_NAME, event['Records'])
    parser.run()

Notifieri lambda-funktsiooni loomine

Teine lambda-funktsioon, mis jälgib teist voolu (special_stream) ja saadab teavituse SNS-ile, luuakse sarnaselt. Seega peab see lambda omama lugemisõigust Kinesis'elt ja saatma sõnumeid määratud SNS-teemasse, mis edastatakse seejärel kõigile selle teema tellijatele (e-post, SMS jne).

IAM rolli loomine
Esmalt loome IAM rolli Lambda-KinesisAlarm selle lambda jaoks ja seejärel määrame selle rolli loodavale lambda alarm_notifier.

See lambda peaks töötama sissetulevate uute kirjade voolu special_stream põhjalise triggerega, seega on vajalik seadistada trigger sarnaselt sellele, kuidas me seda tegime lambda Collector jaoks.

Selle lambda seadistamise mugavuse huvides loome uue keskkonnamuutujate — TOPIC_ARN, kuhu sisestame ANR (Amazon Resource Names) teema Airlines.

Ja sisestame lambda koodi, see on täiesti lihtne:

import boto3
import base64
import os

SNS_CLIENT = boto3.client('sns')
TOPIC_ARN = os.environ['TOPIC_ARN']


def lambda_handler(event, context):
    try:
        SNS_CLIENT.publish(TopicArn=TOPIC_ARN,
                           Message='Tere! Olen leidnud huvitavat sisu!',
                           Subject='Lennupiletite häire')
        print('Häireteade on edukalt edastatud')
    except Exception as err:
        print('Edastamise viga', str(err))

Tundub, et käsitsi seadistamine on nüüd lõpule viidud. Jääb vaid testida ja veenduda, et oleme kõik õigesti seadistunud.

Koodi Terraform'i kaudu rakendamine

Vajaliku ettevalmistus

Terraform — väga mugav avatud lähtekoodiga tööriist infrastruktuuri juurutamiseks koodist. Sellel on oma süntaks, mida on lihtne omandada ja palju näiteid, kuidas ning mida juurutada. Redaktorites like Atom või Visual Studio Code on palju mugavaid pluginaid, mis lihtsustavad Terraform'i kasutamist.

Distribuuti saab alla laadida siit. Terraform'i kõigi võimaluste üksikasjalik analüüs ületab selle artikli piire, seega piirdume peamiste punktidega.

Kuidas käivitada

Kogu projekti kood asub minu hoidlas. Kloonime endale hoidla. Enne käivitamist tuleb veenduda, et AWS CLI on installitud ja seadistatud, kuna Terraform otsib mandaate failist ~/ .aws / credentials.

Heaks praktikaks on enne terve infrastruktuuri juurutamist kasutada käsku plan, et näha, mida Terraform praegu meie jaoks pilve loob:

terraform.exe plan

Küsimine telefoninumbri sisestamiseks, et saada teateid, on kohustuslik. Selles etapis ei ole selle sisestamine vajalik.

Programmide tööplaani analüüsides saame alustada ressursside loomist:

terraform.exe apply

Pärast selle käsu saatmist küsitakse uuesti telefoninumbri sisestamist. Kui küsitakse, kas tegi tõeliselt toimingut, valige "jah". See võimaldab tõsta kõiki infrastruktuure, teha vajalikud EC2 seadistused, käivitada Lambda funktsioonid jne.

Pärast seda, kui kõik ressursid on Terraformi koodi kaudu edukalt loodud, peate minema Kinesis Analytics rakenduse üksikasjadesse (kahjuks ei leidnud ma, kuidas seda otse koodist teha).

Käivitame rakenduse:

Pärast seda tuleb selgelt määrata in-application voogude nimi, valides rippmenüüst:

Nüüd on kõik tööks valmis.

Rakenduse testimine

Sõltumata sellest, kuidas te süsteemi juurutate, käsitsi või Terraformi koodi kaudu, töötab see ühtlaselt.

Siseneme SSH kaudu EC2 virtuaalmasinasse, kuhu on installitud Kinesis Agent, ja käivitame skripti api_caller.py

sudo .\/api_caller.py TOKEN

Jäänud on oodata SMS sõnumit teie numbrile:

SMS - sõnum jõuab telefoni peaaegu minuti jooksul:

On jäänud vaadata, kas andmed on salvestatud DynamoDB andmebaasi, et teha hiljem põhjalikumat analüüsi. Tabel airline_tickets sisaldab ligikaudu selliseid andmeid:

Kokkuvõte

Tehtud töö käigus loodi veebipõhine andmete töötlemise süsteem Amazon Kinesisel. Uuriti Kinesis Agendi kasutamise võimalusi koos Kinesis Data Streams'i ja reaalajas analüüsi Kinesis Analytics'i SQL käskude abil, samuti Amazon Kinesis’i koostööd teiste AWS teenustega.

Ülaltoodud süsteemi juurutati kahes variandis: aeglaselt käsitsi ja kiirelt Terraformi koodi kaudu.

Kogu projekti allikakood on saadaval minu GitHubi hoidlas, soovitan sellega tutvuda.

Olen valmis artiklit arutama, ootan teie kommentaare. Lootsin konstruktiivset kriitikat.

Soovin edu!

Allikas: habr.com