# Ciągłe zarządzanie danymi w pipeline'ach MLOps z Formize

Przedsiębiorstwa, które wdrażają modele uczenia maszynowego na dużą skalę, stoją przed paradoksem: im szybciej iterują, tym trudniej zagwarantować, że dane używane do treningu, walidacji i inferencji spełniają wewnętrzne polityki oraz zewnętrzne regulacje. Tradycyjne podejścia do zarządzania danymi — ręczne audyty, okresowe raporty i statyczne mapy linii danych — nie nadążają za prędkością współczesnych przepływów pracy MLOps.

Formize, niskokodowy silnik śledzenia linii danych i zgodności, został zbudowany właśnie z myślą o tym wyzwaniu. Dzięki wbudowaniu Formize w pipeline CI/CD, organizacje mogą **rejestrować linię danych w czasie rzeczywistym**, **egzekwować polityki jako kod** oraz **udostępniać pulpity jakości**, które deweloperzy i audytorzy mogą natychmiast przeglądać.

W tym artykule pokażemy:

1. Główne pojęcia ciągłego zarządzania danymi.  
2. Jak Formize integruje się z popularnymi narzędziami MLOps (GitHub Actions, Jenkins, Kubeflow, MLflow).  
3. Kompletną implementację od hooków w systemie kontroli wersji po automatyczne kontrole zgodności.  
4. Diagram Mermaid wizualizujący przepływ danych.  
5. Kwestie skalowania, bezpieczeństwa i przyszłej rozbudowy.

> **Kluczowy wniosek:** Gdy Formize staje się natywnym krokiem w Twoim pipeline CI/CD, śledzenie linii danych, egzekwowanie polityk i monitorowanie jakości stają się *ciągłe* zamiast *okazjonalnych* działań.

---

## 1. Dlaczego ciągłe zarządzanie ma znaczenie

| Tradycyjne podejście | Podejście ciągłe |
|----------------------|------------------|
| Audyty przeprowadzane kwartalnie lub po naruszeniu | Audyty uruchamiane przy każdym commicie, buildzie i wdrożeniu |
| Ręczne diagramy linii danych są nieaktualne | Automatyczne grafy linii danych odzwierciedlają bieżący stan |
| Naruszenia polityk wykrywane późno, kosztowne do naprawy | Naruszenia polityk blokują pipeline natychmiast |
| Ograniczona widoczność dla interesariuszy nietechnicznych | Pulpity w czasie rzeczywistym umożliwiają dostęp stewardom danych i audytorom |

Przejście od **okazjonalnego** do **ciągłego** zarządzania odzwierciedla ewolucję od Waterfall do DevOps. Tak jak automatyczne testy wykrywają błędy w kodzie wcześnie, automatyczne mechanizmy zarządzania wykrywają wady danych na wczesnym etapie.

---

## 2. Podstawowe elementy budulcowe

1. **Silnik Formize** – udostępnia API do rejestrowania linii danych, definiowania polityk i przechowywania ścieżki audytu.  
2. **Orkiestrator MLOps** – Jenkins, GitHub Actions, Azure Pipelines lub pipeline'y Kubeflow sterujące treningiem i wdrożeniem modeli.  
3. **Repozytorium artefaktów** – S3, Azure Blob lub GCS, w którym przechowywane są zestawy danych, binaria modeli i sklepy cech.  
4. **Polityka‑jako‑kod** – reguły YAML/JSON opisujące GDPR, HIPAA lub wewnętrzne zasady użycia danych.  
5. **Warstwa obserwowalności** – pulpity Grafana/Prometheus prezentujące metryki Formize.

Wszystkie komponenty komunikują się przez **endpointy RESTful** lub **strumienie zdarzeń** (Kafka, Pub/Sub). Poniższy diagram Mermaid ilustruje przepływ danych.

```mermaid
graph LR
    subgraph CI_CD["Pipeline CI/CD"]
        A["Commit w Git"] --> B["Etap budowania"]
        B --> C["Etap testów"]
        C --> D["Etap treningu"]
        D --> E["Rejestr modeli"]
    end

    subgraph Governance["Zarządzanie Formize"]
        F["Rejestrowanie linii danych"] --> G["Silnik polityk"]
        G --> H["Raport zgodności"]
        H --> I["Dashboard"]
    end

    D -->|Dostęp do zestawu danych| F
    E -->|Artefakt modelu| F
    G -->|Zdarzenie naruszenia| CI_CD
    CI_CD -->|Niepowodzenie builda| B
    I -->|Alert| Deweloperzy
```

*Wszystkie etykiety węzłów są ujęte w podwójne cudzysłowy, jak wymaga Mermaid.*

---

## 3. Integracja krok po kroku

### 3.1. Definicja polityki‑jako‑kod

Utwórz plik `policies.yaml` w katalogu głównym repozytorium:

```yaml
policies:
  - id: "PII-001"
    description: "Żadne pola PII nie mogą być używane w treningu bez wyraźnej zgody"
    condition: "dataset.contains('ssn') or dataset.contains('email')"
    action: "block"
    severity: "high"

  - id: "DATA-RETENTION-01"
    description: "Dane treningowe starsze niż 5 lat muszą być archiwizowane"
    condition: "dataset.age > 5y"
    action: "warn"
    severity: "medium"
```

Formize odczytuje ten plik w trakcie kroku **Rejestrowanie linii danych** i ocenia każdą regułę względem metadanych przychodzącego zestawu danych.

### 3.2. Dodanie hooka Formize do pipeline

Poniżej fragment konfiguracji GitHub Actions, który uruchamia się po zakończeniu zadania treningowego:

```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
```

Jeśli którakolwiek polityka zwróci `block`, krok zakończy się kodem wyjścia różnym od zera, co spowoduje niepowodzenie całego zadania. Takie **fail‑fast** zachowanie gwarantuje, że niezgodne dane nigdy nie trafią do produkcji.

### 3.4. Przechowywanie linii danych w centralnym grafie

Formize automatycznie zapisuje skierowany acykliczny graf (DAG) w wewnętrznej bazie Neo4j. Możesz go zapytać przy pomocy 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;
```

Wynik można zwizualizować w UI Formize lub wyeksportować do Grafany w celu stworzenia własnych pulpitów.

### 3.5. Dashboard w czasie rzeczywistym

Stwórz exporter Prometheusa, który pobiera metryki z 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: "Łączna liczba wykrytych naruszeń polityk",
        },
        []string{"policy_id", "severity"},
    )
)

func main() {
    // Zakładamy, że otrzymujemy zdarzenia webhook od Formize
    http.HandleFunc("/webhook", func(w http.ResponseWriter, r *http.Request) {
        // Parsowanie JSON, inkrementacja liczników...
    })
    prometheus.MustRegister(policyViolations)
    http.Handle("/metrics", promhttp.Handler())
    http.ListenAndServe(":9090", nil)
}
```

Grafana może teraz wykreślić `formize_policy_violations_total` dla poszczególnych pipeline'ów, dając stewardom danych natychmiastową widoczność.

---

## 4. Skalowanie warstwy zarządzania

| Wyzwanie | Rekomendowane rozwiązanie |
|----------|---------------------------|
| **Pipeline'y o wysokiej częstotliwości** (setki uruchomień dziennie) | Uruchom Formize w trybie **klastrowym** za load balancerem; włącz **wsadowe przyjmowanie** zdarzeń linii danych. |
| **Źródła danych wielochmurowe** | Skorzystaj z **łączników niezależnych od chmury** (S3, Azure Blob, GCS) i skonfiguruj jednolitą **składnię identyfikatora zasobu**. |
| **Wspólna własność polityk między zespołami** | Wykorzystaj **RBAC** Formize, aby poszczególne zespoły domenowe zarządzały własnymi plikami polityk, a centralny zespół administrował silnikiem. |
| **Niezmienność ścieżki audytu** | Połącz Formize z **anchorem blockchain** (np. Ethereum lub Hyperledger), aby kryptograficznie zabezpieczyć każdą transakcję linii danych. |

---

## 5. Bezpieczeństwo i kwestie zgodności

1. **Zarządzanie kluczami API** – Przechowuj `FORMIZE_API_KEY` w menedżerach sekretów (GitHub Secrets, Azure Key Vault). Rotuj klucze co kwartał.  
2. **Minimalizacja danych** – Przesyłaj do Formize wyłącznie **metadane** (hashe, schemat, znaczniki czasu); nigdy surowe PII.  
3. **Szyfrowanie w tranzycie** – Wszystkie endpointy Formize wymuszają TLS 1.3.  
4. **Polityki retencji** – Skonfiguruj Formize tak, aby usuwał linię danych starszą niż przyjęte w organizacji okno retencji, zgodnie z [GDPR](https://gdpr.eu/)'s „right to be forgotten”.

---

## 6. Przyszłość stosu zarządzania

- **Generowanie polityk wspomagane AI**: Wykorzystaj modele LLM do proponowania nowych reguł na podstawie wykrytych wzorców dryfu danych.  
- **Architektura zdarzeniowa**: Zastąp wywołania HTTP tematami Kafka (`lineage.events`, `policy.violations`) dla ultra‑niskiej latencji.  
- **Portale samoobsługowe**: Umożliw data scientistom wnioskowanie o tymczasowe wyjątki od polityk poprzez UI napędzane Formize, z automatycznym workflow zatwierdzania.

---

## 7. Podsumowanie

Wbudowanie Formize w pipeline'y CI/CD MLOps przekształca zarządzanie danymi z **reaktywnego punktu kontrolnego** w **ciągły, zautomatyzowany mechanizm ochronny**. Dzięki rejestrowaniu linii danych na każdym etapie, ocenie polityk‑jako‑kod oraz udostępnianiu metryk w czasie rzeczywistym, organizacje mogą:

- Zmniejszyć ryzyko niezgodności i nakład pracy audytowej.  
- Przyspieszyć dostarczanie modeli bez utraty jakości danych.  
- Zapewnić przejrzyste, audytowalne ścieżki dla regulatorów i wewnętrznych audytorów.

Rozpocznij od jednego pipeline'u, iteruj definicje polityk i skaluj horyzontalnie. Efektem będzie odporna, godna zaufania platforma dostarczania AI, nadążająca za nowoczesną prędkością rozwoju.