Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless

Bok, Habr!

Volite li letjeti avionom? Obožavam to, ali tijekom samoizolacije zavolio sam i analizu podataka o avio kartama jednog poznatog resursa — Aviasales.

Danas ćemo istražiti Amazon Kinesis, izgraditi sustav streaminga s analitikom u stvarnom vremenu, postaviti NoSQL bazu podataka Amazon DynamoDB kao glavnu pohranu podataka i postaviti obavijesti putem SMS-a za zanimljive karte.

Sve pojedinosti nalaze se ispod! Idemo!

Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless

Uvod

Za primjer će nam trebati pristup API-ju Aviasales. Pristup je besplatan i neograničen, potrebno je samo registrirati se u odjeljku 'Za programere' kako biste dobili svoj API token za pristup podacima.

Glavni cilj ovog članka je dati opće razumijevanje korištenja streaminga informacija u AWS-u, izostavljamo činjenicu da podaci koje vraća korišteni API nisu strogo aktualni i prenose se iz keša koji se formira na temelju pretraga korisnika na stranicama Aviasales.ru i Jetradar.com tijekom posljednja 48 sati.

Podaci o avio kartama dobiveni putem API-ja, Kinesis-agent, koji je instaliran na stroju proizvođaču, automatski će se parsirati i prenositi u odgovarajući tok putem Kinesis Data Analytics. Prerađena verzija ovog toka bit će direktno zapisana u pohranu. Razvijena pohrana u DynamoDB za 'sirove' podatke omogućit će dublju analizu karata preko BI alata, kao što je AWS Quick Sight.

Razmotrit ćemo dvije opcije za implementaciju cijele infrastrukture:

  • Ručna — preko AWS Management Console;
  • Infrastruktura iz Terraform koda — za lenje automatizatore;

Arhitektura razvijenog sustava

Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless
Koristeni sastavni dijelovi:

  • Aviasales API — podaci koje vraća ovaj API bit će korišteni za cijeli daljnji rad;
  • EC2 Instance proizvođača — obična virtualna mašina u oblaku koja će generirati ulazni tok podataka:
    • Kinesis Agent — Java aplikacija koja se instalira lokalno na uređaj, te pruža jednostavan način za prikupljanje i slanje podataka u Kinesis (Kinesis Data Streams ili Kinesis Firehose). Agent neprekidno prati set datoteka u navedenim direktorijima i šalje nove podatke u Kinesis;
    • Skript za pozivanje API-ja — Python skripta koja šalje upite API-ju i sprema odgovor u mapu koju Kinesis Agent prati;
  • Kinesis Data Streams — servis za streaming podataka u stvarnom vremenu s širokim mogućnostima skaliranja;
  • Kinesis Analytics — besposlužni servis koji pojednostavljuje analizu strujnih podataka u stvarnom vremenu. Amazon Kinesis Data Analytics podešava resurse za rad aplikacija i automatski se skalira za obradu bilo kakvih volumena ulaznih podataka;
  • AWS Lambda — servis koji omogućava pokretanje koda bez rezerviranja i podešavanja servera. Sve računalne snage automatski se skaliraju za svaki poziv;
  • Amazon DynamoDB — baza podataka parova "ključ-vrijednost" i dokumenata koja osigurava kašnjenje manje od 10 milisekundi pri radu u bilo kojem opsegu. Koristeći DynamoDB, nije potrebno raspoređivati servere, instalirati ispravke ili njima upravljati. DynamoDB automatski skalira tablice prilagođavajući količinu dostupnih resursa i održava visoke performanse. Nema potrebe za administrativnim radnjama;
  • Amazon SNS — potpuno upravljani servis za slanje poruka po modelu "izdavač - pretplatnik" (Pub/Sub), putem kojeg se mogu izolirati mikroservisi, distribuirani sustavi i besposlužne aplikacije. SNS se može koristiti za slanje informacija krajnjim korisnicima putem mobilnih push obavijesti, SMS poruka i e-pošte.

Početna priprema

Za emulaciju toka podataka odlučio sam koristiti informacije o avionskim kartama koje vraća API Aviasales. U dokumentaciju prilično opsežnom popisu različitih metoda, uzmimo jednu od njih — "Kalendar cijena za mjesec", koja vraća cijene za svaki dan u mjesecu, grupirane prema broju presjedanja. Ako se u zahtjevu ne dostavi mjesec pretraživanja, vraćene informacije bit će za mjesec koji slijedi nakon trenutnog.

Dakle, registriramo se, dobivamo svoj token.

Primjer zahtjeva je u nastavku:

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

Gore opisani način dobivanja podataka iz API-ja s naznačenim tokenom u zahtjevu će raditi, ali više volim prenositi token pristupa kroz zaglavlje, pa ćemo u skripti api_caller.py koristiti upravo ovaj način.

Primjer odgovora:

{{
   "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
   }]
}

U primjeru odgovora API-ja iznad prikazana je karta iz Sankt Peterburga u Phuk… Ah, da ne sanjam…
Budući da sam iz Kazan, a Phuket nam trenutno "samo sniva", pronađimo karte iz Sankt Peterburga u Kazan.

Pretpostavlja se da već imate račun na AWS-u. Odmah želim posebno skrenuti pažnju na to da Kinesis i slanje obavijesti putem SMS-a nisu uključeni u godišnji Free Tier (besplatna upotreba). No, unatoč tome, ako imate na umu nekoliko dolara, sasvim je moguće izgraditi predloženi sustav i eksperimentirati s njim. I, naravno, ne zaboravite ukloniti sve resurse nakon što postanu nepotrebni.

Na sreću, DynamoDb i lambda funkcije će za nas biti uvjetno besplatne ako se uklopimo u mjesečne besplatne limite. Na primjer, za DynamoDB: 25 GB pohrane, 25 WCU/RCU i 100 milijuna upita. I milijun poziva lambda funkcija mjesečno.

Ručno postavljanje sustava

Postavke Kinesis Data Streams

Pređimo na uslugu Kinesis Data Streams i kreirajmo dva nova toka s jednim shardom za svaki.

Što je shard?
Shard je osnovna jedinica prijenosa podataka toka Amazon Kinesis. Jedan segment osigurava prijenos ulaznih podataka brzinom od 1 MB/s i prijenos izlaznih podataka brzinom od 2 MB/s. Jedan segment može podržati do 1000 PUT zapisa u sekundi. Prilikom kreiranja toka podataka potrebno je navesti potrebno broj segmenata. Na primjer, možete stvoriti tok podataka s dva segmenta. Ovaj tok podataka osigurat će prijenos ulaznih podataka brzinom od 2 MB/s i prijenos izlaznih podataka brzinom od 4 MB/s, uz podršku za do 2000 PUT zapisa u sekundi.

Što više shardova imate u svom toku — to veća propusnost. U načelu, to su načini na koje se tokovi skaliraju — dodavanjem shardova. No, što više shardova imate, to je i cijena viša. Svaki shard košta 1,5 centi po satu i dodatnih 1,4 centa za svaku milijun operacija dodavanja u tok (PUT payload units).

Kreirajmo novi tok s imenom airline_tickets, njemu će biti dovoljan 1 shard:

Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless
Sada kreirajmo još jedan tok s imenom special_stream:

Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless

Postavka proizvođača

Kao proizvođač podataka za rješavanje zadatka dovoljno je koristiti običan EC2 instans. To ne mora biti moćna skupa virtualna mašina, bit će dovoljno spot t2.micro.

Važna napomena: za primjer treba koristiti image — Amazon Linux AMI 2018.03.0, s njim ima manje postavki za brzi pokret Kinesis Agent.

Idemo na EC2 uslugu, kreiramo novu virtualnu mašinu, biramo traženi AMI tipa t2.micro, koji je uključen u Free Tier:

Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless
Da bi nova virtualna mašina mogla komunicirati s Kinesis uslugom, potrebno je dati joj prava za to. Najbolji način za to je dodijeliti IAM ulogu. Stoga, na ekranu koraka 3: Konfiguriraj detalje instance, trebate odabrati Kreiraj novu IAM ulogu:

Kreiranje IAM uloge za EC2
Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless
U otvorenom prozoru odabiremo da novu ulogu kreiramo za EC2 i prelazimo na odjeljak Dozvole:

Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless
U ovom primjeru ne moramo se zamarati svim detaljima granularne konfiguracije prava na resurse, stoga ćemo odabrati unaprijed postavljene Amazonove politike: AmazonKinesisFullAccess i CloudWatchFullAccess.

Dajmo ovoj ulozi neko smisleno ime, na primjer: EC2-KinesisStreams-FullAccess. Kao rezultat, treba da dobijemo isto što je prikazano na slici ispod:

Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless
Nakon kreiranja ove nove uloge, ne zaboravite prikačiti je na instancu virtualne mašine koju kreirate:

Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless
Na ovom ekranu više ništa ne mijenjamo i prelazimo na sljedeće prozore.

Postavke tvrdog diska možemo ostaviti prema zadanim parametrima, kao i oznake (iako je dobra praksa koristiti oznake, barem dodati ime instanci i označiti okoliš).

Sada smo na kartici Step 6: Konfiguriraj grupu sigurnosti, gdje je potrebno kreirati novu ili odabrati postojeću grupu sigurnosti koja omogućava povezivanje putem ssh (port 22) na instancu. Odaberite izvor —> Moj IP i možete pokrenuti instancu.

Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless
S čim pređe u status pokretanja, možete pokušati povezati se na njega putem ssh.

Da biste dobili mogućnost rada s Kinesis Agent-om, nakon uspješne veze s mašinom, potrebno je unijeti sljedeće komande u terminal:

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

Kreirajmo mapu za pohranu API odgovora:

sudo mkdir /var/log/airline_tickets

Prije pokretanja agenta, potrebno je konfigurirati njegov config:

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

Sadržaj datoteke agent.json trebao bi imati sljedeći oblik:

{
  "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"]
         }
      ]
    }
  ]
}

Kao što je prikazano u konfiguracijskoj datoteci, agent će nadzirati direktorij /var/log/airline_tickets/ za datoteke s ekstenzijom .log, analizirati ih i slati u tok airline_tickets.

Ponovno pokrećemo servis i provjeravamo da li se pokrenuo i radi:

sudo service aws-kinesis-agent restart

Sada ćemo preuzeti Python skriptu koja će zatražiti podatke od API-ja:

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

Skripta api_caller.py zatražuje podatke od Aviasales-a i sprema dobiveni odgovor u direktorij koji skenira Kinesis agent. Implementacija ove skripte je prilično standardna, postoji klasa TicketsApi koja omogućava asinkrono dohvaćanje API-ja. U tu klasu predajemo zaglavlje s tokenom i parametre zahtjeva:

class TicketsApi:
    """Klasa za pozivanje API-ja."""

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

    async def get_data(self, data):
        """Dohvati podatke iz API zahtjeva."""
        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('Status odgovora %s: %s',
                            self.base_url, response.status)
                response_json = await response.json()
            except HTTPError as http_err:
                LOGGER.error('Oops! Došlo je do HTTP greške: %s', str(http_err))
            except Exception as err:
                LOGGER.error('Oops! Došlo je do greške: %s', str(err))
            return response_json


def prepare_request(api_token):
    """Vraća zaglavlja i upit za API zahtjev."""
    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():
    """Pokreni kod."""
    if len(sys.argv) != 2:
        print('Korištenje: api_caller.py ')
        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 je vratio %s stavki', len(response['data']))
        try:
            count_rows = log_maker(response)
            LOGGER.info('%s redova je spremljeno u %s',
                        count_rows,
                        TARGET_FILE)
        except Exception as e:
            LOGGER.error('Oops! Rezultat zahtjeva nije spremljen u datoteku. %s',
                         str(e))
    else:
        LOGGER.error('Oops! API zahtjev nije bio uspješan %s!', response)

Za testiranje ispravnosti postavki i funkcionalnosti agenta, napravit ćemo testno pokretanje skripte api_caller.py:

sudo ./api_caller.py TOKEN

Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless
I gledamo rezultat rada u logovima Agenta i na kartici Monitoring u toku podataka airline_tickets:

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

Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless
Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless
Kao što se može vidjeti, sve funkcionira i Kinesis Agent uspješno šalje podatke u tok. Sada ćemo postaviti consumer.

Postavljanje Kinesis Data Analytics

Prelazimo na središnju komponentu cijelog sustava — kreiramo novu aplikaciju u Kinesis Data Analytics pod imenom kinesis_analytics_airlines_app:

Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless
Kinesis Data Analytics omogućuje analizu podataka u stvarnom vremenu iz Kinesis Streams koristeći SQL jezik. To je potpuno automatski skalabilna usluga (za razliku od Kinesis Streams) koja:

  1. omogućuje stvaranje novih tokova (Output Stream) na temelju upita na izvorne podatke;
  2. pruža tok s pogreškama koje su se pojavile tijekom rada aplikacija (Error Stream);
  3. može automatski odrediti shemu ulaznih podataka (može se ručno redefinirati po potrebi).

Ova usluga nije jeftina — 0.11 USD po satu rada, stoga je treba koristiti pažljivo i ukloniti kada se završi s radom.

Povezat ćemo aplikaciju s izvorom podataka:

Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless
Biramo tok kojem se planiramo povezati (airline_tickets):

Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless
Nakon toga, potrebno je dodati novu IAM ulogu kako bi aplikacija mogla čitati iz toka i pisati u tok. Za to je dovoljno ne mijenjati ništa u bloku Access permissions:

Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless
Sada ćemo zatražiti otkrivanje sheme podataka u toku, za to pritisnite gumb «Discover schema». Kao rezultat, ažurit će se (stvorit će se nova) IAM uloga i pokrenut će se otkrivanje sheme iz podataka koji su već pristižu u tok:

Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless
Sada je potrebno preći na SQL editor. Kada pritisnete ovaj gumb, otvorit će se prozor s pitanjem o pokretanju aplikacije — odabiremo što želimo pokrenuti:

Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless
U SQL editor prozor umetnemo jednostavan upit i pritisnemo 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';

U relacijskim bazama podataka radite s tablicama, koristeći operatore INSERT za dodavanje zapisa i operater SELECT za upit podataka. U Amazon Kinesis Data Analytics radite s tokovima (STREAM) i "pumpama" (PUMP) — kontinuiranim upitima umetanja koji umetnu podatke iz jednog toka u aplikaciji u drugi tok.

U gornjem SQL upitu se pretražuju Aeroflot karte po cijeni manjoj od pet tisuća rubalja. Svi zapisi koji zadovoljavaju te uvjete bit će smješteni u tok DESTINATION_SQL_STREAM.

Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless
U bloku Destination odabiremo tok special_stream, a u padajućem meniju In-application stream name DESTINATION_SQL_STREAM:

Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless
Kao rezultat svih manipulacija, trebali bismo dobiti nešto slično slici ispod:

Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless

Izrada i pretplata na SNS temu

Prelazimo na servis Simple Notification Service i tamo kreiramo novu temu pod imenom Airlines:

Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless
Prijavljujemo se na ovu temu, u njoj navodimo broj mobilnog telefona na koji će dolaziti SMS obavijesti:

Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless

Izrada tablice u DynamoDB

Za pohranu obrađenih podataka iz toka airline_tickets, stvorit ćemo tablicu u DynamoDB s istim imenom. Kao primarni ključ koristit ćemo record_id:

Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless

Izrada lambda funkcije collector

Stvaramo lambda funkciju pod nazivom Collector, čija je zadaća ispitivanje toka airline_tickets i, u slučaju pronalaska novih zapisa, umetanje tih zapisa u tablicu DynamoDB. Očigledno je da, osim zadatih prava, ova lambda mora imati pristup za čitanje toka podataka Kinesis i pisanje u DynamoDB.

Izrada IAM uloge za lambda funkciju collector
Za početak, kreiramo novu IAM ulogu za lambdu pod imenom Lambda-TicketsProcessingRole:

Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless
Za testni primjer više nego dovoljno mogu poslužiti unaprijed podešene politike AmazonKinesisReadOnlyAccess i AmazonDynamoDBFullAccess, kao što je prikazano na slici ispod:

Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless
Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless

Ova lambda se mora pokrenuti na temelju okidača od Kinesis-u kada novi zapisi dođu u tok airline_stream, stoga je potrebno dodati novi okidač:

Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless
Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless
Preostaje umetnuti kod i sačuvati lambdu.

"""Parsiranje toka i umetanje u DynamoDB tablicu."""
import base64
import json
import boto3
from decimal import Decimal

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

class TicketsParser:
    """Parsiranje informacija iz toka."""

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

    @staticmethod
    def get_json_data(records):
        """Vraća deserializirane podatke iz toka."""
        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):
        """Pre-obrada json podataka."""
        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):
        """Batch umetanje u tablicu."""
        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('Dodano je ', len(self.json_data), ' stavki')

def lambda_handler(event, context):
    """Parsiranje toka i umetanje u DynamoDB tablicu."""
    print('Događaj:', event)
    parser = TicketsParser(TABLE_NAME, event['Records'])
    parser.run()

Kreiranje lambda funkcije notifier

Druga lambda funkcija, koja će nadgledati drugi tok (special_stream) i slati obavijest u SNS, kreira se na sličan način. Stoga, ova lambda mora imati pristup za čitanje iz Kinesis-a i slanje poruka u određeni SNS-temat koji dalje servis SNS šalje svim pretplatnicima te teme (e-mail, SMS itd.).

Izrada IAM uloge
Prvo kreiramo IAM ulogu Lambda-KinesisAlarm za ovu lambdu, a zatim dodjeljujemo ovu ulogu za kreiranu lambdu alarm_notifier:

Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless
Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless

Ova lambda bi trebala raditi uz okidač kada nove stavke dođu u tok special_stream, stoga je potrebno postaviti okidač slično kao što smo to radili za lambdu Collector.

Za lakšu konfiguraciju ove lambde, uvodimo novu varijablu okruženja — TOPIC_ARN, gdje postavljamo ANR (Amazon Resource Names) teme Airlines:

Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless
I umetnemo kod lambde, koji je vrlo jednostavan:

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='Bok! Pronašao sam zanimljive stvari!',
                           Subject='Alarm za avionske karte')
        print('Poruka alarma je uspješno isporučena')
    except Exception as err:
        print('Neuspjeh u isporuci', str(err))

Čini se da je ovdje ručna konfiguracija sustava završena. Preostaje samo testirati i uvjeriti se da smo sve pravilno postavili.

Implementacija iz Terraform koda

Potrebna priprema

Terraform — vrlo praktičan open-source alat za implementaciju infrastrukture iz koda. Ima svoju sintaksu koja se lako usvaja i brojne primjere kako i što implementirati. U uređivaču Atom ili Visual Studio Code ima mnogo praktičnih dodataka koji olakšavaju rad s Terraform-om.

Distribuciju možete preuzeti odavde. Detaljna analiza svih mogućnosti Terraform-a premašuje okvire ovog članka, stoga ćemo se ograničiti na osnovne točke.

Kako pokrenuti

Puni kod projekta se nalazi u mom repozitoriju. Klonirajte repozitorij na svoju mašinu. Prije pokretanja potrebno je osigurati da ste instalirali i konfigurirali AWS CLI, jer će Terraform tražiti vjerodajnice u datoteci ~\/\.aws\/credentials.

Dobra praksa je da prije implementacije cijele infrastrukture pokrenete naredbu plan, kako biste vidjeli što Terraform planira izraditi u oblaku:

terraform.exe plan

Bit će vam zatraženo da unesete broj telefona za primanje obavijesti. U ovoj fazi njegovo unošenje nije obavezno.

Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless
Analiziravši plan rada programa, možemo početi s izradom resursa:

terraform.exe apply

Nakon slanja ove naredbe opet će se pojaviti upit za unos broja telefona, upišite 'yes' kada se postavi pitanje o stvarnom izvršavanju radnji. To će omogućiti podizanje cijele infrastrukture, izvršavanje svih potrebnih postavki EC2, implementaciju lambda funkcija itd.

Nakon što su svi resursi uspješno stvoreni putem Terraform koda, potrebno je ući u detalje Kinesis Analytics aplikacije (nažalost, nisam pronašao kako to učiniti odmah iz koda).

Pokrećemo aplikaciju:

Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless
Nakon toga potrebno je izričito postaviti in-application stream name, birajući iz padajuće liste:

Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless
Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless
Sada je sve spremno za rad.

Testiranje rada aplikacije

Bez obzira na to kako ste implementirali sustav, ručno ili putem Terraform koda, radit će jednako.

Prijavljivanje putem SSH na virtualnu mašinu EC2, gdje je instaliran Kinesis Agent, i pokretanje skripte api_caller.py

sudo ./api_caller.py TOKEN

Ostalo je čekati SMS na vaš broj:

Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless
SMS – poruka dolazi na telefon gotovo odmah, za otprilike 1 minutu:

Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless
Ostaje provjeriti jesu li zapisi pohranjeni u bazi podataka DynamoDB za daljnju, detaljniju analizu. Tablica airline_tickets sadrži otprilike ove podatke:

Integracija Aviasales API s Amazon Kinesis i jednostavnost serverless

Zaključak

U tijeku rada izgrađen je sustav online obrade podataka temeljen na Amazon Kinesis. Razmatrane su opcije korištenja Kinesis Agenta u vezi s Kinesis Data Streams i real-time analizom Kinesis Analytics pomoću SQL naredbi, kao i interakcija Amazon Kinesis s drugim AWS uslugama.

Opišemo sustav smo postavili na dva načina: prilično dugog ručnog i brzog putem Terraform koda.

Sav izvorni kod projekta dostupan je u mom repozitoriju na GitHubu, predlažem da se upoznate s njim.

Rado ću razgovarati o članku, čekam vaše komentare. Nadam se konstruktivnoj kritici.

Želim vam puno uspjeha!

Izvor: habr.com

Kupite pouzdan hosting za web stranice s DDoS zaštitom, VPS VDS servere 🔥 Kupite pouzdan hosting za web stranice s DDoS zaštitom, VPS VDS servere | ProHoster