CAP teorém a jeho vztah k NoSQL databázím
Základy distribuovaných systémů, 3 vlastnosti CAP, kategorie CA/CP/AP, BASE model, škálování, distribuce a replikace. Porovnání relačních a NoSQL databází.
📊 Big Data a distribuované systémy
5V model Big Data:
- Volume (Objem) – množství dat; petabyty a exabyty; každý den se generuje ~2,5 kvintilionu bajtů
- Velocity (Rychlost) – rychlost vzniku a zpracování; streaming v reálném čase; každých 60 sekund hodiny videa na YouTube
- Variety (Různorodost) – různé typy dat: strukturovaná (SQL tabulky), polostrukturovaná (JSON, XML), nestrukturovaná (~80 % světových dat: obrázky, videa, text)
- Veracity (Důvěryhodnost) – spolehlivost a přesnost dat; věrohodnost klesá s objemem
- Value (Hodnota) – schopnost extrahovat hodnotu z dat; klíčová pro business intelligence
Facebook, Google, Amazon narazily na problém škálovatelnosti: přidávání HW (vertical scaling) nestačilo. Vznikly NoSQL databáze jako řešení pro distribuované prostředí s horizontálním škálováním.
📐 CAP teorém – definice a principy
V praxi je Partition tolerance (P) vždy nutná – výpadky sítě se v distribuovaných systémech předpokládají jako normální stav ("co se může pokazit, pokazí se"). Proto volíme vždy mezi C a A.
| Vlastnost | Česky | Co znamená | Kdy selhává |
|---|---|---|---|
| C – Consistency | Konzistence | Každý požadavek vrátí aktuální data nebo chybu; všechny uzly vidí stejná data ve stejný čas | Pokud replika nestihla synchronizaci, vrátí staré datum |
| A – Availability | Dostupnost | Na každý požadavek přijde odpověď (i za cenu neaktuálních dat); systém je vždy dostupný | Pokud systém raději odmítne odpovědět, než by vrátil nekonzistentní data |
| P – Partition tolerance | Tolerance výpadku | Systém funguje i při výpadku komunikace mezi uzly (rozdělení sítě) | Pokud vyžadujeme 100 % spolehlivou síť |
Eric Brewer v roce 2012 upřesnil: hodnoty nejsou striktně binární – lze je nastavit na spektru. Cassandra např. dovoluje konfigurovat míru konzistence za běhu.
🗂️ Kategorie CAP: CA, CP, AP
- Striktní synchronizace celé DB
- Vyžaduje garantovanou komunikaci = nelze tolerovat výpadky sítě (P)
- Příklady: většina SQL/relačních databází (MySQL, PostgreSQL, Oracle)
- Použití: bankovní systémy, účetnictví – tam kde je konzistence kritická
- Při výpadku sítě systém odmítne odpovědět (raději nedostupný než nekonzistentní)
- Relaxujeme dostupnost (A)
- Příklady: HBase, MongoDB, Redis, Google BigTable
- Použití: metadata distribuovaného filesystému, internetové bankovnictví
Dostupnost je klíčová, přijímáme eventuální konzistenci – data mohou být dočasně neaktuální, ale systém vždy odpovídá. Relaxujeme konzistenci (C).
- Příklady: Apache Cassandra (výchozí), CouchDB, Dynamo, Voldemort
- Použití: CDN, cache servery, zpravodajské servery, Facebook (stránka může být 5 min stará), IoT
- Praktická volba: výchozí pro internetové služby
Systémy mohou různé části dat klasifikovat různě – čtení a zápis mohou mít jiné požadavky. Cassandra to umožňuje pomocí konfigurovatelných úrovní konzistence (ONE, QUORUM, ALL).
🧱 BASE model vs ACID
ACID (relační DB)
- Atomicity – transakce proběhne celá nebo vůbec
- Consistency – DB zůstane konzistentní před i po transakci
- Isolation – transakce jsou izolované od sebe
- Durability – potvrzená data jsou trvale uložena
BASE (NoSQL DB)
- Basically Available – systém je dostupný vždy, i při výpadcích (může vracet částečné výsledky)
- Soft state – stav dat může být dočasně nekonzistentní; asynchronní replikace
- Eventual consistency – data se nakonec dostanou do konzistentního stavu, ale ne okamžitě
V distribuovaných systémech s tisíci uzly a nespolehlivou sítí je striktní ACID konzistence extrémně drahá. BASE obětuje okamžitou konzistenci výměnou za výkon, škálovatelnost a dostupnost. Eventuální konzistence je dostatečná pro většinu webových aplikací.
📏 Škálování, distribuce a replikace
| Koncept | Horizontální (Scale Out) | Vertikální (Scale Up) |
|---|---|---|
| Princip | Přidání dalších uzlů (serverů) do clusteru | Upgrade stávajícího HW (více RAM, CPU) |
| Limit | Teoreticky neomezené; síťová latence | HW limity; vysoká cena |
| Technologie | NoSQL, cloud, distribuované systémy | Relační DB |
Strategie distribuce dat v NoSQL:
- Distribuce podle klíče – každý klíč mapován na konkrétní uzel; rychlé vyhledávání, ale nerovnoměrná zátěž
- Hashovací funkce – hash klíče určí uzel; rovnoměrné rozložení zátěže; lepší škálovatelnost
- Sharding – data rozdělena do fragmentů (shardů), každý na jiném uzlu; lineární horizontální škálování; ochrana proti výpadku jednoho serveru
Replikační modely:
- Master-Slave (asynchronní) – jeden master (zápis), N slave (čtení); vhodné pro read-heavy workload; při výpadku masteru slave přebírá roli
- Peer-to-Peer (synchronní) – všechny uzly rovnocenné; čtení i zápis na libovolný uzel; problém write-write konfliktů; řeší se "volební princip" (nadpoloviční shoda)
V P2P replikaci mohou dva uzly přijmout zápis stejných dat ve stejný čas → trvalé poškození dat. Cassandra to řeší algoritmem Last-Write-Wins (vyhrávají novější časová razítka).
🗃️ Typy NoSQL databází a porovnání s relačními
"Not Only SQL" – databáze bez pevného schématu, horizontálně škálovatelné, CAP/BASE místo ACID.
| Typ | Princip | Příklady | Vhodné pro |
|---|---|---|---|
| Klíč-Hodnota | Hashtable; rychlé GET/PUT | Redis, Riak, DynamoDB | Cache, session, profily uživatelů |
| Dokumentová | JSON/BSON dokumenty; flexibilní schéma | MongoDB, CouchDB | Katalogy, blog, e-commerce |
| Sloupcová (Column-family) | Data uložena po sloupcích; rodiny sloupců | Apache Cassandra, HBase | Big Data analýzy, IoT, časové řady |
| Grafová | Uzly a hrany; vztahy jako first-class citizens | Neo4j, JanusGraph | Sociální sítě, doporučovací systémy |
| Aspekt | Relační DB | NoSQL DB |
|---|---|---|
| Konzistence | ACID transakce | BASE / eventuální konzistence |
| Škálování | Vertikální | Horizontální (cluster) |
| Schéma | Pevné, dopředu definované | Flexibilní, schéma-free |
| Záloha | Pravidelné zálohy | Replikace dat |
| Objem dat | Předvídatelný lineární nárůst | Exponenciální, nepředvídatelný |
📋 Shrnutí okruhu 1
- CAP teorém: distribuovaný systém zvládne max. 2 ze 3 vlastností (C, A, P)
- P (Partition tolerance) je v praxi vždy nutná → reálně volíme mezi CP a AP
- BASE = alternativa k ACID; eventuální konzistence; klade dostupnost před konzistenci
- NoSQL = horizontální škálování, flexibilní schéma, distribuce dat přes cluster
- Distribuce: sharding (fragmenty), hashing (rovnoměrné rozdělení), replikace (záloha)
🎓 Kontrolní otázky a odpovědi:
MapReduce model: principy a využití pro dotazování Big Data
Programovací model MapReduce, fáze Map/Shuffle/Reduce, Hadoop ekosystém, HDFS, YARN, detailní flow výpočtu, praktické příklady WordCount.
🗺️ MapReduce – základní princip
Tradiční přístup přesouvá data na jeden server ke zpracování – v Big Data to je nefektivní (data jsou příliš velká). MapReduce místo toho posílá kód (výpočet) k datům, kde data fyzicky leží. Výsledky se poté agregují.
- Sharding bez MapReduce by neumožnil dotazovat všechny servery najednou
- Transparentní paralelizace – programátor píše jednoduchou logiku, framework se postará o distribuci
- Fault tolerance – pokud uzel selže, task se automaticky přerozdělí
⚙️ Fáze MapReduce: Map, Shuffle, Reduce
Celý výpočet probíhá ve třech logických fázích:
- Vstupní data jsou rozdělena na InputSplits – každý split přiřazen jednomu Mapperu
- RecordReader transformuje raw data na
<klíč, hodnota>páry pro Mapper - Mapper aplikuje uživatelskou funkci a produkuje mezioutputs ve formě
<klíč2, hodnota2> - Počet Mapperů = počet InputSplitů (nelze konfigurovat přímo, závisí na InputFormat)
- Operace: map (1→1), filter (1→0 nebo 1), flatmap (1→N)
- Partitioner rozhoduje, do kterého Reduceru data půjdou (výchozí: HashPartitioner dle klíče)
- Combiner (volitelný) = "mini-reducer" na každém Mapperu; redukuje přenášená data přes síť; vhodný pro komutativní funkce (sčítání, počítání)
- Shuffle = přesun dat z Map nodů na Reduce nody přes síť (HTTP/HTTPS) – kritické místo pro výkon sítě; data se zapisují na lokální disk
- Sort = data jsou seřazena podle klíče (komparátor) než vstoupí do Reduceru
- Reducer přijme všechna data pro svůj partition key seřazená
- Aplikuje agregační logiku → výsledky uloží na HDFS
- Výstupní soubory:
part-r-0001,part-r-0002, ... +_SUCCESS - Počet Reducerů je konfigurovatelný (parametr
job.setNumReduceTasks(N)) - Výstupy různých reducerů nejsou vzájemně seřazeny
Příklad WordCount – počítání výskytů slov:
- Map: Pro každé slovo emituj
(slovo, 1) - Shuffle: Všechna
(slovo, 1)se stejným slovem jdou ke stejnému Reduceru - Reduce: Sečti všechny jedničky pro každé slovo →
(slovo, počet)
🐘 Apache Hadoop – ekosystém a architektura
Základní komponenty Hadoop:
- HDFS – Hadoop Distributed File System; úložiště
- YARN – Yet Another Resource Negotiator; správa zdrojů a plánování jobů
- MapReduce – výpočetní engine
- Common – sdílené knihovny
Výhody Hadoop: distribuovaný, rychlý, levný (commodity HW), bezpečný (fault tolerance), schopen zpracovat data jakéhokoliv typu (strukturovaná i nestrukturovaná).
- Master-Slave architektura: NameNode (master) + DataNodes (slaves)
- NameNode – uchovává metadata (seznam souborů, bloků, repliky) v paměti (in-memory); single point of failure! Řeší se HA nastavením (Secondary NameNode, StandBy NameNode)
- DataNode – uchovává datové bloky; posílá heartbeat NameNodu; provádí instrukce (vytvoř, smaž, replikuj blok)
- Blok – základní jednotka HDFS; typicky 128 MB nebo 256 MB; každý soubor je rozdělen do bloků; bloky jsou replikovány (výchozí replikační faktor = 3)
- Optimalizace: write-once/read-many; výborné pro batch zpracování (vysoká propustnost), nevhodné pro real-time (vysoká latence)
📖 Klíčová terminologie MapReduce
| Termín | Popis |
|---|---|
| NODE | Fyzický stroj nebo virtuální kontejner s JVM |
| JOB | MapReduce program + konfigurace + vstupní data; největší jednotka výpočtu |
| ApplicationMaster | Master – řídí celý výpočet jobu; koordinuje Tasky |
| SPLIT | Logická část vstupních dat; reference na data (ne fyzická kopie) |
| TASK | Výpočet Map nebo Reduce funkce nad jedním Splitem |
| TASK ATTEMPT | Pokus provést Task na konkrétním Nodu; při selhání se opakuje |
| InputFormat | Definuje strategii čtení a rozdělení dat; typy: TextInputFormat, SequenceFileInputFormat |
| InputSplit | Reference na část dat; počet splitů = počet Mapperů |
| RecordReader | Připravuje [klíč, hodnota] páry pro Mapper ze Splitu |
| Mapper | Interface Mapper<K1,V1,K2,V2>; transformuje vstup na mezivýstup |
| Combiner | Stejný interface jako Reducer; pre-agregace dat před Shuffle; snižuje síťový přenos |
| Partitioner | Rozhoduje do kterého Reduceru jdou která data; výchozí: HashPartitioner |
| SHUFFLE | Přesun dat přes síť z Mapperů k Reducerům; kritické pro výkon |
| SORT | Seřazení dat dle klíče před vstupem do Reduceru; probíhá souběžně se Shuffle |
| Reducer | Interface Reducer<K2,V2,K3,V3>; agreguje výstup; výsledek na HDFS |
| OutputFormat | Definuje formát výstupních dat; typy: TextOutputFormat, SequenceFileOutputFormat |
⚖️ Omezení MapReduce a proč vznikl Spark
- Pouze batch processing – nelze použít pro streaming, interaktivní dotazy nebo ML
- Vysoká latence – mezi každou fází Map→Shuffle→Reduce se zapisuje na disk; pro iterativní algoritmy (ML) je to velmi pomalé
- Verbózní kód – jednoduché operace vyžadují mnoho kódu (Java API)
- Složité ladění a monitorování – dependency hell, Kerberos security, komplexní konfigurace
Proto vznikl Apache Spark, který zpracovává data in-memory a podporuje batch, streaming i ML v jednom frameworku.
📋 Shrnutí okruhu 2
- MapReduce = programovací model pro distribuované zpracování; 3 fáze: Map, Shuffle+Sort, Reduce
- Klíčový princip: výpočet k datům, ne data k výpočtu (minimalizace síťového přenosu)
- Combiner = mini-reducer; snižuje data přenesená přes síť (vhodný pro komutativní funkce)
- HDFS: NameNode (metadata, in-memory) + DataNodes (data, bloky); replikační faktor 3
- Hadoop ekosystém: HDFS (storage) + YARN (resources) + MapReduce (compute)
🎓 Kontrolní otázky a odpovědi:
Apache Cassandra – architektura, databázový model, distribuce dat
Masterless ring architektura, konzistentní hashování, Gossip protokol, struktura dat (Keyspace, Column Family, Row, Column), čtení a zápis, replikace, CQL jazyk.
🏛️ Apache Cassandra – úvod a charakteristika
Klíčové vlastnosti:
- Master-less architektura – žádný "master" node; všechny uzly jsou si rovny; odolnost vůči SPOF (Single Point of Failure)
- Lineární škálovatelnost – přidáním každého nového nodu roste výkon lineárně
- Extrémní odolnost – Restart Free, Fail Free, Maintenance Free; zvládá 100 000+ nodů (Apple)
- AP systém (výchozí) – dostupnost + tolerance výpadku; konfigurovatelné na CP
- In-Memory – memtable struktura; po naplnění zápis na disk
- CQL – vlastní dotazovací jazyk podobný SQL (bez JOINů)
- Java platforma – multiplatformní díky JVM; OS Free
- Dělení dat pomocí konzistentního hashování (Hash Rings)
- Replikace s verzovanými daty (Last-Write-Wins)
- Distribuce clusteru a detekce chyb pomocí Gossip protokolu
- Škálovatelnost na commodity hardware
🗄️ Databázový model Cassandry
| Cassandra | Relační DB | Popis |
|---|---|---|
| Keyspace | Databáze | Nejvyšší kontejner; definuje replikační strategii, faktor, konzistenci; unikátní název v clusteru |
| Column Family | Tabulka | Definuje strukturu dat; každý řádek může mít různý počet sloupců |
| Row | Řádek | Kolekce sloupců identifikovaná Partition Key a Clustering Key |
| Column | Sloupec | Trojice: název + hodnota + timestamp; vždy definovaný datový typ |
| Super Column | N/A | "Tabulka v tabulce"; sloupec obsahující další sloupce; analogie 3. normální formy v SQL |
| Row Key | Primární klíč | Partition Key (určuje uzel) + Clustering Key (řazení uvnitř oddílu) |
- Partition Key – hashuje se pro určení uzlu; všechny řádky se stejným PK jsou fyzicky na stejném uzlu
- Clustering Key – určuje fyzické pořadí dat v rámci oddílu; umožňuje efektivní range queries
- Složený PK:
PRIMARY KEY ((partition_key), clustering_key1, clustering_key2) - Dotazy musí vždy specifikovat Partition Key – bez něj nebude dotaz efektivní (full table scan)
Keyspace – replikační strategie:
- SimpleStrategy – jen pro testování; neumožňuje různý replikační faktor pro různá DC
- NetworkTopologyStrategy – produkce; různý replikační faktor pro každé datacenter; zaručuje repliky na různých rackách v DC
💍 Masterless Ring architektura
Konzistentní hashování:
- Klíč záznamu se zahashuje → hash = token → určí uzel
- Na rozdíl od prostého hashování: přidání/odebrání uzlu přesune jen část dat (ne vše)
- Virtuální uzly (vnodes) – každý fyzický uzel může hostit více virtuálních uzlů; lepší vyrovnání zátěže při přidání/odebrání nodu
- Tabulka tokenů mapuje virtuální → fyzické uzly
- Žádný SPOF – výpadek libovolného nodu neohrozí systém
- Bezešvé rozšiřování – nový node přidán bez výpadku, replikace proběhne sama
- Data mohou být replikována do více datacenter
- Last-Write-Wins – konflikty mezi replikami řeší timestamp; novější hodnota vyhrává
💬 Gossip protokol a detekce chyb
Jak Gossip funguje (1x za sekundu):
- Uzel inkrementuje číslo svojí verze a vytvoří zprávu o svém stavu
- Náhodně vybere jiný uzel a vymění si informace
- Pokusí se komunikovat s nedostupnými uzly (pokud o nich ví)
- Komunikuje se Seed nodem (pokud tak neučinil)
Informace sdílené přes Gossip: konfigurace clusteru, stav uzlů, umístění dat, verze informací (zastaralé se ignorují).
Seed uzly jsou vstupní brány do clusteru pro nové uzly. Nový uzel kontaktuje Seed → dostane topologii clusteru → připojí se. Seed by měl být v clusteru vícekrát pro redundanci.
Gossip sám o sobě chyby nezjišťuje – to dělá Phi Accrual Failure Detector. Každý uzel sleduje heartbeaty ostatních uzlů a nezávisle rozhoduje, kdo je nedostupný. Nedostupné uzly nejsou automaticky odstraněny z clusteru – data se pro ně uchovávají jako hints a při obnovení komunikace jsou doručena.
✍️ Proces zápisu a čtení dat
Zápis dat:
- Data zapsána do Commit Logu (WAL – Write-Ahead Log; obnova po havárii)
- Data zapsána do Memtable (write-back cache v RAM)
- Po naplnění limitu se Memtable propíše na disk jako SSTable (Sorted String Table)
- SSTable je immutable soubor; nikdy se nemění, jen přidává nová verze
Čtení dat:
- Bloom Filter – probabilistická struktura; rychle zjistí, zda klíč pravděpodobně v SSTable je (může mít false positive, ale ne false negative)
- Key Cache – cache nejčastěji čtených klíčů s ukazatelem do SSTable
- Partition Index – index všech klíčů; pro klíče nenalezené v cache
- SSTable – fyzické čtení z disku
- Memtable – slučuje data z SSTable s novějšími daty v Memtable
Cassandra umožňuje nastavit úroveň konzistence pro každou operaci zvlášť. Čím vyšší konzistence, tím nižší dostupnost.
| Úroveň | Co znamená | Kdy použít |
|---|---|---|
| ONE | Stačí odpověď od 1 repliky | Nejrychlejší, nejnižší konzistence |
| TWO / THREE | Odpověď od 2/3 replik | Střední konzistence |
| QUORUM | Nadpoloviční většina (n/2 + 1) | Dobrý kompromis |
| LOCAL_QUORUM | Quorum v lokálním DC | Multi-DC nasazení |
| ALL | Všechny repliky musí odpovědět | Maximální konzistence, nízká dostupnost |
| ANY (jen zápis) | Uloženo jako hint, ještě není čitelné | Maximální dostupnost zápisu |
Pokud úroveň zápisu + úroveň čtení > replikační faktor, je zaručena silná konzistence (čteme vždy nejnovější data). Např. RF=3: QUORUM čtení + QUORUM zápis = 2+2=4 > 3 → silná konzistence.
💻 CQL – Cassandra Query Language
Co CQL nepodporuje: JOINy, poddotazy, cizí klíče, relace (je to NoSQL!).
Co CQL podporuje navíc:
- Datové typy pro kolekce:
list,map,set,frozen - Speciální typy:
timeuuid(časové UUID v1),uuid(náhodné UUID v4),counter,inet(IP adresa) - Uživatelsky definované typy (UDT):
CREATE TYPE - Uživatelsky definované funkce a agregace
- Batch operace:
BEGIN BATCH ... APPLY BATCH(atomické) - TTL (Time To Live):
INSERT ... USING TTL 60– automatické mazání - Materialized Views (experimentální)
Základní DDL/DML příkazy:
CREATE KEYSPACE– vytvoření keyspace s replikační strategiíCREATE TABLE– s definicí primárního klíčeINSERT INTO ... IF NOT EXISTSSELECT– musí obsahovat Partition Key; bez něj ALLOW FILTERING (pomalé!)UPDATE,DELETE,TRUNCATE,DROPCREATE INDEX– sekundární indexy
📋 Shrnutí okruhu 3
- Cassandra = AP distribuovaná sloupcová DB bez masteru; masterless ring architektura
- Konzistentní hashování + Hash Ring – data distribuována pomocí hash tokenu klíče
- Gossip protokol – peer-to-peer synchronizace stavu clusteru každou sekundu
- Zápis: Commit Log → Memtable → SSTable (immutable); čtení: Bloom Filter → Key Cache → Partition Index → SSTable + Memtable merge
- Tunable Consistency: ONE, QUORUM, ALL – kompromis mezi konzistencí a dostupností
🎓 Kontrolní otázky a odpovědi:
Apache Spark & Elastic Stack – distribuované výpočty a indexace
Spark: Driver/Executor architektura, RDD, DataFrame, DAG, transformace a akce, lazy evaluation. Elastic Stack: Elasticsearch indexace, Logstash pipeline, Kibana vizualizace, Beats.
⚡ Apache Spark – úvod a motivace
Proč Spark a ne jen MapReduce?
| Kritérium | MapReduce (Hadoop) | Apache Spark |
|---|---|---|
| Rychlost | Disk I/O mezi každou fází (pomalé) | In-memory výpočty (10–100× rychlejší) |
| Iterativní algoritmy | Nevhodné – každá iterace = nový job → disk | Výborné – data v paměti přes iterace |
| Typy zpracování | Pouze batch | Batch, streaming, ML, grafy, SQL |
| API | Verbose Java API | Stručné API (Scala, Python, SQL) |
| Interaktivní shell | Ne | Ano (REPL) |
Spark byl vyvinut na UC Berkeley (2009), od 2013 jako Apache projekt. Používá ho: Oracle, Cisco, Visa, Microsoft, Databricks, Amazon, Yahoo, Seznam a tisíce dalších firem.
🏗️ Spark architektura a klíčové principy
Klíčové principy Sparku:
- Driver – hlavní program; koordinuje výpočet; posílá tasky Executorům; hostuje SparkContext
- Executor – JVM proces na worker nodu; provádí tasky; drží data v paměti (cache)
- In-memory výpočty – data zůstávají v RAM Executorů; eliminuje disk I/O mezi fázemi
- DAG (Directed Acyclic Graph) – Spark builduje DAG transformací před spuštěním; optimalizuje plán výpočtu
- Lazy Evaluation – transformace se nevykonají ihned; trigger je až Akce (collect, count, save). Umožňuje optimalizaci celého plánu.
- Immutable data – RDD/DataFrame nelze modifikovat; transformací vznikají nové
- Fault tolerant – při výpadku uzlu se ztracená partition dopočítá znovu z lineage (DAG záznamu)
SparkContext je instance Spark aplikace – bez něj nelze výpočet spustit. Aplikace se submituje pomocí: spark-submit --class path.To.Class --master yarn [jar] [options]. Celý JAR je distribuován na každý node.
Hierarchy výpočetních jednotek:
- Job – celý výpočet od akce; největší jednotka
- Stage – logická část výpočtu oddělená Shuffle boundary (join, reduceByKey, groupBy); uvnitř Stage nejdou data přes síť
- Task – výpočet jedné Stage nad jednou partition; na jednom Executoru v jednom vlákně
📦 RDD, DataFrame a Dataset API
- Dataset – kolekce objektů jakéhokoliv typu
- Distributed – rozdělena na partitions; každá partition zpracována jiným Task/Executor
- Immutable – nelze měnit; transformace vytváří nové RDD
- Resilient – při výpadku uzlu se ztracená partition dopočítá z lineage (záznamu transformací)
- In-memory – RDD se drží v RAM Executoru; rychlé, ale náročné na paměť
- Nejnižší úroveň API; maximální flexibilita; typicky pro unstrukturovaná data
- Dataset – novější API (od v1.6); RDD + optimalizovaný execution engine + schéma; API pro Scala, Java
- DataFrame – Dataset<Row>; organizovaný do pojmenovaných sloupců; konceptuálně tabulka; SQL-like operace
- Lze dotazovat pomocí SQL:
spark.sql("SELECT name FROM people WHERE age > 18") - Přístup i přes JDBC/ODBC
- Catalyst optimizer automaticky optimalizuje plán dotazu
🔄 Transformace a Akce (Lazy Evaluation)
Transformace (lazy – nevykonají se okamžitě):
Narrow – data z jedné partition:
map,flatMap,filtermapPartitions,sample,union- Lze "slepit" bez přesunu dat přes síť
Wide – data z více partition (způsobí Shuffle):
reduceByKey,groupByKeyjoin,repartition,coalesce- Vyžadují přesun dat přes síť → Stage boundary
Akce (eager – spouštějí výpočet):
collect()– vrátí všechna data do driverutake(n)– prvních n prvkůcount()– počet prvkůtop(n)– top n prvkůfold(),aggregate()foreach()– iterace přes prvkysaveAsTextFile()– uložení na disk
Spark neexekutuje transformace ihned. Místo toho builduje DAG (plán výpočtu). Až když nastane Akce, Spark zoptimalizuje celý plán (sloučí transformace, eliminuje zbytečné operace) a teprve pak spustí výpočet. To umožňuje Catalyst optimizér dosáhnout výkonu srovnatelného s ručně optimalizovaným kódem.
Shuffle boundary = Stage boundary – operace jako join, reduceByKey, groupByKey, repartition způsobí Shuffle (přesun dat přes síť). Každý Shuffle odděluje dvě Stage.
🔍 The Elastic Stack – přehled a komponenty
| Komponenta | Role | Popis |
|---|---|---|
| Elasticsearch | Úložiště + vyhledávač | Distribuovaný search engine; indexuje a ukládá data; RESTful API (JSON) |
| Logstash | Zpracování dat | Sběr, transformace a posílání dat do ES; pipeline: Input → Filter → Output |
| Kibana | Vizualizace | Webové UI pro Elasticsearch; dashboardy, grafy, mapy, ML detekce anomálií |
| Beats | Sběr dat | Odlehčené agenty pro sběr dat z různých zdrojů; posílají do ES nebo Logstash |
🔬 Elasticsearch – architektura a indexace
Datová struktura (analogie s relační DB):
- Index ≈ tabulka; předepisuje datový typ, schéma (mapping), nastavení shardů
- Dokument ≈ řádek; jednotka dat uložená v indexu
- Field ≈ sloupec; pole v dokumentu s definovaným typem a analyzérem
Cluster, Node, Shard:
- Cluster – skupina spolupracujících nodů; jednoduše škálovatelný (přidání nodu)
- Node typy: Datový (ukládá data), Master (správa clusteru), Clientský (proxy), Ingest (pre-processing)
- Shard – jedna instance Lucene indexu; Primární shard + Replika shard
- Elasticsearch distribuuje shardy automaticky; doporučeno min. 3 nody (64 GB RAM každý, SSD)
Každý dokument před uložením prochází analyzérem (pipeline):
- Char filters – úprava textu (např. odstranění HTML tagů)
- Tokenizer – rozdělení textu na tokeny (slova, interpunkce)
- Token filters – lowercase, odstranění stop slov (předložky), stemming
Výsledné tokeny jsou uloženy do invertovaného indexu (obrácený index: slovo → dokumenty kde se vyskytuje). ES podporuje ~40 jazyků, včetně českého analyzéru (rozumí skloňování!).
Nové dokumenty nejsou viditelné okamžitě, ale po procesu refresh (výchozí: každou sekundu pro aktivní indexy). Refresh = nový Lucene segment zapíše do file system cache → viditelný pro vyhledávání bez drahého fsync na disk. Proto "near" real-time.
🪵 Logstash – pipeline pro zpracování dat
Architektura pipeline: Input → Filter → Output
- Event Object – základní datová jednotka; zapouzdřuje tok dat pipeline
- Input plugins – zdroje dat:
file,stdin,beats,http,elasticsearch,twitter,kafka,azure_event_hub - Filter plugins – transformace:
grok(regex parsing),mutate(přejmenování, konverze),json/csv/xml(parsování),geoip(GPS z IP adresy),date(parsování časových razítek),ruby(vlastní kód) - Output plugins – cíle:
elasticsearch,file,stdout,email,http,mongodb,tcp
Výchozí nastavení: in-memory fronta (při výpadku Logstash ztrácíme data). Perzistentní fronta ukládá čekající zprávy na disk – ochrana před ztrátou dat při výpadku. Nevýhoda: bez replikace (ochrana proti disk failure).
Více pipeline: Logstash umožňuje spustit více pipeline v jednom procesu (konfigurace v pipelines.yml). Různé pipeline mohou mít různé nastavení výkonu a trvanlivosti.
💓 Beats a Kibana
Beats – odlehčené jednoúčelové agenty pro sběr dat; alternativa k těžkému Logstashi přímo na zdrojovém serveru:
- Filebeat – čtení logů ze souborů; posílá do ES nebo Logstash
- Metricbeat – metriky systému (CPU, RAM, disk)
- Heartbeat – monitoring dostupnosti URL endpointů
- Auditbeat – auditové logy z Linux auditd
- Packetbeat – monitoring síťového provozu
- Winlogbeat – Windows Event Logy
- Journalbeat – systemd journal (Linux)
- Lze napsat vlastní Beat pomocí libbeat knihoven
Kibana – webový analytický a vizualizační nástroj pro Elasticsearch:
- Data View (dříve Index Pattern) – definuje zdroje dat (indexy, datastreamy)
- Discover – interaktivní průzkum dat s KQL filtry
- Visualize Library – tvorba grafů (Lens, heatmapy, koláčové grafy, histogramy, Aggregation based)
- Dashboard – kompozice vizualizací; interaktivní přehled dat
- Canvas – prezentace; flexibilnější než Dashboard; export do PDF
- Maps – geospatial vizualizace; GeoJSON, animované mapy
- Machine Learning – detekce anomálií (Phi Accrual)
Dotazovací jazyk pro filtrování dat z ES v Kibaně. Podporuje: textové vyhledávání, filtrování podle polí, boolean operátory (AND/OR/NOT), rozsahové podmínky (>, <=), zástupné znaky (*), vnořená pole. Nepodporuje: regulární výrazy, fuzzy vyhledávání.
📋 Shrnutí okruhu 4
- Spark = in-memory distribuovaný výpočetní framework; batch + streaming + ML + SQL v jednom
- Lazy Evaluation + DAG = Spark builduje optimalizovaný plán; vykoná ho až při Akci
- RDD (nízkoúrovňové, flexibilní) → DataFrame/Dataset (SQL-like, optimalizované Catalyst optimizérem)
- Wide vs Narrow transformace: Wide (join, groupBy) způsobuje Shuffle = Stage boundary
- Elastic Stack: Beats → (Logstash) → Elasticsearch → Kibana; distribuovaný search engine s inverzním indexem a NRT vyhledáváním
🎓 Kontrolní otázky a odpovědi: