Aviasales API integrācija ar Amazon Kinesis un vienkāršība bez serveriem

Čau Habr!

Vai jums patīk lidot ar lidmašīnām? Man tas patīk, bet pašizolācijas laikā es iemīlējos arī aviobiļešu datu analīzē no viena labi zināma resursa - Aviasales.

Šodien mēs analizēsim Amazon Kinesis darbu, izveidosim straumēšanas sistēmu ar reāllaika analīzi, kā galveno datu krātuvi instalēsim Amazon DynamoDB NoSQL datu bāzi un iestatīsim SMS paziņojumus interesantām biļetēm.

Visas detaļas ir zem griezuma! Aiziet!

Ievads

Piemēram, mums ir nepieciešama piekļuve Aviasales API. Piekļuve tai tiek nodrošināta bez maksas un bez ierobežojumiem; jums tikai jāreģistrējas sadaļā “Izstrādātāji”, lai saņemtu API marķieri, lai piekļūtu datiem.

Šī raksta galvenais mērķis ir sniegt vispārēju izpratni par informācijas straumēšanas izmantošanu AWS; mēs ņemam vērā, ka izmantotie API atgrieztie dati nav stingri atjaunināti un tiek pārsūtīti no kešatmiņas, kas ir izveidots, pamatojoties uz vietņu Aviasales.ru un Jetradar.com lietotāju meklējumiem pēdējo 48 stundu laikā.

Kinesis aģents, kas instalēts ražošanas mašīnā un saņemts, izmantojot API, automātiski parsēs un pārsūtīs datus uz vēlamo straumi, izmantojot Kinesis Data Analytics. Šīs straumes neapstrādātā versija tiks rakstīta tieši veikalā. DynamoDB izvietotā neapstrādāto datu krātuve ļaus veikt dziļāku biļešu analīzi, izmantojot BI rīkus, piemēram, AWS Quick Sight.

Mēs apsvērsim divas iespējas visas infrastruktūras izvietošanai:

• Rokasgrāmata - izmantojot AWS pārvaldības konsoli;
• Infrastruktūra no Terraform koda ir paredzēta slinkiem automātiem;

Izstrādātās sistēmas arhitektūra

Izmantotās sastāvdaļas:

• Aviasales API — šīs API atgrieztie dati tiks izmantoti visam turpmākajam darbam;
• EC2 ražotāja instance — parasta virtuālā mašīna mākonī, kurā tiks ģenerēta ievades datu straume:
  • Kinēzes aģents ir ierīcē lokāli instalēta Java lietojumprogramma, kas nodrošina vienkāršu veidu, kā apkopot un nosūtīt datus uz Kinesis (Kinesis Data Streams vai Kinesis Firehose). Aģents pastāvīgi uzrauga failu kopu norādītajos direktorijos un nosūta jaunus datus uz Kinesis;
  • API zvanītāja skripts — Python skripts, kas veic pieprasījumus API un ievieto atbildi mapē, kuru uzrauga Kinesis aģents;
• Kinesis datu straumes — reāllaika datu straumēšanas pakalpojums ar plašām mērogošanas iespējām;
• Kinēzes analīze ir pakalpojums bez serveriem, kas vienkāršo straumēšanas datu analīzi reāllaikā. Amazon Kinesis Data Analytics konfigurē lietojumprogrammu resursus un automātiski mērogojas, lai apstrādātu jebkāda apjoma ienākošos datus;
• AWS Lambda — pakalpojums, kas ļauj palaist kodu bez dublēšanas vai serveru iestatīšanas. Visa skaitļošanas jauda tiek automātiski mērogota katram zvanam;
• Amazon DynamoDB - Atslēgu un vērtību pāru un dokumentu datu bāze, kas nodrošina latentumu, kas mazāks par 10 milisekundēm, ja darbojas jebkurā mērogā. Izmantojot DynamoDB, jums nav jānodrošina, jālabo vai jāpārvalda serveri. DynamoDB automātiski mērogo tabulas, lai pielāgotu pieejamo resursu apjomu un uzturētu augstu veiktspēju. Nav nepieciešama sistēmas administrēšana;
• Amazon SNS - pilnībā pārvaldīts pakalpojums ziņojumu sūtīšanai, izmantojot izdevēja-abonenta (Pub/Sub) modeli, ar kuru varat izolēt mikropakalpojumus, izkliedētās sistēmas un lietojumprogrammas bez serveriem. SNS var izmantot, lai nosūtītu informāciju gala lietotājiem, izmantojot mobilos push paziņojumus, SMS un e-pastus.

Sākotnējā apmācība

Lai atdarinātu datu plūsmu, es nolēmu izmantot Aviasales API atgriezto informāciju par aviobiļetēm. IN dokumentācija diezgan plašs dažādu metožu saraksts, ņemsim vienu no tiem - “Mēneša cenu kalendārs”, kas atgriež cenas katrai mēneša dienai, sagrupētas pēc pārskaitījumu skaita. Ja pieprasījumā nenorādīsiet meklēšanas mēnesi, informācija tiks atgriezta par nākamo mēnesi pēc pašreizējā mēneša.

Tātad, reģistrēsimies un saņemsim savu žetonu.

Pieprasījuma piemērs ir zemāk:

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

Iepriekš minētā metode datu saņemšanai no API, pieprasījumā norādot pilnvaru, darbosies, taču es dodu priekšroku piekļuves pilnvaras nodošanai caur galveni, tāpēc mēs izmantosim šo metodi skriptā api_caller.py.

Atbildes piemērs:

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

Augšējā API atbildes piemērā ir redzama biļete no Sanktpēterburgas uz Puku... Ak, kāds sapnis...
Tā kā esmu no Kazaņas, un Puketa tagad ir “tikai sapnis”, tad meklēsim biļetes no Sanktpēterburgas uz Kazaņu.

Tiek pieņemts, ka jums jau ir AWS konts. Uzreiz vēlos vērst īpašu uzmanību, ka Kinesis un paziņojumu sūtīšana ar SMS nav iekļauta gada Bezmaksas līmenis (bezmaksas izmantošana). Bet pat neskatoties uz to, ar pāris dolāriem prātā, ir pilnīgi iespējams izveidot piedāvāto sistēmu un spēlēt ar to. Un, protams, neaizmirstiet izdzēst visus resursus pēc tam, kad tie vairs nav vajadzīgi.

Par laimi, DynamoDb un lambda funkcijas mums būs bez maksas, ja mēs izpildīsim savus mēneša bezmaksas limitus. Piemēram, DynamoDB: 25 GB krātuve, 25 WCU/RCU un 100 miljoni vaicājumu. Un miljons lambda funkciju zvanu mēnesī.

Sistēmas manuāla izvietošana

Kinesis datu straumju iestatīšana

Dosimies uz pakalpojumu Kinesis Data Streams un izveidosim divas jaunas straumes, katrai pa vienai shardam.

Kas ir lauskas?
Shard ir Amazon Kinesis straumes pamata datu pārsūtīšanas vienība. Viens segments nodrošina ievades datu pārraidi ar ātrumu 1 MB/s un izejas datu pārraidi ar ātrumu 2 MB/s. Viens segments atbalsta līdz 1000 PUT ierakstiem sekundē. Veidojot datu straumi, jānorāda nepieciešamais segmentu skaits. Piemēram, varat izveidot datu straumi ar diviem segmentiem. Šī datu straume nodrošinās ieejas datu pārsūtīšanu ar ātrumu 2 MB/s un izejas datu pārraidi ar ātrumu 4 MB/s, atbalstot līdz 2000 PUT ierakstiem sekundē.

Jo vairāk šķembu jūsu straumē, jo lielāka ir tās caurlaidspēja. Principā plūsmas tiek mērogotas šādi - pievienojot skaidiņas. Bet jo vairāk lauskas jums ir, jo augstāka cena. Katra šķemba maksā 1,5 centus stundā un papildu 1.4 centus par katru miljonu PUT kravas vienību.

Izveidosim jaunu straumi ar nosaukumu aviobiļetes, viņam pietiks ar 1 skaidiņu:

Tagad izveidosim citu pavedienu ar nosaukumu īpašā_straume:

Ražotāja iestatīšana

Lai analizētu uzdevumu, pietiek ar parastu EC2 gadījumu kā datu veidotāju. Tai nav jābūt jaudīgai, dārgai virtuālai mašīnai; t2.micro būs lieliski piemērots.

Svarīga piezīme: piemēram, jums vajadzētu izmantot attēlu - Amazon Linux AMI 2018.03.0, tam ir mazāk iestatījumu, lai ātri palaistu Kinesis Agent.

Dodieties uz pakalpojumu EC2, izveidojiet jaunu virtuālo mašīnu, atlasiet vajadzīgo AMI ar tipu t2.micro, kas ir iekļauts bezmaksas līmenī:

Lai jaunizveidotā virtuālā mašīna varētu mijiedarboties ar Kinesis servisu, tai ir jāpiešķir tiesības to darīt. Labākais veids, kā to izdarīt, ir piešķirt IAM lomu. Tāpēc ekrānā 3. darbība: Instances informācijas konfigurēšana ir jāatlasa Izveidojiet jaunu IAM lomu:

IAM lomas izveide EC2

Atvērtajā logā atlasiet, ka mēs veidojam jaunu lomu EC2, un dodieties uz sadaļu Atļaujas:

Izmantojot apmācību piemēru, mums nav jāiedziļinās visās resursu tiesību detalizētās konfigurācijas sarežģītībās, tāpēc mēs atlasīsim Amazon iepriekš konfigurētās politikas: AmazonKinesisFullAccess un CloudWatchFullAccess.

Piešķirsim šai lomai kādu jēgpilnu nosaukumu, piemēram: EC2-KinesisStreams-FullAccess. Rezultātam jābūt tādam pašam, kā parādīts zemāk esošajā attēlā:

Pēc šīs jaunās lomas izveides neaizmirstiet to pievienot izveidotajai virtuālās mašīnas instancei:

Mēs neko citu šajā ekrānā nemainām un pārejam pie nākamajiem logiem.

Cietā diska iestatījumus var atstāt kā noklusējuma iestatījumus, kā arī tagus (lai gan laba prakse ir izmantot tagus, vismaz piešķiriet instancei nosaukumu un norādiet vidi).

Tagad mēs atrodamies cilnē 6. darbība: drošības grupas konfigurēšana, kur jums ir jāizveido jauna vai jānorāda esošā drošības grupa, kas ļauj izveidot savienojumu ar gadījumu, izmantojot ssh (ports 22). Tur atlasiet Avots -> Mans IP un varat palaist instanci.

Tiklīdz tas pārslēdzas uz darbības statusu, varat mēģināt izveidot savienojumu ar to, izmantojot ssh.

Lai varētu strādāt ar Kinesis Agent, pēc veiksmīgas savienojuma izveides ar iekārtu, terminālā jāievada šādas komandas:

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

Izveidosim mapi API atbilžu saglabāšanai:

sudo mkdir /var/log/airline_tickets

Pirms aģenta palaišanas jums jākonfigurē tā konfigurācija:

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

Faila agent.json saturam vajadzētu izskatīties šādi:

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

Kā redzams no konfigurācijas faila, aģents pārraudzīs failus ar paplašinājumu .log direktorijā /var/log/airline_tickets/, parsēs tos un pārsūtīs uz aviobiļetes straumi.

Mēs restartējam pakalpojumu un pārliecināmies, ka tas ir izveidots un darbojas:

sudo service aws-kinesis-agent restart

Tagad lejupielādēsim Python skriptu, kas pieprasīs datus no API:

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

Skripts api_caller.py pieprasa datus no Aviasales un saglabā saņemto atbildi direktorijā, ko skenē Kinesis aģents. Šī skripta ieviešana ir diezgan standarta, ir TicketsApi klase, tā ļauj asinhroni vilkt API. Mēs nododam galveni ar pilnvaru un pieprasām parametrus šai klasei:

class TicketsApi:
    """Api caller class."""

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

    async def get_data(self, data):
        """Get the data from API query."""
        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('Response status %s: %s',
                            self.base_url, response.status)
                response_json = await response.json()
            except HTTPError as http_err:
                LOGGER.error('Oops! HTTP error occurred: %s', str(http_err))
            except Exception as err:
                LOGGER.error('Oops! An error ocurred: %s', str(err))
            return response_json


def prepare_request(api_token):
    """Return the headers and query fot the API request."""
    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():
    """Get run the code."""
    if len(sys.argv) != 2:
        print('Usage: api_caller.py <your_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 has returned %s items', len(response['data']))
        try:
            count_rows = log_maker(response)
            LOGGER.info('%s rows have been saved into %s',
                        count_rows,
                        TARGET_FILE)
        except Exception as e:
            LOGGER.error('Oops! Request result was not saved to file. %s',
                         str(e))
    else:
        LOGGER.error('Oops! API request was unsuccessful %s!', response)

Lai pārbaudītu pareizos aģenta iestatījumus un funkcionalitāti, pārbaudīsim skriptu api_caller.py:

sudo ./api_caller.py TOKEN

Un mēs aplūkojam darba rezultātus aģentu žurnālos un cilnē Monitorings datu straumē airline_tickets:

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

Kā redzat, viss darbojas un Kinesis Agent veiksmīgi nosūta datus uz straumi. Tagad konfigurēsim patērētāju.

Kinesis Data Analytics iestatīšana

Pārejam pie visas sistēmas centrālās sastāvdaļas — izveidojiet jaunu lietojumprogrammu programmā Kinesis Data Analytics ar nosaukumu kinesis_analytics_airlines_app:

Kinesis Data Analytics ļauj veikt reāllaika datu analīzi no Kinesis Streams, izmantojot SQL valodu. Tas ir pilnībā automātiskās mērogošanas pakalpojums (atšķirībā no Kinesis Streams), kas:

1. ļauj izveidot jaunas straumes (Output Stream), pamatojoties uz avota datu pieprasījumiem;
2. nodrošina straumi ar kļūdām, kas radušās lietojumprogrammu darbības laikā (Error Stream);
3. var automātiski noteikt ievaddatu shēmu (ja nepieciešams, to var manuāli pārdefinēt).

Šis nav lēts pakalpojums - 0.11 USD par darba stundu, tāpēc jums tas jāizmanto uzmanīgi un jāizdzēš, kad esat pabeidzis.

Savienosim lietojumprogrammu ar datu avotu:

Atlasiet straumi, ar kuru mēs izveidosim savienojumu (airline_tickets):

Pēc tam jums jāpievieno jauna IAM loma, lai lietojumprogramma varētu lasīt no straumes un rakstīt straumē. Lai to izdarītu, pietiek neko nemainīt piekļuves atļauju blokā:

Tagad pieprasīsim datu shēmas atklāšanu straumē; lai to izdarītu, noklikšķiniet uz pogas “Atklāt shēmu”. Rezultātā IAM loma tiks atjaunināta (tiks izveidota jauna) un tiks palaists shēmas noteikšana no datiem, kas jau ir nonākuši straumē:

Tagad jums jāiet uz SQL redaktoru. Noklikšķinot uz šīs pogas, parādīsies logs ar aicinājumu palaist lietojumprogrammu - atlasiet, ko vēlaties palaist:

SQL redaktora logā ievietojiet šādu vienkāršo vaicājumu un noklikšķiniet uz Saglabāt un palaist 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';

Relāciju datu bāzēs jūs strādājat ar tabulām, izmantojot INSERT priekšrakstus, lai pievienotu ierakstus, un SELECT priekšrakstu datu vaicāšanai. Programmā Amazon Kinesis Data Analytics jūs strādājat ar straumēm (STREAM) un sūkņiem (PUMP) — nepārtrauktiem ievietošanas pieprasījumiem, kas ievieto datus no vienas lietojumprogrammas straumes citā straumē.

Iepriekš parādītais SQL vaicājums meklē Aeroflot biļetes, kuru cena ir mazāka par pieciem tūkstošiem rubļu. Visi ieraksti, kas atbilst šiem nosacījumiem, tiks ievietoti straumē DESTINATION_SQL_STREAM.

Blokā Galamērķis atlasiet straumi special_stream un nolaižamajā sarakstā straumes nosaukums lietojumprogrammā DESTINATION_SQL_STREAM:

Visu manipulāciju rezultātam vajadzētu būt līdzīgam attēlā redzamajam:

SNS tēmas izveide un abonēšana

Dodieties uz Vienkāršo paziņojumu pakalpojumu un izveidojiet jaunu tēmu ar nosaukumu Aviokompānijas:

Abonējiet šo tēmu un norādiet mobilā tālruņa numuru, uz kuru tiks nosūtīti SMS paziņojumi:

Izveidojiet tabulu DynamoDB

Lai saglabātu neapstrādātos datus no straumes airline_tickets, izveidosim DynamoDB tabulu ar tādu pašu nosaukumu. Mēs izmantosim ieraksta_id kā primāro atslēgu:

Lambda funkciju savācēja izveide

Izveidosim lambda funkciju Collector, kuras uzdevums būs aptaujāt airline_tickets straumi un, ja tur tiks atrasti jauni ieraksti, ievietot šos ierakstus DynamoDB tabulā. Acīmredzot papildus noklusējuma tiesībām šai lambda ir jābūt lasīšanas piekļuvei Kinesis datu straumei un rakstīšanas piekļuvei DynamoDB.

IAM lomas izveide kolektora lambda funkcijai
Vispirms izveidosim jaunu IAM lomu lambda ar nosaukumu Lambda-TicketsProcessingRole:

Testa piemērā iepriekš konfigurētās AmazonKinesisReadOnlyAccess un AmazonDynamoDBFullAccess politikas ir diezgan piemērotas, kā parādīts attēlā zemāk:

Šī lambda ir jāpalaiž ar Kinesis aktivizētāju, kad airline_stream tiek ievadīti jauni ieraksti, tāpēc mums ir jāpievieno jauns aktivizētājs:

Atliek tikai ievietot kodu un saglabāt lambda.

"""Parsing the stream and inserting into the DynamoDB table."""
import base64
import json
import boto3
from decimal import Decimal

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

class TicketsParser:
    """Parsing info from the Stream."""

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

    @staticmethod
    def get_json_data(records):
        """Return deserialized data from the stream."""
        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-process the json data."""
        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 insert into the table."""
        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('Has been added ', len(self.json_data), 'items')

def lambda_handler(event, context):
    """Parse the stream and insert into the DynamoDB table."""
    print('Got event:', event)
    parser = TicketsParser(TABLE_NAME, event['Records'])
    parser.run()

Lambda funkcijas paziņotāja izveide

Līdzīgi tiek izveidota arī otrā lambda funkcija, kas uzraudzīs otro straumi (special_stream) un nosūtīs paziņojumu SNS. Tāpēc šai lambda ir jābūt pieejai, lai lasītu no Kinesis un nosūtītu ziņojumus uz doto SNS tēmu, ko pēc tam SNS pakalpojums nosūtīs visiem šīs tēmas abonentiem (e-pasts, SMS utt.).

IAM lomas izveide
Vispirms mēs izveidojam IAM lomu Lambda-KinesisAlarm šai lambda un pēc tam piešķiram šo lomu alarm_notifier lambda, kas tiek veidota:

Šai lambda ir jādarbojas ar trigeri, lai jauni ieraksti ievadītu special_stream, tāpēc jums ir jākonfigurē aktivizētājs tādā pašā veidā, kā mēs to darījām Collector lambda.

Lai atvieglotu šīs lambda konfigurēšanu, ieviesīsim jaunu vides mainīgo — TOPIC_ARN, kurā ievietojam Airlines tēmas ANR (Amazon Recourse Names):

Un ievietojiet lambda kodu, tas nemaz nav sarežģīti:

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='Hi! I have found an interesting stuff!',
                           Subject='Airline tickets alarm')
        print('Alarm message has been successfully delivered')
    except Exception as err:
        print('Delivery failure', str(err))

Šķiet, ka šeit ir pabeigta manuālā sistēmas konfigurēšana. Atliek tikai pārbaudīt un pārliecināties, ka esam visu pareizi konfigurējuši.

Izvietot no Terraform koda

Nepieciešamā sagatavošanās

Terraform ir ļoti ērts atvērtā pirmkoda rīks infrastruktūras izvietošanai no koda. Tam ir sava sintakse, ko ir viegli iemācīties, un tajā ir daudz piemēru, kā un ko izvietot. Atom redaktoram vai Visual Studio Code ir daudz parocīgu spraudņu, kas atvieglo darbu ar Terraform.

Jūs varat lejupielādēt izplatīšanu tātad. Detalizēta visu Terraform iespēju analīze ir ārpus šī raksta darbības jomas, tāpēc mēs aprobežosimies ar galvenajiem punktiem.

Kā palaist

Pilns projekta kods ir manā repozitorijā. Mēs klonējam krātuvi sev. Pirms darba sākšanas jums ir jāpārliecinās, vai AWS CLI ir instalēta un konfigurēta, jo... Terraform meklēs akreditācijas datus failā ~/.aws/credentials.

Laba prakse ir palaist plāna komandu pirms visas infrastruktūras izvietošanas, lai redzētu, ko Terraform pašlaik mums veido mākonī:

terraform.exe plan

Jums tiks piedāvāts ievadīt tālruņa numuru, uz kuru nosūtīt paziņojumus. Šajā posmā tas nav jāievada.

Izanalizējot programmas darbības plānu, varam sākt veidot resursus:

terraform.exe apply

Pēc šīs komandas nosūtīšanas jums atkal tiks lūgts ievadīt tālruņa numuru; sastādiet “jā”, kad tiek parādīts jautājums par darbību faktisko izpildi. Tas ļaus jums izveidot visu infrastruktūru, veikt visu nepieciešamo EC2 konfigurāciju, izvietot lambda funkcijas utt.

Kad visi resursi ir veiksmīgi izveidoti, izmantojot Terraform kodu, jums jāiedziļinās Kinesis Analytics lietojumprogrammas detaļās (diemžēl es neatradu, kā to izdarīt tieši no koda).

Palaidiet lietojumprogrammu:

Pēc tam jums ir skaidri jāiestata lietojumprogrammas straumes nosaukums, nolaižamajā sarakstā atlasot:

Tagad viss ir gatavs darbam.

Lietojumprogrammas testēšana

Neatkarīgi no tā, kā jūs izvietojāt sistēmu, manuāli vai izmantojot Terraform kodu, tā darbosies tāpat.

Mēs piesakāmies, izmantojot SSH, virtuālajā mašīnā EC2, kurā ir instalēts Kinesis Agent, un palaižam skriptu api_caller.py.

sudo ./api_caller.py TOKEN

Viss, kas jums jādara, ir jāgaida SMS uz jūsu numuru:

SMS — ziņa uz jūsu tālruni nonāk gandrīz 1 minūtes laikā:

Atliek noskaidrot, vai ieraksti tika saglabāti DynamoDB datu bāzē turpmākai, detalizētākai analīzei. Aviobiļetes tabulā ir aptuveni šādi dati:

Secinājums

Paveiktā darba gaitā tika uzbūvēta tiešsaistes datu apstrādes sistēma uz Amazon Kinesis bāzes. Tika apsvērtas iespējas izmantot Kinesis Agent kopā ar Kinesis datu straumēm un reāllaika analīzi Kinesis Analytics, izmantojot SQL komandas, kā arī Amazon Kinesis mijiedarbība ar citiem AWS pakalpojumiem.

Iepriekš minēto sistēmu mēs izvietojām divos veidos: diezgan garu manuālu un ātru no Terraform koda.

Ir pieejams viss projekta pirmkods manā GitHub repozitorijā, iesaku ar to iepazīties.

Es priecājos apspriest rakstu, es gaidu jūsu komentārus. Ceru uz konstruktīvu kritiku.

Es vēlu jums veiksmi!

Avots: www.habr.com