Wykład 5 — Apache Spark i Structured Streaming

Analiza danych w czasie rzeczywistym

Apache Spark jako silnik rozproszonego przetwarzania, Structured Streaming, integracja Spark–Kafka, kompletny pipeline real-time analytics.

{{< fa clock >}} Czas trwania: 1,5h

Cel wykładu: Poznanie Apache Spark jako silnika do rozproszonego przetwarzania danych. Wprowadzenie do Structured Streaming i integracji Spark–Kafka. Przegląd kompletnego pipeline’u real-time analytics.

1 Dlaczego Spark?

Na poprzednich wykładach poznaliśmy Kafkę — system, który transportuje strumienie danych. Ale Kafka sama w sobie nie wykonuje złożonych analiz. Do tego potrzebujemy silnika przetwarzania — i tu wchodzi Apache Spark.

Spark to silnik do rozproszonego przetwarzania danych, który obsługuje zarówno tryb wsadowy (batch), jak i strumieniowy (streaming). Powstał na UC Berkeley w 2009 roku jako odpowiedź na ograniczenia Hadoop MapReduce — głównie na jego powolność wynikającą z ciągłego zapisu na dysk.

{{< fa memory >}} Przetwarzanie w pamięci

Dane trzymane w RAM, nie na dysku. Nawet 100x szybciej niż MapReduce.

{{< fa cubes >}} Jeden silnik, wiele trybów

Batch, streaming, SQL, ML, grafy — wszystko w jednym frameworku.

{{< fa python >}} API w wielu językach

PySpark, Scala, Java, R.

{{< fa wand-magic-sparkles >}} Lazy evaluation

Spark buduje plan wykonania i optymalizuje go zanim cokolwiek obliczy.

flowchart TB
    subgraph "Apache Spark"
        CORE["Spark Core\n(RDD, zarządzanie pamięcią)"]
        SQL["Spark SQL\n& DataFrames"]
        SS["Structured\nStreaming"]
        ML["MLlib\n(Machine Learning)"]
        GR["GraphX\n(Grafy)"]
    end
    SQL --> CORE
    SS --> CORE
    ML --> CORE
    GR --> CORE

    style CORE fill:#FF9800,color:#fff
    style SQL fill:#2196F3,color:#fff
    style SS fill:#F44336,color:#fff
    style ML fill:#4CAF50,color:#fff
    style GR fill:#9C27B0,color:#fff

Ekosystem Apache Spark

2 PySpark — podstawy

2.1 SparkSession — punkt wejścia

Każdy program PySpark zaczyna się od utworzenia SparkSession:

from pyspark.sql import SparkSession

spark = SparkSession.builder \
    .appName("MojaPierwszaAplikacja") \
    .master("local[*]") \
    .getOrCreate()

local[*] oznacza: uruchom Sparka lokalnie, używając wszystkich dostępnych rdzeni procesora. W produkcji zamiast tego podaje się adres klastra.

2.2 DataFrame API

Spark DataFrame to odpowiednik tabeli SQL lub DataFrame z Pandas — ale rozproszony na wielu maszynach.

from pyspark.sql import SparkSession
from pyspark.sql.functions import col, avg, sum, count

spark = SparkSession.builder.appName("Demo").master("local[*]").getOrCreate()

# Tworzenie DataFrame
dane = [
    ("Warszawa", "Elektronika", 4299.00),
    ("Kraków", "Odzież", 189.99),
    ("Warszawa", "Żywność", 87.50),
    ("Gdańsk", "Elektronika", 2599.00),
    ("Kraków", "Elektronika", 1299.00),
    ("Warszawa", "Odzież", 349.99),
    ("Gdańsk", "Żywność", 156.00),
]

df = spark.createDataFrame(dane, ["miasto", "kategoria", "kwota"])
df.show()

2.3 Transformacje i akcje

Spark rozróżnia dwa typy operacji:

Definiują co chcesz zrobić, ale nie wykonują obliczeń. Są leniwe (lazy).

Przykłady: filter, groupBy, select, join.

# Transformacje (lazy — nic się jeszcze nie liczy)
wynik = df \
    .filter(col("kwota") > 100) \
    .groupBy("miasto") \
    .agg(
        sum("kwota").alias("suma"),
        count("kwota").alias("liczba"),
        avg("kwota").alias("srednia")
    )

Wyzwalają faktyczne obliczenia.

Przykłady: show, count, collect, write.

# Akcja (tu Spark faktycznie wykonuje obliczenia)
wynik.show()

spark.stop()

{{< fa database >}} Spark SQL — alternatywa

Możesz też używać zwykłego SQL-a:

df.createOrReplaceTempView("sprzedaz")

spark.sql("""
    SELECT miasto,
           SUM(kwota) as suma,
           COUNT(*) as liczba
    FROM sprzedaz
    WHERE kwota > 100
    GROUP BY miasto
    ORDER BY suma DESC
""").show()

3 Structured Streaming — strumienie jako tabele

Kluczowa koncepcja

Structured Streaming traktuje strumień danych jak tabelę, do której ciągle dopisywane są nowe wiersze. Dzięki temu piszesz kod strumieniowy prawie identycznie jak batch — używasz tego samego DataFrame API.

flowchart TB
    subgraph "Strumień wejściowy"
        T1["Batch t1"] --> TAB["Nieograniczona\ntabela wejściowa\n(nowe wiersze\ndopisywane ciągle)"]
        T2["Batch t2"] --> TAB
        T3["Batch t3"] --> TAB
        T4["Batch t4..."] --> TAB
    end
    TAB -->|"Zapytanie\n(query)"| RES["Tabela wynikowa\n(aktualizowana\nz każdym triggerem)"]
    RES --> OUT["Wyjście:\nkonsola / Kafka / pliki / baza"]

    style TAB fill:#2196F3,color:#fff
    style RES fill:#4CAF50,color:#fff
    style OUT fill:#FF9800,color:#fff

Structured Streaming: strumień jako nieograniczona tabela

3.1 Tryby wyjścia (Output Modes)

{{< fa plus >}} Append

Do wyniku dopisywane są tylko nowe wiersze. Domyślny tryb.

{{< fa arrows-rotate >}} Complete

Cała tabela wynikowa jest nadpisywana (np. po agregacji).

{{< fa pen >}} Update

Zapisywane są tylko zmienione wiersze.

3.2 Przykład: streaming z plików CSV

Najprostszy przykład — Spark monitoruje katalog i przetwarza nowe pliki CSV w miarę ich pojawiania się:

from pyspark.sql import SparkSession
from pyspark.sql.functions import col, window, sum
from pyspark.sql.types import StructType, StringType, DoubleType, TimestampType

spark = SparkSession.builder.appName("StreamingDemo").master("local[*]").getOrCreate()

# Schemat danych
schema = StructType() \
    .add("transaction_id", StringType()) \
    .add("amount", DoubleType()) \
    .add("store", StringType()) \
    .add("timestamp", TimestampType())

# Czytanie strumienia z katalogu CSV
streaming_df = spark.readStream \
    .schema(schema) \
    .option("header", True) \
    .csv("/data/incoming/")

# Agregacja w oknach 5-minutowych
result = streaming_df \
    .groupBy(
        window(col("timestamp"), "5 minutes"),
        col("store")
    ) \
    .agg(sum("amount").alias("total"))

# Zapis wyniku do konsoli
query = result.writeStream \
    .outputMode("complete") \
    .format("console") \
    .trigger(processingTime="10 seconds") \
    .start()

# query.awaitTermination()

4 Integracja Spark + Kafka

Serce kursu

Kafka transportuje dane, Spark je przetwarza. To fundamentalna para w architekturze real-time analytics.

from pyspark.sql import SparkSession
from pyspark.sql.functions import from_json, col, window, avg, count
from pyspark.sql.types import StructType, StringType, DoubleType, TimestampType

spark = SparkSession.builder \
    .appName("KafkaStreaming") \
    .master("local[*]") \
    .getOrCreate()

# Odczyt strumienia z Kafki
kafka_df = spark.readStream \
    .format("kafka") \
    .option("kafka.bootstrap.servers", "localhost:9092") \
    .option("subscribe", "transakcje") \
    .option("startingOffsets", "latest") \
    .load()

# Kafka zwraca dane jako bajty — trzeba je sparsować
schema = StructType() \
    .add("id", StringType()) \
    .add("kwota", DoubleType()) \
    .add("sklep", StringType()) \
    .add("czas", TimestampType())

parsed_df = kafka_df \
    .selectExpr("CAST(value AS STRING) as json") \
    .select(from_json(col("json"), schema).alias("data")) \
    .select("data.*")

# Agregacja: średnia kwota i liczba transakcji
# w oknach 5-minutowych per sklep
wynik = parsed_df \
    .withWatermark("czas", "2 minutes") \
    .groupBy(
        window(col("czas"), "5 minutes"),
        col("sklep")
    ) \
    .agg(
        avg("kwota").alias("srednia_kwota"),
        count("*").alias("liczba_transakcji")
    )

# Zapis do konsoli (na lab: do bazy danych lub dashboardu)
query = wynik.writeStream \
    .outputMode("update") \
    .format("console") \
    .option("truncate", False) \
    .trigger(processingTime="10 seconds") \
    .start()

# query.awaitTermination()

Zwróć uwagę na .withWatermark("czas", "2 minutes") — to mechanizm watermarkingu, o którym mówiliśmy na Wykładzie 2. Spark toleruje opóźnienie zdarzeń do 2 minut i automatycznie odrzuca te, które przyszły później.

5 Kompletny pipeline — podsumowanie kursu

Łączmy wszystko, co poznaliśmy na wykładach:

flowchart LR
    subgraph "Źródła danych"
        WEB["Aplikacja\nwebowa"]
        PAY["System\npłatności"]
        IOT["Sensory\nIoT"]
    end
    subgraph "Transport"
        K["Apache Kafka\n(W4)"]
    end
    subgraph "Przetwarzanie"
        SS["Spark Streaming\n(W5)"]
        ML["FastAPI + ML\n(W3)"]
    end
    subgraph "Wyniki"
        DASH["Dashboard\n(near RT)"]
        ALERT["Alerty\n(real-time)"]
        REP["Raporty\n(batch)"]
    end

    WEB --> K
    PAY --> K
    IOT --> K
    K --> SS --> DASH
    K --> ML --> ALERT
    SS --> REP

    style K fill:#FF9800,color:#fff
    style SS fill:#2196F3,color:#fff
    style ML fill:#4CAF50,color:#fff
    style DASH fill:#E3F2FD,stroke:#2196F3
    style ALERT fill:#FFEBEE,stroke:#F44336
    style REP fill:#F3E5F5,stroke:#9C27B0

Kompletny pipeline real-time analytics — podsumowanie kursu

Mapa kursu
Komponent	Rola	Wykład
Typy danych, OLTP/OLAP, Data Lake	Kontekst i historia	W1
Lambda/Kappa, okna czasowe	Architektura	W2
ML batch vs online, SGD, anomalie	Modele i algorytmy	W3
Apache Kafka	Transport danych	W4
Apache Spark + Structured Streaming	Przetwarzanie	W5

6 Złożoność algorytmów — uwaga praktyczna

Projektując pipeline real-time, rozważ wymiar obliczeniowy

Duże dane, proste obliczenia — np. filtrowanie logów, agregacje. Spark radzi sobie świetnie.
Małe dane, ciężkie obliczenia — np. trenowanie modelu deep learning. Lepiej offline na GPU.
Duże dane, ciężkie obliczenia — np. analiza wideo w czasie rzeczywistym. Wymaga specjalistycznej architektury (GPU cluster, edge computing).

Dla systemów real-time kluczowe jest, żeby czas przetwarzania jednego zdarzenia był krótszy niż interwał między zdarzeniami. Inaczej kolejka rośnie bez końca.

7 Co dalej — laboratoria

Na laboratoriach zbudujecie kompletny system krok po kroku:

Plan laboratoriów
Lab	Temat
1–2	Środowisko (Git, Docker, Python), analiza eksploracyjna danych
3–4	Model ML (scikit-learn), przygotowanie do wdrożenia
5–6	Kafka w Dockerze — producent i konsument w Pythonie
7–8	PySpark + Structured Streaming + Kafka
9–10	Kompletny pipeline + projekt grupowy

8 Podsumowanie

Apache Spark to silnik, który zamienia surowe strumienie danych w wartość biznesową. W połączeniu z Kafką tworzy potężną platformę real-time analytics. Structured Streaming upraszcza programowanie strumieniowe — piszesz kod jak dla batch, a Spark zajmuje się resztą.

{{< fa flag-checkered >}} To był ostatni wykład

Na laboratoriach przełożycie tę wiedzę na praktykę — od pierwszego docker compose up po kompletny system przetwarzania danych w czasie rzeczywistym.

{{< fa laptop-code >}} Przed Lab 1

Upewnij się, że masz zainstalowanego Dockera i Gita (patrz strona Narzędzia). Sklonuj repozytorium kursu i uruchom docker compose up — jeśli działa, jesteś gotowy.

--- title: "Wykład 5 — Apache Spark i Structured Streaming" subtitle: "Analiza danych w czasie rzeczywistym" description: "Apache Spark jako silnik rozproszonego przetwarzania, Structured Streaming, integracja Spark–Kafka, kompletny pipeline real-time analytics." format: html: code-fold: true code-tools: true code-summary: "Pokaż kod" toc: true toc-depth: 3 toc-title: "Spis treści" number-sections: true smooth-scroll: true theme: light: flatly highlight-style: github fig-align: center fig-cap-location: bottom jupyter: python3 --- ::: {.callout-note appearance="minimal"} ## {{< fa clock >}} Czas trwania: 1,5h **Cel wykładu:** Poznanie Apache Spark jako silnika do rozproszonego przetwarzania danych. Wprowadzenie do Structured Streaming i integracji Spark–Kafka. Przegląd kompletnego pipeline'u real-time analytics. ::: --- ## Dlaczego Spark? Na poprzednich wykładach poznaliśmy Kafkę — system, który **transportuje** strumienie danych. Ale Kafka sama w sobie nie wykonuje złożonych analiz. Do tego potrzebujemy silnika przetwarzania — i tu wchodzi **Apache Spark**. Spark to silnik do **rozproszonego przetwarzania danych**, który obsługuje zarówno tryb wsadowy (batch), jak i strumieniowy (streaming). Powstał na UC Berkeley w 2009 roku jako odpowiedź na ograniczenia Hadoop MapReduce — głównie na jego powolność wynikającą z ciągłego zapisu na dysk. :::: {.columns} ::: {.column width="50%"} ::: {.callout-tip appearance="simple"} ## {{< fa memory >}} Przetwarzanie w pamięci Dane trzymane w RAM, nie na dysku. Nawet **100x szybciej** niż MapReduce. ::: ::: {.callout-tip appearance="simple"} ## {{< fa cubes >}} Jeden silnik, wiele trybów Batch, streaming, SQL, ML, grafy — wszystko w jednym frameworku. ::: ::: ::: {.column width="50%"} ::: {.callout-tip appearance="simple"} ## {{< fa python >}} API w wielu językach PySpark, Scala, Java, R. ::: ::: {.callout-tip appearance="simple"} ## {{< fa wand-magic-sparkles >}} Lazy evaluation Spark buduje plan wykonania i optymalizuje go **zanim** cokolwiek obliczy. ::: ::: :::: ```{mermaid} %%| fig-cap: "Ekosystem Apache Spark" flowchart TB subgraph "Apache Spark" CORE["Spark Core\n(RDD, zarządzanie pamięcią)"] SQL["Spark SQL\n& DataFrames"] SS["Structured\nStreaming"] ML["MLlib\n(Machine Learning)"] GR["GraphX\n(Grafy)"] end SQL --> CORE SS --> CORE ML --> CORE GR --> CORE style CORE fill:#FF9800,color:#fff style SQL fill:#2196F3,color:#fff style SS fill:#F44336,color:#fff style ML fill:#4CAF50,color:#fff style GR fill:#9C27B0,color:#fff ``` --- ## PySpark — podstawy ### SparkSession — punkt wejścia Każdy program PySpark zaczyna się od utworzenia `SparkSession`: ```python from pyspark.sql import SparkSession spark = SparkSession.builder \ .appName("MojaPierwszaAplikacja") \ .master("local[*]") \ .getOrCreate() ``` ::: {.callout-note appearance="simple"} `local[*]` oznacza: uruchom Sparka lokalnie, używając wszystkich dostępnych rdzeni procesora. W produkcji zamiast tego podaje się adres klastra. ::: ### DataFrame API Spark DataFrame to odpowiednik tabeli SQL lub DataFrame z Pandas — ale **rozproszony** na wielu maszynach. ```python from pyspark.sql import SparkSession from pyspark.sql.functions import col, avg, sum, count spark = SparkSession.builder.appName("Demo").master("local[*]").getOrCreate() # Tworzenie DataFrame dane = [ ("Warszawa", "Elektronika", 4299.00), ("Kraków", "Odzież", 189.99), ("Warszawa", "Żywność", 87.50), ("Gdańsk", "Elektronika", 2599.00), ("Kraków", "Elektronika", 1299.00), ("Warszawa", "Odzież", 349.99), ("Gdańsk", "Żywność", 156.00), ] df = spark.createDataFrame(dane, ["miasto", "kategoria", "kwota"]) df.show() ``` ### Transformacje i akcje Spark rozróżnia dwa typy operacji: ::: {.panel-tabset} #### {{< fa wand-magic-sparkles >}} Transformacje (lazy) Definiują *co* chcesz zrobić, ale **nie wykonują** obliczeń. Są **leniwe** (lazy). Przykłady: `filter`, `groupBy`, `select`, `join`. ```python # Transformacje (lazy — nic się jeszcze nie liczy) wynik = df \ .filter(col("kwota") > 100) \ .groupBy("miasto") \ .agg( sum("kwota").alias("suma"), count("kwota").alias("liczba"), avg("kwota").alias("srednia") ) ``` #### {{< fa play >}} Akcje (eager) **Wyzwalają** faktyczne obliczenia. Przykłady: `show`, `count`, `collect`, `write`. ```python # Akcja (tu Spark faktycznie wykonuje obliczenia) wynik.show() spark.stop() ``` ::: ::: {.callout-tip collapse="true"} ## {{< fa database >}} Spark SQL — alternatywa Możesz też używać zwykłego SQL-a: ```python df.createOrReplaceTempView("sprzedaz") spark.sql(""" SELECT miasto, SUM(kwota) as suma, COUNT(*) as liczba FROM sprzedaz WHERE kwota > 100 GROUP BY miasto ORDER BY suma DESC """).show() ``` ::: --- ## Structured Streaming — strumienie jako tabele ::: {.callout-important} ## Kluczowa koncepcja Structured Streaming traktuje **strumień danych jak tabelę, do której ciągle dopisywane są nowe wiersze**. Dzięki temu piszesz kod strumieniowy prawie identycznie jak batch — używasz tego samego DataFrame API. ::: ```{mermaid} %%| fig-cap: "Structured Streaming: strumień jako nieograniczona tabela" flowchart TB subgraph "Strumień wejściowy" T1["Batch t1"] --> TAB["Nieograniczona\ntabela wejściowa\n(nowe wiersze\ndopisywane ciągle)"] T2["Batch t2"] --> TAB T3["Batch t3"] --> TAB T4["Batch t4..."] --> TAB end TAB -->|"Zapytanie\n(query)"| RES["Tabela wynikowa\n(aktualizowana\nz każdym triggerem)"] RES --> OUT["Wyjście:\nkonsola / Kafka / pliki / baza"] style TAB fill:#2196F3,color:#fff style RES fill:#4CAF50,color:#fff style OUT fill:#FF9800,color:#fff ``` ### Tryby wyjścia (Output Modes) :::: {.columns} ::: {.column width="33%"} ::: {.callout-note appearance="simple"} ## {{< fa plus >}} Append Do wyniku dopisywane są tylko **nowe** wiersze. Domyślny tryb. ::: ::: ::: {.column width="33%"} ::: {.callout-warning appearance="simple"} ## {{< fa arrows-rotate >}} Complete Cała tabela wynikowa jest **nadpisywana** (np. po agregacji). ::: ::: ::: {.column width="33%"} ::: {.callout-tip appearance="simple"} ## {{< fa pen >}} Update Zapisywane są tylko **zmienione** wiersze. ::: ::: :::: ### Przykład: streaming z plików CSV Najprostszy przykład — Spark monitoruje katalog i przetwarza nowe pliki CSV w miarę ich pojawiania się: ```python from pyspark.sql import SparkSession from pyspark.sql.functions import col, window, sum from pyspark.sql.types import StructType, StringType, DoubleType, TimestampType spark = SparkSession.builder.appName("StreamingDemo").master("local[*]").getOrCreate() # Schemat danych schema = StructType() \ .add("transaction_id", StringType()) \ .add("amount", DoubleType()) \ .add("store", StringType()) \ .add("timestamp", TimestampType()) # Czytanie strumienia z katalogu CSV streaming_df = spark.readStream \ .schema(schema) \ .option("header", True) \ .csv("/data/incoming/") # Agregacja w oknach 5-minutowych result = streaming_df \ .groupBy( window(col("timestamp"), "5 minutes"), col("store") ) \ .agg(sum("amount").alias("total")) # Zapis wyniku do konsoli query = result.writeStream \ .outputMode("complete") \ .format("console") \ .trigger(processingTime="10 seconds") \ .start() # query.awaitTermination() ``` --- ## Integracja Spark + Kafka ::: {.callout-important appearance="simple"} ## Serce kursu **Kafka transportuje dane, Spark je przetwarza.** To fundamentalna para w architekturze real-time analytics. ::: ::: {.panel-tabset} ### Czytanie z Kafki ```python from pyspark.sql import SparkSession from pyspark.sql.functions import from_json, col, window, avg, count from pyspark.sql.types import StructType, StringType, DoubleType, TimestampType spark = SparkSession.builder \ .appName("KafkaStreaming") \ .master("local[*]") \ .getOrCreate() # Odczyt strumienia z Kafki kafka_df = spark.readStream \ .format("kafka") \ .option("kafka.bootstrap.servers", "localhost:9092") \ .option("subscribe", "transakcje") \ .option("startingOffsets", "latest") \ .load() # Kafka zwraca dane jako bajty — trzeba je sparsować schema = StructType() \ .add("id", StringType()) \ .add("kwota", DoubleType()) \ .add("sklep", StringType()) \ .add("czas", TimestampType()) parsed_df = kafka_df \ .selectExpr("CAST(value AS STRING) as json") \ .select(from_json(col("json"), schema).alias("data")) \ .select("data.*") ``` ### Przetwarzanie i zapis ```python # Agregacja: średnia kwota i liczba transakcji # w oknach 5-minutowych per sklep wynik = parsed_df \ .withWatermark("czas", "2 minutes") \ .groupBy( window(col("czas"), "5 minutes"), col("sklep") ) \ .agg( avg("kwota").alias("srednia_kwota"), count("*").alias("liczba_transakcji") ) # Zapis do konsoli (na lab: do bazy danych lub dashboardu) query = wynik.writeStream \ .outputMode("update") \ .format("console") \ .option("truncate", False) \ .trigger(processingTime="10 seconds") \ .start() # query.awaitTermination() ``` ::: {.callout-note appearance="simple"} Zwróć uwagę na `.withWatermark("czas", "2 minutes")` — to mechanizm watermarkingu, o którym mówiliśmy na Wykładzie 2. Spark toleruje opóźnienie zdarzeń do 2 minut i automatycznie odrzuca te, które przyszły później. ::: ::: --- ## Kompletny pipeline — podsumowanie kursu Łączmy wszystko, co poznaliśmy na wykładach: ```{mermaid} %%| fig-cap: "Kompletny pipeline real-time analytics — podsumowanie kursu" flowchart LR subgraph "Źródła danych" WEB["Aplikacja\nwebowa"] PAY["System\npłatności"] IOT["Sensory\nIoT"] end subgraph "Transport" K["Apache Kafka\n(W4)"] end subgraph "Przetwarzanie" SS["Spark Streaming\n(W5)"] ML["FastAPI + ML\n(W3)"] end subgraph "Wyniki" DASH["Dashboard\n(near RT)"] ALERT["Alerty\n(real-time)"] REP["Raporty\n(batch)"] end WEB --> K PAY --> K IOT --> K K --> SS --> DASH K --> ML --> ALERT SS --> REP style K fill:#FF9800,color:#fff style SS fill:#2196F3,color:#fff style ML fill:#4CAF50,color:#fff style DASH fill:#E3F2FD,stroke:#2196F3 style ALERT fill:#FFEBEE,stroke:#F44336 style REP fill:#F3E5F5,stroke:#9C27B0 ``` | Komponent | Rola | Wykład | |-----------|------|:------:| | Typy danych, OLTP/OLAP, Data Lake | Kontekst i historia | W1 | | Lambda/Kappa, okna czasowe | Architektura | W2 | | ML batch vs online, SGD, anomalie | Modele i algorytmy | W3 | | Apache Kafka | Transport danych | W4 | | Apache Spark + Structured Streaming | Przetwarzanie | W5 | : Mapa kursu {.striped .hover} --- ## Złożoność algorytmów — uwaga praktyczna ::: {.callout-caution} ## Projektując pipeline real-time, rozważ wymiar obliczeniowy - **Duże dane, proste obliczenia** — np. filtrowanie logów, agregacje. Spark radzi sobie świetnie. - **Małe dane, ciężkie obliczenia** — np. trenowanie modelu deep learning. Lepiej offline na GPU. - **Duże dane, ciężkie obliczenia** — np. analiza wideo w czasie rzeczywistym. Wymaga specjalistycznej architektury (GPU cluster, edge computing). Dla systemów real-time kluczowe jest, żeby czas przetwarzania jednego zdarzenia był **krótszy** niż interwał między zdarzeniami. Inaczej kolejka rośnie bez końca. ::: --- ## Co dalej — laboratoria Na laboratoriach zbudujecie kompletny system krok po kroku: | Lab | Temat | |:---:|-------| | 1–2 | Środowisko (Git, Docker, Python), analiza eksploracyjna danych | | 3–4 | Model ML (scikit-learn), przygotowanie do wdrożenia | | 5–6 | Kafka w Dockerze — producent i konsument w Pythonie | | 7–8 | PySpark + Structured Streaming + Kafka | | 9–10 | Kompletny pipeline + projekt grupowy | : Plan laboratoriów {.striped .hover} --- ## Podsumowanie Apache Spark to silnik, który zamienia surowe strumienie danych w wartość biznesową. W połączeniu z Kafką tworzy potężną platformę real-time analytics. Structured Streaming upraszcza programowanie strumieniowe — piszesz kod jak dla batch, a Spark zajmuje się resztą. ::: {.callout-important appearance="simple"} ## {{< fa flag-checkered >}} To był ostatni wykład Na laboratoriach przełożycie tę wiedzę na praktykę — od pierwszego `docker compose up` po kompletny system przetwarzania danych w czasie rzeczywistym. ::: ::: {.callout-tip appearance="simple"} ## {{< fa laptop-code >}} Przed Lab 1 Upewnij się, że masz zainstalowanego Dockera i Gita (patrz strona [Narzędzia](info.qmd)). Sklonuj repozytorium kursu i uruchom `docker compose up` — jeśli działa, jesteś gotowy. :::