Effektiv datahantering med PySpark, Pandas och Polars på Kubernetes

Prerequisites:

Deltagarna bör ha:

• Praktisk erfarenhet av Python-programmering, inklusive funktioner, moduler och grundläggande objektorienterade koncept.
• Grundläggande till medelstads erfarenhet av arbete med Pandas och tabellbaserade datahanteringsflöden.
• Grundläggande kännedom om PySpark och Spark DataFrames, inklusive dataläsning, transformationer, åtgärder, joinar och aggregationer.
• En generell förståelse av SQL och datahanteringskoncept, inklusive filtrering, gruppering och sammanslagning av datauppsättningar.
• Grundläggande kännedom om Docker- och Kubernetes-koncept, såsom behållare, bilder och pods. Det krävs inte att deltagarna har erfarenhet av Kubernetes-administration.
• Grundläggande förståelse av vanliga dataformat, såsom CSV, JSON och Parquet.

Deltagarna behöver inte vara Kubernetes-administratorer eller infrastrukturspecialister. Kursen fokuserar på hur dataingenjörer, utvecklare och datavetare kan förstå och optimera sina Spark-processer på Kubernetes ur ett applikations- och konfigurationsperspektiv.

Målgrupp

Denna kurs är designad för yrkesverksamma som utvecklar, underhåller eller optimerar datahanterings- och maskinlärningsprocesser med hjälp av Python och Spark i moln- eller behållarbaserade miljöer.

Den passar särskilt väl för:

• Dataingenjörer som arbetar med PySpark, distribuerad datahantering och ETL-pipelines.
• Datavetare som behandlar stora datauppsättningar eller kör maskinlärningsprocesser med Spark, Pandas eller Polars.
• Python-utvecklare som arbetar med datatunga appar och vill förbättra minneseffektivitet och bearbetningsprestanda.
• Maskinlärningsingenjörer som hanterar dataförberedelse- och modellutbildningsprocesser i delade Kubernetes- eller molnmiljöer.
• Analysingenjörer som arbetar med stora datauppsättningar och vill förbättra datahanteringseffektiviteten.
• DevOps-, plattform- och molningenjörer som stöder Spark-processer på Kubernetes och behöver förstå hur konfiguration på applikationsnivå påverkar resursanvändning och prestanda.
• Tekniska ledare och arkitekter som är inblandade i design eller optimering av moderna datahanteringsplattformar.

Overview:

Den här praktiska kursen på tre dagar fokuserar på att bygga och optimera effektiva datahanteringsprocesser med PySpark, Pandas och Polars i Kubernetes-baserade miljöer.

Deltagarna får en praktisk förståelse för hur Spark-applikationer exekveras på Kubernetes och hur beslutsfattande på applikationsnivå påverkar prestanda, skalbarhet, resursanvändning och kostnader. Kursen täcker centrala optimeringsområden, såsom executor-storlek, minnesallokering, dynamisk allokering, partitioneringsstrategier, shuffle-beteende, småfilproblem och effektiv Parquet-hantering.

Kursen tar också upp vanliga utmaningar vid arbete med Pandas, inklusive minnesbegränsningar och minnesbristfel, och presenterar Polars som ett högeffektivt alternativ för specifika datahanteringsprocesser. Genom praktiska övningar kommer deltagarna att diagnostisera prestanda- och minnesproblem, jämföra olika konfigurationsstrategier och tillämpa optimeringstekniker på realistiska ETL- och maskinlärnings_scenarioer.

Tonen i kursen är inriktad på praktiskt beslutsfattande: att förstå hur man identifierar flaskhalsar, väljer rätt verktyg, konfigurerar Spark effektivt och balanserar prestanda med infrastrukturresursanvändning och kostnad.

Course Outline:

Modul 1: Grundläggande Big Data & Spark

• Översikt över Big Data-ekosystemet och Spark:s roll i moderna dataplattformar
• Förståelse av Spark-arkitektur: driver, executorer, klusterhanterare, lat evaluering, DAG och exekveringsplanering
• Skillnader mellan RDD- och DataFrame-API:er och när man ska använda respektive metod
• Skapa och konfigurera SparkSession samt förstå grundläggande applikationskonfiguration

Modul 2: PySpark DataFrames

• Läsa och skriva data från källor och format för företag: CSV, JSON, Parquet och Delta
• Arbeta med PySpark DataFrames: transformationer, åtgärder, kolumnextrack, filtrering, joinar och aggregationer
• Implementera avancerade operationer som funksionsfönster, hantera tidsstämplar och arbeta med nästlad data
• Tillämpa datakvalitetskontroller och skriva återanvändbar, underhållbar PySpark-kod

Modul 3: Kubernetes & Docker-grunder för Spark-användare

• Förstå hur Docker-bilder och Kubernetes-pods relaterar till Spark driver- och executor-processer – ett konceptuellt perspektiv för klusteranvändare, inte administratorer
• Förstå vad som händer när ett Spark-jobb körs på Kubernetes: pod-schemaläggning, resursbegär och gränser, och hur sessioninställningar kartläggs på dem
• Förstå vad du styr via Spark session-parametrar jämfört med vad plattformsteamet styr via klusterprovisionering – och varför denna gräns är viktig för städningsarbete
• Praktisk övning: Inspektera ett körande Spark-on-Kubernetes-jobb i sandbox-klustret och identifiera driver- och executor-pods

Modul 4: Spark Session-konfiguration på Kubernetes – Djupdykning

• Förstå antalet executorer jämfört med executor-storlek: avvägningar mellan minne och kärnor och hur man resonemang kring dem
• Minnesallokering för driver och executorer, minnesreserver, och hur detta översätts till pod-resurser
• Dynamisk allokering: hur den beter sig på Kubernetes, när den sparar resurser och när den inte gör det
• Praktisk övning: Kör samma jobb med olika executor- och kärnkongfigurationer och jämför körningstid och resursanvändning

Modul 5: Skalningsbeteende & Kostnadsoptimering

• Förstå hur tillägg eller borttag av noder påverkar jobbets beteende, sluttid och resursanvändning
• Jämföra många små executorer mot färre stora: avvägningar mellan prestanda och kostnad
• Shuffle-beteende och stäning av shuffle-partitioner, inklusive uppskattning av kostnadsverkan av konfigurationsval
• Praktisk övning: Skala upp sandbox-klustret från fem till tio noder och observera effekten på jobbets sluttid och resursanvändning

Modul 6: Effektiv datainkontering & partitionering

• Förstå småfilproblemet: varför källor uppdelade i många små Parquet-filer (1–5 MB) försämrar prestanda och förvränger partitionering
• Strategier för ompartitionering och sammanfogning
• Kontrollera storlek på partitioner vid läsning och skrivning
• Skriva Parquet effektivt för att undvika att skapa småfilproblem nedströms
• Praktisk övning: Ladda en dataset bestående av många små Parquet-partitioner, tillämpa olika ompartitioneringsstrategier och jämför prestanda före och efter optimering

Modul 7: Minneshantering & felbehandling i Pandas

• Förstå grundorsakerna till minnesbristfel i Pandas och känna igen symtomen
• Tillämpa minneseffektiva omvandlingsmönster mellan Spark och Pandas
• Undvika minnesbrist vid skrivning av stora datasets till CSV
• Använda styckvis bearbetning och dtype-optimering för begränsade miljöer
• Praktisk övning: Återuppta ett typiskt Pandas minnesbristscenario och lösa det med styckvis bearbetning och dtype-optimering

Modul 8: Polars som ett kompletterande verktyg

• Positionera Polars i förhållande till Pandas: prestandakarakteristika, lat evaluering och minnesbeteende
• Förstå var Polars passar in bredvid PySpark och Pandas i moderna molndatastacks och migrationsvägar, inklusive AWS-miljöer
• Praktisk övning: Skriv om en Pandas-tung transformation i Polars och jämför minnesanvändning och bearbetningshastighet

Modul 9: Tillämpa optimering på ETL & ML-processer

• Tillämpa principer för konfiguration, partitionering och minneshantering i en realistisk ETL-pipeline
• Förstå optimeringsöverväganden specifika för maskinlärningsprocesser som körs i samma kluster
• Tillämpa en praktisk justeringsarbetsflöde för att systematiskt diagnostisera kostnads- och prestandaproblem
• Praktisk övning: Slutför ett end-to-end mini-projekt som kombinerar datainläsning, transformation och ett enkelt modellutbildningssteg, där deltagarna själva justerar Spark-konfigurationen