Vážení čitatelia, prajeme vám dobrý deň!
V tomto článku vedúci konzultant obchodného zamerania Big Data Solutions spoločnosti "Neoflex" podrobne opisuje možnosti vytvárania vitrín s variabilnou štruktúrou pomocou Apache Spark.
V rámci projektu analýzy dát sa často objavuje úloha vytvárania vitrín na základe slabo štruktúrovaných dát.
Obvykle ide o logy alebo odpovede rôznych systémov uchovávané vo forme JSON alebo XML. Dáta sa exportujú do Hadoopu, odkiaľ je potrebné tieto dáta spracovať do vitríny. Prístup k vytvorenej vitríne môžeme zabezpečiť napríklad prostredníctvom Impala.
V tomto prípade schéma cieľovej vitríny nie je predbežne známa. Navyše, schému nie je možné zostaviť vopred, pretože závisí od dát, s ktorými máme do činenia, a ide o tieto slabo štruktúrované dáta.
Napríklad, dnes sa loguje takáto odpoveď:
{source: "app1", error_code: ""}a zajtra od toho istého systému príde takáto odpoveď:
{source: "app1", error_code: "error", description: "Network error"}V dôsledku toho by do vitríny malo pribudnúť ďalšie pole — description, a nikto nevie, či príde alebo nie.
Úloha vytvorenia vitríny na takýchto dátach je celkom štandardná, a pre Spark sú k dispozícii viaceré nástroje. Na parsovanie vstupných dát sú podporované ako JSON, tak aj XML, a pre vopred neznámu schému je zahrnutá podpora schemaEvolution.
Na prvý pohľad sa riešenie zdá jednoduché. Stačí vziať zložku s JSON a načítať do dataframe. Spark vytvorí schému a vnorené dáta sa premenia na štruktúry. Následne je potrebné všetko uložiť do parquet, ktorý je podporovaný aj v Impala, registrujúc vitrínu v Hive metastore.
Zdá sa, že je to všetko jednoduché.
Avšak z krátkych príkladov v dokumentácii nie je jasné, čo robiť v praxi s niekoľkými problémami.
V dokumentácii je opísaný prístup nie na vytvorenie vitríny, ale na čítanie JSON alebo XML do dataframe.
A konkrétne, jednoducho sa uvádza, ako prečítať a rozparsovať JSON:
df = spark.read.json(path...)To stačí na sprístupnenie dát pre Spark.
V praxi je scénar oveľa zložitejší, než len prečítať JSON súbory zo zložky a vytvoriť dataframe. Situácia vyzerá takto: už existuje určitá vitrína, každý deň prichádzajú nové dáta, ktoré je potrebné pridať do vitríny, pričom je potrebné mať na pamäti, že schéma sa môže líšiť.
Bežná schéma vytvárania vitríny je takáto:
Krok 1. Údaje sa načítavajú do Hadoopu s následným denným doplňovaním a ukladajú sa do novej partition. Vzniká priečinok s partionovanými dátami podľa dní.
Krok 2. Počas inicializačného načítania sa tento priečinok číta a parsuje pomocou Spark. Získaný dataframe sa ukladá do formátu, ktorý je dostupný na analýzu, napríklad do parquet, ktorý sa potom môže importovať do Impala. Takto sa vytvára cieľová vitrína so všetkými dátami, ktoré sa k tomuto momentu nahromadili.
Krok 3. Vytvára sa načítanie, ktoré každý deň aktualizuje vitrínu.
Vynára sa otázka inkrementálneho načítania, potreba partitionovania vitríny a otázka podpory celkovej schémy vitríny.
Uveďme príklad. Predpokladajme, že bol realizovaný prvý krok budovania úložiska a nastavené vykladanie JSON súborov do priečinka.
Vytvoriť z nich dataframe, aby sme ho potom mohli uložiť ako vitrínu, nie je problém. To je ten prvý krok, ktorý sa ľahko nájde v dokumentácii Spark:
df = spark.read.option("mergeSchema", True).json(".../*")
df.printSchema()
root
|-- a: long (nullable = true)
|-- b: string (nullable = true)
|-- c: struct (nullable = true) |
|-- d: long (nullable = true)Zdá sa, že všetko je v poriadku.
Prečítali sme a rozparsovali JSON, následne ukladáme dataframe ako parquet, registrovaním v Hive akýmkoľvek vhodným spôsobom:
df.write.format(“parquet”).option('path','').saveAsTable('') Získavame vitrínu.
Ale, na druhý deň pribudli nové údaje zo zdroja. Máme priečinok s JSON a vitrínu, vytvorenú na základe tohto priečinka. Po načítaní ďalšej dávky údajov zo zdroja vo vitríne chýbajú údaje za jeden deň.
Logickým riešením bude partitionovať vitrínu podľa dní, čo umožní každý ďalší deň pridávať novú partition. Mechanizmus tohto je tiež dobre známy, Spark umožňuje zapisovať partitiony oddelene.
Najprv vykonáme inicializačné načítanie, pričom uchovávame údaje, ako bolo popísané vyššie, pridaním len partitionovania. Tento krok sa nazýva inicializácia vitríny a robí sa len raz:
df.write.partitionBy("date_load").mode("overwrite").parquet(dbpath + "/" + db + "/" + destTable)
Na ďalší deň načítavame iba novú partition:
df.coalesce(1).write.mode("overwrite").parquet(dbpath + "/" + db + "/" + destTable +"/date_load=" + date_load + "/")
Ostáva len znovu registrovať v Hive, aby sme aktualizovali schému.
Avšak, tu nastávajú problémy.
Prvý problém. Skôr či neskôr nebude možné prečítať výsledný parquet. Je to spôsobené odlišným prístupom parquet a JSON k prázdnym poliam.
Pozrime sa na typickú situáciu. Napríklad, včera prišiel JSON:
Deň 1: {"a": {"b": 1}},
a dnes vyzerá ten istý JSON takto:
Deň 2: {"a": null}
Povedzme, že máme dve rôzne partície, v ktorých je po jednom riadku.
Keď čítame pôvodné údaje ako celok, Spark dokáže určiť typ a pochopí, že „a“ je pole typu „štruktúra“ s vnoreným poľom „b“ typu INT. Ale ak bola každá partícia uložená samostatne, vznikne parquet s nekompatibilnými schémami partícií:
df1 (a: <struct>)
df2 (a: STRING NULLABLE)
Táto situácia je dobre známa, preto bola špeciálne pridaná možnosť — pri parsovaní pôvodných údajov odstrániť prázdne polia:
df = spark.read.json("...", dropFieldIfAllNull=True)
V tomto prípade bude parquet pozostávať z partícií, ktoré bude možné prečítať spoločne.
Aj keď sa tí, ktorí to robili v praxi, tu trpko usmejú. Prečo? Pretože pravdepodobne vzniknú ďalšie dve situácie. Alebo tri. Alebo štyri. Prvá, ktorá sa takmer určite objaví, je, že číselné typy budú vyzerať rôzne v rôznych JSON súboroch. Napríklad, {intField: 1} a {intField: 1.1}. Ak takéto polia skončia v jednej partícii, mergenie schémy všetko prečíta správne, privádzajúc k najpresnejšiemu typu. Ale ak budú v rôznych, v jednej bude intField: int, zatiaľ čo v druhej intField: double.
Na spracovanie tejto situácie existuje nasledujúca vlajka:
df = spark.read.json("...", dropFieldIfAllNull=True, primitivesAsString=True)
Teraz máme zložku, kde sú uložené partície, ktoré môžeme prečítať do jedného dataframe a platného parquet celej vitríny. Áno? Nie.
Treba si pripomenúť, že sme zaregistrovali tabuľku v Hive. Hive nie je citlivý na veľkosť písmen v názvoch polí, zatiaľ čo parquet je citlivý. Preto partície so schémami: field1: int a Field1: int sú pre Hive rovnaké, ale pre Spark nie. Treba nezabudnúť zmeniť názvy polí na malé písmená.
Po tomto, sa zdá, že všetko je v poriadku.
Avšak, nie všetko je také jednoduché. Vzniká druhý, takisto dobre známy problém. Keďže každá nová partícia sa ukladá samostatne, v zložke partície budú ležať systémové súbory Spark, napríklad flag úspešnosti operácie _SUCCESS. To povedie k chybe pri pokuse o parquet. Aby sa tomu zabránilo, treba nastaviť konfiguráciu, ktorá zakáže Sparku zapisovať systémové súbory do zložky:
hadoopConf = sc._jsc.hadoopConfiguration()
hadoopConf.set("parquet.enable.summary-metadata", "false")
hadoopConf.set("mapreduce.fileoutputcommitter.marksuccessfuljobs", "false")
Zdá sa, že každý deň sa do zložky cieľového vitríny pridáva nová parquet partícia, kde sú uložené parsované údaje za deň. Vopred sme sa postarali o to, aby sa nevytvárali partície s konfliktom typov údajov.
Ale pred nami sa objaví tretí problém. Teraz nie je známa celková schéma, navyše v tabuľke Hive je nesprávna schéma, pretože každá nová partícia pravdepodobne pridala skreslenie do schémy.
Musíme zaregistrovať tabuľku znova. To môžeme spraviť jednoducho: znovu načítať parquet vitríny, získať schému a na jej základe vytvoriť DDL, s ktorou znova zaregistrujeme zložku v Hive ako externú tabuľku a aktualizujeme schému cieľového vitríny.
Pred nami sa objaví štvrtý problém. Keď sme registráciu tabuľky robili prvýkrát, opierali sme sa o Spark. Teraz to robíme sami a musíme si pamätať, že polia parquet môžu začínať so znakmi, ktoré nie sú platné pre Hive. Napríklad, Spark vyhadzuje riadky, ktoré sa nepodarilo parsovať do poľa „corrupt_record“. Takéto pole nebude možné zaregistrovať v Hive bez toho, aby sme ho escapovali.
Vedúc toto, získavame schému:
f_def = ""
for f in pf.dtypes:
if f[0] != "date_load":
f_def = f_def + "," + f[0].replace("_corrupt_record", "`_corrupt_record`") + " " + f[1].replace(":", "`:").replace("<", "<`").replace(",", ",`").replace("array<`", "array<")
table_define = "CREATE EXTERNAL TABLE jsonevolvtable (" + f_def[1:] + " ) "
table_define = table_define + "PARTITIONED BY (date_load string) STORED AS PARQUET LOCATION '\/user\/admin\/testJson\/testSchemaEvolution\/pq\/'"
hc.sql("drop table if exists jsonevolvtable")
hc.sql(table_define)
Kód ("_corrupt_record", "`_corrupt_record`") + " " + f[1].replace(":", "`:").replace("<", "<`").replace(",", ",`").replace("array<`", "array<") vytvára bezpečné DDL, teda namiesto:
create table tname (_field1 string, 1field string)
S takými názvami polí ako „_field1, 1field“ sa vytvára bezpečné DDL, kde sú názvy polí escapované: create table `tname` (`_field1` string, `1field` string).
Vzniká otázka: ako správne získať dataframe s celou schémou (v kóde pf)? Ako získať tento pf? To je piaty problém. Čítať schému všetkých partícií zo zložky s parquet súbormi cieľového vitríny? Tento spôsob je najbezpečnejší, ale náročný.
Schéma už existuje v Hive. Novú schému je možné získať kombinovaním schémy celej tabuľky a novej partition. To znamená, že musíme brať schému tabuľky z Hive a zlúčiť ju so schémou novej partition. To sa dá realizovať prečítaním testovacích metadát z Hive, uložením ich do dočasného priečinka a súčasným prečítaním oboch partition pomocou Sparku.
V podstate máme všetko, čo potrebujeme: pôvodnú schému tabuľky v Hive a novú partition. Datasets máme tiež. Ostáva len získať novú schému, v ktorej sa zlúči schéma výstupu a nové polia zo vytvorenej partition:
from pyspark.sql import HiveContext
from pyspark.sql.functions import lit
hc = HiveContext(spark)
df = spark.read.json("...", dropFieldIfAllNull=True)
df.write.mode("overwrite").parquet(".../date_load=12-12-2019")
pe = hc.sql("select * from jsonevolvtable limit 1")
pe.write.mode("overwrite").parquet(".../fakePartiton/")
pf = spark.read.option("mergeSchema", True).parquet(".../date_load=12-12-2019/*", ".../fakePartiton/*")
Ďalej vytvárame DDL registráciu tabuľky, ako v predchádzajúcom úryvku.
Ak celá reťazec funguje správne, a to — prebehla inicializačná nahrávka a správne bola vytvorená tabuľka v Hive, získavame aktualizovanú schému tabuľky.
A posledný problém spočíva v tom, že nie je také jednoduché pridať partition do tabuľky Hive, pretože by sa mohla rozbiť. Je potrebné prinútiť Hive opraviť svoju štruktúru partition:
from pyspark.sql import HiveContext
hc = HiveContext(spark)
hc.sql("MSCK REPAIR TABLE " + db + "." + destTable)
Jednoduchá úloha čítania JSON a vytvorenie na jeho základe výstupu sa premieňa na prekonávanie niekoľkých neviditeľných ťažkostí, na ktorých riešenia treba hľadať samostatne. A hoci sú tieto riešenia jednoduché, ich hľadanie si vyžaduje veľa času.
Aby sme realizovali vytvorenie výstupu, museli sme:
- Pridávať partition do výstupu, zbaviac sa pomocných súborov.
- Porozumieť prázdnym poliam vo vstupných údajoch, ktoré Spark typizoval.
- Previesť jednoduché typy na reťazec.
- Preniesť názvy polí na malé písmená.
- Oddeliť výstup údajov a registráciu tabuľky v Hive (vytvorenie DDL).
- Nezabudnúť na eskaláciu názvov polí, ktoré môžu byť nekompatibilné s Hive.
- Naučiť sa aktualizovať registráciu tabuľky v Hive.
Zhrňujúc, poznamenávame, že riešenie na vytvorenie výstupov skrýva množstvo skrytých nástrah. Preto, ak vzniknú ťažkosti pri realizácii, je lepšie obrátiť sa na skúseného partnera s úspešnou expertízou.
Ďakujeme za prečítanie tohto článku, dúfame, že informácie budú užitočné.
Zdroj: habr.com
Kúpte si spoľahlivý hosting pre webové stránky s ochranou proti DDoS, VPS VDS servery 🔥 Kúpte si spoľahlivý hosting pre webové stránky s ochranou proti DDoS, VPS VDS servery | ProHoster
