# Kontinuirano upravljanje podacima u MLOps cjevovodima s Formizeom

Poduzeća koja isporučuju modele strojnog učenja u velikom opsegu suočavaju se s paradoksom: što brže iteriraju, to je teže jamčiti da podaci korišteni za treniranje, validaciju i inferenciju zadovoljavaju interne politike i vanjske regulative. Tradicionalni pristupi upravljanju podacima – ručne revizije, periodični izvještaji i statični dijagrami linije podrijetla – ne mogu pratiti brzinu modernih MLOps radnih tokova.

Formize, low‑code motor za liniju podrijetla podataka i usklađenost, izgrađen je upravo za ovaj izazov. Ugradnjom Formizea u CI/CD cjevovod, organizacije mogu **bilježiti liniju podrijetla u stvarnom vremenu**, **provoditi pravila kao kod**, i **izlagati nadzorne ploče kvalitete** koje developeri i revizori mogu odmah pretraživati.

U ovom članku ćemo:

1. Izložiti osnovne koncepte kontinuiranog upravljanja podacima.  
2. Pokazati kako Formize integrirati s popularnim MLOps alatima (GitHub Actions, Jenkins, Kubeflow, MLflow).  
3. Proći kroz kompletnu implementaciju od hook‑ova u sustavu za kontrolu verzija do automatiziranih provjera usklađenosti.  
4. Prikazati Mermaid dijagram koji vizualizira protok podataka.  
5. Raspraviti skaliranje, sigurnost i buduće osiguranje.

> **Ključna poanta:** Kada Formize postane izvorni korak u vašem CI/CD cjevovodu, linija podrijetla podataka, provođenje pravila i nadzor kvalitete postaju *kontinuirani* umjesto *periodični* aktivnosti.

---

## 1. Zašto je kontinuirano upravljanje važno

| Tradicionalni pristup | Kontinuirani pristup |
|----------------------|----------------------|
| Revizije se provode kvartalno ili nakon incidenta | Revizije se provode pri svakom commitu, izgradnji i implementaciji |
| Ručni dijagrami linije podrijetla su zastarjeli | Automatizirani grafovi linije podrijetla odražavaju stvarno stanje |
| Kršenja pravila otkrivena kasno, skupa za otklanjanje | Kršenja pravila odmah blokiraju cjevovod |
| Ograničena vidljivost za ne‑tehničke dionike | Nadzorne ploče u stvarnom vremenu osnažuju čuvare podataka i revizore |

Prijelaz s **periodičnog** na **kontinuirani** odražava evoluciju od Waterfalla do DevOpsa. Na isti način na koji automatizirani testovi rano otkrivaju greške u kodu, automatizirano upravljanje otkriva greške u podacima rano.

---

## 2. Osnovni gradivni blokovi

1. **Formize Engine** – Pruža API za bilježenje linije podrijetla, definiciju pravila i pohranu revizijskog zapisa.  
2. **MLOps Orchestrator** – Jenkins, GitHub Actions, Azure Pipelines ili Kubeflow cjevovodi koji upravljaju treniranjem i implementacijom modela.  
3. **Artifact Repository** – S3, Azure Blob ili GCS gdje se nalaze skupovi podataka, binarni modeli i spremišta značajki.  
4. **Policy‑as‑Code** – YAML/JSON pravila koja kodiraju GDPR, HIPAA ili interne politike korištenja podataka.  
5. **Observability Layer** – Grafana/Prometheus nadzorne ploče koje prikazuju Formize metrike.

Svi komponenti komuniciraju putem **RESTful endpointa** ili **event streamova** (Kafka, Pub/Sub). Sljedeći Mermaid dijagram prikazuje protok podataka.

```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. Integracija korak po korak

### 3.1. Definirajte Policy‑as‑Code

Stvorite datoteku `policies.yaml` u korijenu repozitorija:

```yaml
policies:
  - id: "PII-001"
    description: "No PII fields may be used in training without explicit consent"
    condition: "dataset.contains('ssn') or dataset.contains('email')"
    action: "block"
    severity: "high"

  - id: "DATA-RETENTION-01"
    description: "Training data older than 5 years must be archived"
    condition: "dataset.age > 5y"
    action: "warn"
    severity: "medium"
```

Formize čita ovu datoteku tijekom koraka **Lineage Capture** i procjenjuje svako pravilo prema metapodacima dolaznog skupa podataka.

### 3.2. Dodajte Formize Hook u cjevovod

Dolje je isječak GitHub Actions koji se izvršava nakon završetka zadatka treniranja:

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

Ako bilo koje pravilo vrati `block`, korak završava s ne‑nultim statusom, što uzrokuje neuspjeh cijelog posla. Ovo **fail‑fast** ponašanje jamči da neusklađeni podaci nikada ne dođu u produkciju.

### 3.3. Pohranite liniju podrijetla u centralni graf

Formize automatski zapisuje usmjereni aciklični graf (DAG) u svoju internu Neo4j pohranu. Možete ga upitati Cypherom:

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

Rezultat se može vizualizirati u Formize UI‑ju ili izvesti u Grafanu za prilagođene nadzorne ploče.

### 3.4. Nadzorna ploča u stvarnom vremenu

Stvorite Prometheus exporter koji prikuplja Formize metrike:

```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 sada može prikazivati `formize_policy_violations_total` po cjevovodu, dajući čuvarima podataka trenutni uvid.

---

## 4. Skaliranje sloja upravljanja

| Izazov | Preporučeno rješenje |
|--------|----------------------|
| **Cjevovodi visoke frekvencije** (stotine pokretanja dnevno) | Implementirajte Formize u **klasteriranom** načinu iza load balancera; omogućite **grupno unos** događaja linije podrijetla. |
| **Višestruki cloud izvori podataka** | Koristite **cloud‑agnostičke konektore** Formizea (S3, Azure Blob, GCS) i konfigurirajte jedinstvenu shemu **identifikatora resursa**. |
| **Vlasništvo pravila preko timova** | Iskoristite **kontrolu pristupa temeljenu na ulogama (RBAC)** Formizea kako bi svaki domen tim posjedovao svoje datoteke pravila, dok centralni tim upravlja motorom. |
| **Neizmjenjivost revizijskog zapisa** | Uparite Formize s **blockchain sidrom** (npr. Ethereum ili Hyperledger) kako biste kriptografski zatvorili svaku transakciju linije podrijetla. |

---

## 5. Razmatranja sigurnosti i usklađenosti

1. **Upravljanje API ključem** – Pohranite `FORMIZE_API_KEY` u upravitelje tajni (GitHub Secrets, Azure Key Vault). Rotirajte ključeve kvartalno.  
2. **Minimizacija podataka** – Šaljite samo **metapodatke** (hashes, shemu, vremenske oznake) Formizeu; nikada ne prenosite sirove PII.  
3. **Šifriranje u prijenosu** – Svi Formize endpointi primjenjuju TLS 1.3.  
4. **Politike zadržavanja** – Konfigurirajte Formize da ukloni liniju podrijetla stariju od perioda zadržavanja organizacije, usklađeno s “pravo na zaborav” iz [GDPR](https://gdpr.eu/).

---

## 6. Buduće osiguranje vašeg sloja upravljanja

- **AI‑pomoć pri generiranju pravila**: Koristite LLM‑ove za predlaganje novih pravila na temelju uočenih obrazaca pomaka podataka.  
- **Arhitektura temeljena na događajima**: Zamijenite HTTP pozive s Kafka temama (`lineage.events`, `policy.violations`) za ultra‑nisku latenciju.  
- **Portali samoposluge**: Omogućite data znanstvenicima da zatraže privremene iznimke pravila putem Formize‑upravljačkog sučelja, s automatiziranim radnim tokovima odobrenja.

---

## 7. Sažetak

Ugradnja Formizea u MLOps CI/CD cjevovode pretvara upravljanje podacima iz **reaktivnog kontrolnog točke** u **kontinuiranu, automatiziranu zaštitu**. Bilježenjem linije podrijetla u svakoj fazi, procjenom policy‑as‑code i prikazivanjem metrika u stvarnom vremenu, organizacije mogu:

- Smanjiti rizik od neusklađenosti i napor revizije.  
- Ubrzati isporuku modela bez žrtvovanja kvalitete podataka.  
- Osigurati transparentne, revizijske tragove za regulatore i interne revizore.

Započnite s jednim cjevovodom, iterirajte definicije pravila i skalirajte horizontalno. Rezultat je otporna, pouzdana platforma za isporuku AI koja prati tempo modernog razvoja.