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!

Uvod
Za primjer će nam trebati pristup . 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

Koristeni sastavni dijelovi:
- — podaci koje vraća ovaj API bit će korišteni za cijeli daljnji rad;
- — obična virtualna mašina u oblaku koja će generirati ulazni tok podataka:
- — 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;
- — Python skripta koja šalje upite API-ju i sprema odgovor u mapu koju Kinesis Agent prati;
- — servis za streaming podataka u stvarnom vremenu s širokim mogućnostima skaliranja;
- — 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;
- — servis koji omogućava pokretanje koda bez rezerviranja i podešavanja servera. Sve računalne snage automatski se skaliraju za svaki poziv;
- — 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;
- — 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 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_APIGore 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 . 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:

Sada kreirajmo još jedan tok s imenom special_stream:

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:

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

U otvorenom prozoru odabiremo da novu ulogu kreiramo za EC2 i prelazimo na odjeljak Dozvole:

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:

Nakon kreiranja ove nove uloge, ne zaboravite prikačiti je na instancu virtualne mašine koju kreirate:

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.

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_ticketsPrije pokretanja agenta, potrebno je konfigurirati njegov config:
sudo vim /etc/aws-kinesis/agent.jsonSadrž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 restartSada ć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 
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 

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:

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:
- omogućuje stvaranje novih tokova (Output Stream) na temelju upita na izvorne podatke;
- pruža tok s pogreškama koje su se pojavile tijekom rada aplikacija (Error Stream);
- 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:

Biramo tok kojem se planiramo povezati (airline_tickets):

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:

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:

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:

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.

U bloku Destination odabiremo tok special_stream, a u padajućem meniju In-application stream name DESTINATION_SQL_STREAM:

Kao rezultat svih manipulacija, trebali bismo dobiti nešto slično slici ispod:

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

Prijavljujemo se na ovu temu, u njoj navodimo broj mobilnog telefona na koji će dolaziti SMS obavijesti:

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:

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:

Za testni primjer više nego dovoljno mogu poslužiti unaprijed podešene politike AmazonKinesisReadOnlyAccess i AmazonDynamoDBFullAccess, kao što je prikazano na slici ispod:


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č:


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:


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:

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
— 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 . 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 . 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 planBit će vam zatraženo da unesete broj telefona za primanje obavijesti. U ovoj fazi njegovo unošenje nije obavezno.

Analiziravši plan rada programa, možemo početi s izradom resursa:
terraform.exe applyNakon 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:

Nakon toga potrebno je izričito postaviti in-application stream name, birajući iz padajuće liste:


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 TOKENOstalo je čekati SMS na vaš broj:

SMS – poruka dolazi na telefon gotovo odmah, za otprilike 1 minutu:

Ostaje provjeriti jesu li zapisi pohranjeni u bazi podataka DynamoDB za daljnju, detaljniju analizu. Tablica airline_tickets sadrži otprilike ove podatke:

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 , 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
