# Kontinuálna správa dát v MLOps pipeline s Formize

Podniky, ktoré nasadzujú modely strojového učenia vo veľkom meradle, čelia paradoxu: čím rýchlejšie iterujú, tým ťažšie je zaručiť, že dáta použité na tréning, validáciu a inferenciu spĺňajú interné politiky a externé regulácie. Tradičné prístupy k správe dát — manuálne audity, periodické správy a statické mapy liniek — nedokážu držať krok s rýchlosťou moderných MLOps pracovných tokov.

Formize, nízkokódový engine pre sledovanie liniek a súlad, bol postavený práve pre túto výzvu. Vložením Formize do CI/CD pipeline môžu organizácie **zachytávať linie v reálnom čase**, **vynucovať politiku ako kód** a **zverejňovať dashboardy kvality**, ktoré vývojári a audítori môžu okamžite dotazovať.

V tomto článku si ukážeme:

1. Náčrt základných konceptov kontinuálnej správy dát.  
2. Ako Formize integruje s populárnymi MLOps nástrojmi (GitHub Actions, Jenkins, Kubeflow, MLflow).  
3. Kompletnú implementáciu od hookov v systéme správy zdrojov po automatické kontroly súladu.  
4. Mermaid diagram vizualizujúci tok dát.  
5. Úvahy o škálovaní, bezpečnosti a budúcej odolnosti.

> **Kľúčová myšlienka:** Keď sa Formize stane natívnym krokom vo vašom CI/CD pipeline, sledovanie dát, vynucovanie politík a monitorovanie kvality sa stane *kontinuálnym* namiesto *periodického*.

---

## 1. Prečo je dôležitá kontinuálna správa

| Tradičný prístup | Kontinuálny prístup |
|------------------|---------------------|
| Audity sa vykonávajú štvrťročne alebo po narušení | Audity sa vykonávajú pri každom commite, zostavení a nasadení |
| Manuálne diagramy liniek sú neaktuálne | Automatizované grafy liniek odrážajú aktuálny stav |
| Porušenia politík sa objavia neskoro, ich oprava je nákladná | Porušenia politík okamžite blokujú pipeline |
| Obmedzená viditeľnosť pre netechnických stakeholderov | Dashboardy v reálnom čase posilňujú správcu dát a auditorov |

Prechod z **periodického** na **kontinuálny** odráža evolúciu z Waterfall na DevOps. Rovnako ako automatizované testy zachytia chyby kódu skôr, automatizovaná správa zachytí chyby dát skôr.

---

## 2. Základné stavebné bloky

1. **Formize Engine** – poskytuje API na zachytávanie liniek, definovanie politík a ukladanie audit trailu.  
2. **MLOps Orchestrator** – Jenkins, GitHub Actions, Azure Pipelines alebo Kubeflow pipelines, ktoré riadia tréning a nasadenie modelov.  
3. **Artifact Repository** – S3, Azure Blob alebo GCS, kde sú uložené datasety, binárky modelov a feature store.  
4. **Policy‑as‑Code** – pravidlá v YAML/JSON, ktoré kódujú GDPR, HIPAA alebo interné politiky používania dát.  
5. **Observability Layer** – Grafana/Prometheus dashboardy, ktoré zobrazujú metriky Formize.

Všetky komponenty komunikujú cez **RESTful endpointy** alebo **event streamy** (Kafka, Pub/Sub). Nasledujúci Mermaid diagram ilustruje tok dát.

```mermaid
graph LR
    subgraph CI_CD["CI/CD Pipeline"]
        A["Git Commit"] --> B["Build Stage"]
        B --> C["Test Stage"]
        C --> D["Training Stage"]
        D --> E["Model Registry"]
    end

    subgraph Governance["Formize Governance"]
        F["Lineage Capture"] --> G["Policy Engine"]
        G --> H["Compliance Report"]
        H --> I["Dashboard"]
    end

    D -->|Dataset Access| F
    E -->|Model Artifact| F
    G -->|Violation Event| CI_CD
    CI_CD -->|Fail Build| B
    I -->|Alert| Developers
```

*All node labels are wrapped in double quotes as required for Mermaid.*

---

## 3. Krok‑po‑kroku integrácia

### 3.1. Definujte politiku ako kód

Vytvorte súbor `policies.yaml` v koreňovom adresári repozitára:

```yaml
policies:
  - id: "PII-001"
    description: "Žiadne PII polia nesmú byť použité v tréningu bez explicitného súhlasu"
    condition: "dataset.contains('ssn') or dataset.contains('email')"
    action: "block"
    severity: "high"

  - id: "DATA-RETENTION-01"
    description: "Tréningové dáta staršie ako 5 rokov musia byť archivované"
    condition: "dataset.age > 5y"
    action: "warn"
    severity: "medium"
```

Formize načíta tento súbor počas kroku **Lineage Capture** a vyhodnotí každé pravidlo proti metadátam prichádzajúceho datasetu.

### 3.2. Pridajte Formize hook do pipeline

Nižšie je úryvok GitHub Actions, ktorý sa spustí po dokončení tréningovej úlohy:

```yaml
name: MLOps CI/CD

on:
  push:
    branches: [ main ]

jobs:
  train-and-govern:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Set up Python
        uses: actions/setup-python@v4
        with:
          python-version: '3.11'

      - name: Install dependencies
        run: pip install -r requirements.txt

      - name: Run training script
        id: train
        run: |
          python train.py --data s3://bucket/raw-data/2024-08-01.csv --output model.pkl

      - name: Capture lineage & enforce policy
        env:
          FORMIZE_API_KEY: ${{ secrets.FORMIZE_API_KEY }}
        run: |
          curl -X POST https://api.formize.io/v1/lineage \
            -H "Authorization: Bearer $FORMIZE_API_KEY" \
            -H "Content-Type: application/json" \
            -d @- <<EOF
          {
            "pipeline_id": "github-actions-mlops",
            "run_id": "${{ github.run_id }}",
            "artifact": "model.pkl",
            "dataset": "s3://bucket/raw-data/2024-08-01.csv",
            "metadata": {
              "commit_sha": "${{ github.sha }}",
              "author": "${{ github.actor }}",
              "timestamp": "$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
            },
            "policy_file": "policies.yaml"
          }
          EOF
```

Ak niektorá politika vráti `block`, krok skončí s nenulovým stavom, čím spôsobí zlyhanie celého jobu. Toto **fail‑fast** správanie zaručuje, že nekompatibilné dáta nikdy nedosiahnu produkciu.

### 3.3. Uložte linie do centrálneho grafu

Formize automaticky zapisuje orientovaný acyklický graf (DAG) do svojho interného Neo4j úložiska. Môžete ho dotazovať pomocou Cypher:

```cypher
MATCH (d:Dataset)-[:USED_IN]->(t:TrainingRun)-[:PRODUCED]->(m:Model)
WHERE d.name CONTAINS 'raw-data'
RETURN d.name, t.run_id, m.version
ORDER BY t.timestamp DESC
LIMIT 10;
```

Výsledok môžete vizualizovať v UI Formize alebo exportovať do Grafany pre vlastné dashboardy.

### 3.4. Dashboard v reálnom čase

Vytvorte Prometheus exporter, ktorý bude sťahovať metriky Formize:

```go
package main

import (
    "net/http"
    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promhttp"
)

var (
    policyViolations = prometheus.NewCounterVec(
        prometheus.CounterOpts{
            Name: "formize_policy_violations_total",
            Help: "Total number of policy violations detected",
        },
        []string{"policy_id", "severity"},
    )
)

func main() {
    // Assume we receive webhook events from Formize
    http.HandleFunc("/webhook", func(w http.ResponseWriter, r *http.Request) {
        // Parse JSON, increment counters...
    })
    prometheus.MustRegister(policyViolations)
    http.Handle("/metrics", promhttp.Handler())
    http.ListenAndServe(":9090", nil)
}
```

Grafana teraz môže vykresľovať `formize_policy_violations_total` podľa pipeline, čo poskytuje správcom dát okamžitú prehľadnosť.

---

## 4. Škálovanie vrstvy správy

| Výzva | Odporúčané riešenie |
|-------|----------------------|
| **Vysokofrekvenčné pipeline** (stovky spustení denne) | Nasadiť Formize v **klastrovanom** režime za load balancer; povoliť **batch ingest** liniek. |
| **Multi‑cloud zdroje dát** | Využiť **cloud‑agnostické konektory** Formize (S3, Azure Blob, GCS) a nastaviť jednotnú **schému identifikátorov zdrojov**. |
| **Vlastníctvo politík naprieč tímami** | Využiť **role‑based access control (RBAC)** Formize, aby každé doménové tím vlastnil svoje súbory politík, zatiaľ čo centrálny tím spravuje engine. |
| **Nemennosť audit‑trailu** | Prepojiť Formize s **blockchain anchor** (napr. Ethereum alebo Hyperledger) na kryptografické zapečatenie každej transakcie liniek. |

---

## 5. Bezpečnostné a súladové úvahy

1. **Správa API kľúčov** – Ukladať `FORMIZE_API_KEY` v secret manageroch (GitHub Secrets, Azure Key Vault). Kľúče rotovať štvrťročne.  
2. **Minimalizácia dát** – Do Formize posielať iba **metadáta** (hashy, schému, časové značky); nikdy nesúčasťovať surové PII.  
3. **Šifrovanie pri prenose** – Všetky endpointy Formize vyžadujú TLS 1.3.  
4. **Politiky uchovávania** – Nastaviť Formize tak, aby mazalo linie staršie ako nastavené retenčné okno, čím sa zosúladí s [GDPR](https://gdpr.eu/) „právom na zabudnutie“.

---

## 6. Budúcnosť vašej správy

- **Generovanie politík asistované AI**: Použiť LLM na návrh nových pravidiel na základe pozorovaných vzorov driftu dát.  
- **Event‑driven architektúra**: Nahradiť HTTP volania Kafka témami (`lineage.events`, `policy.violations`) pre ultra‑nízku latenciu.  
- **Self‑service portály**: Umožniť dátovým vedcom žiadať dočasné výnimky z politík cez UI poháňané Formize, s automatizovanými schvaľovacími workflow.

---

## 7. Zhrnutie

Vložením Formize do MLOps CI/CD pipeline sa správa dát mení z **reaktívneho kontrolného bodu** na **kontinuálny, automatizovaný štít**. Zachytávaním liniek v každej fáze, vyhodnocovaním politiky ako kódu a zobrazovaním metrik v reálnom čase môžu organizácie:

- Znížiť riziko nesúladu a náročnosť auditov.  
- Urýchliť doručovanie modelov bez kompromisu na kvalite dát.  
- Poskytnúť transparentné, auditovateľné stopy pre regulátorov aj interných auditorov.

Začnite s jednou pipeline, iterujte definície politík a škálujte horizontálne. Výsledkom je odolná, dôveryhodná platforma pre doručovanie AI, ktorá drží krok s modernou rýchlosťou vývoja.