# Nuolatinė duomenų valdymas MLOps konvejeriuose su Formize

Įmonės, kurios didelėmis apimtimis pristato mašininio mokymosi modelius, susiduria su paradoksu: kuo greičiau jos iteruoja, tuo sunkiau užtikrinti, kad mokymo, validacijos ir inferencijos duomenys atitiktų vidines politikos nuostatas ir išorinius reglamentus. Tradiciniai duomenų valdymo metodai – rankiniai auditai, periodinės ataskaitos ir statiškos kilmės diagramos – negali sekmadienio greičio šiuolaikinių MLOps darbo srautų.

Formize, žemo kodo duomenų kilmės ir atitikties variklis, sukurtas būtent šiai iššūkiui. Įterpdami Formize į CI/CD konvejerį, organizacijos gali **fiksuoti kilmės duomenis realiu laiku**, **įgyvendinti politiką kaip kodą** ir **pateikti kokybės skydelius**, kuriuos kūrėjai ir auditoriai gali iš karto peržiūrėti.

Šiame straipsnyje mes:

1. Apžvelgsime pagrindines nuolatinio duomenų valdymo koncepcijas.  
2. Parodysime, kaip Formize integruojamas su populiariausiomis MLOps priemonėmis (GitHub Actions, Jenkins, Kubeflow, MLflow).  
3. Peržvelgsime visą galutinį įgyvendinimą – nuo šaltinio kontrolės kablių iki automatizuotų atitikties patikrinimų.  
4. Pateiksime Mermaid diagramą, kuri vizualizuoja duomenų srautą.  
5. Aptarsime mastelio didinimo, saugumo ir ateities perspektyvas.

> **Svarbiausia išvada:** Kai Formize tampa natūraliu jūsų CI/CD konvejerio žingsniu, duomenų kilmės sekimas, politikos įgyvendinimas ir kokybės stebėjimas tampa *nuolatiniais* vietoj *periodinių* veiklų.

---

## 1. Kodėl svarbus nuolatinis valdymas

| Tradicinis požiūris | Nuolatinis požiūris |
|----------------------|----------------------|
| Auditai atliekami kas ketvirtį arba po pažeidimo | Auditai atliekami kiekviename commit’e, build’e ir deploy’e |
| Rankinės kilmės diagramos yra pasenusios | Automatizuotos kilmės grafikos atspindi tiesioginę būseną |
| Politikos pažeidimai aptinkami vėlai, brangu juos taisyti | Politikos pažeidimai iš karto blokuoja konvejerį |
| Ribotas matomumas ne‑techniniams suinteresuotiems asmenims | Realiojo laiko skydeliai suteikia įgaliojimus duomenų prižiūrėtojams ir auditoriams |

Perėjimas nuo **periodiško** prie **nuolatinio** atspindi evoliuciją nuo Waterfall iki DevOps. Kaip automatizuoti testai anksti aptinka kodo klaidas, taip automatizuotas valdymas anksti aptinka duomenų trūkumus.

---

## 2. Pagrindiniai komponentai

1. **Formize variklis** – suteikia API kilmės duomenų fiksavimui, politikos apibrėžimui ir audito takelio saugojimui.  
2. **MLOps orkestratorius** – Jenkins, GitHub Actions, Azure Pipelines arba Kubeflow pipelines, kurie valdo modelio mokymą ir diegimą.  
3. **Artefaktų saugykla** – S3, Azure Blob arba GCS, kur saugomi duomenų rinkiniai, modelio binariniai failai ir feature store.  
4. **Politika kaip kodas** – YAML/JSON taisyklės, koduojančios GDPR, HIPAA arba vidines duomenų naudojimo politikas.  
5. **Stebimumo sluoksnis** – Grafana/Prometheus skydeliai, kurie rodo Formize metrikas.

Visi komponentai bendrauja per **RESTful** galinius taškus arba **įvykių srautus** (Kafka, Pub/Sub). Žemiau pateikta Mermaid diagrama iliustruoja duomenų srautą.

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

*Visi mazgo pavadinimai yra įdėti į dvigubas kabutes, kaip reikalauja Mermaid.*

---

## 3. Žingsnis po žingsnio integracija

### 3.1. Apibrėžkite politiką kaip kodą

Sukurkite `policies.yaml` failą projekto šakniniame kataloge:

```yaml
policies:
  - id: "PII-001"
    description: "Jokie PII laukai negali būti naudojami mokyme be aiškaus sutikimo"
    condition: "dataset.contains('ssn') or dataset.contains('email')"
    action: "block"
    severity: "high"

  - id: "DATA-RETENTION-01"
    description: "Mokymo duomenys, senesni nei 5 metai, turi būti archyvuojami"
    condition: "dataset.age > 5y"
    action: "warn"
    severity: "medium"
```

Formize perskaito šį failą **Kilmės fiksavimo** žingsnyje ir įvertina kiekvieną taisyklę prieš gaunamus duomenų rinkinio metaduomenis.

### 3.2. Pridėkite Formize kablį (hook) į konvejerį

Žemiau pateiktas GitHub Actions fragmentas, kuris vykdomas po mokymo darbo pabaigos:

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

Jei bet kuri politika grąžina `block`, žingsnis baigiasi su ne‑nulinėmis išėjimo būsenomis, todėl visas darbas nepavyksta. Šis **fail‑fast** elgesys garantuoja, kad nesuderinami duomenys niekada nepateks į gamybą.

### 3.3. Saugojimas kilmės duomenų centrinėje grafo struktūroje

Formize automatiškai įrašo nukreiptą aciklinį grafą (DAG) į savo vidinį Neo4j saugyklą. Jį galite užklausti naudojant 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;
```

Rezultatas gali būti vizualizuojamas Formize UI arba eksportuojamas į Grafana, kad sukurtumėte pritaikytus skydelius.

### 3.4. Realiojo laiko skydelis

Sukurkite Prometheus eksportuotoją, kuris surenka Formize metrikas:

```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 dabar gali braižyti `formize_policy_violations_total` pagal konvejerį, suteikdama duomenų prižiūrėtojams momentinį matomumą.

---

## 4. Valdymo sluoksnio mastelio didinimas

| Iššūkis | Rekomenduojamas sprendimas |
|-----------|----------------------|
| **Didelio dažnio konvejeriai** (šimtai vykdymų per dieną) | Diegti Formize **klasteriuota** veiksena už apkrovos balansatoriaus; įjungti **paketų įkėlimą** kilmės įvykių. |
| **Daugialypės debesų duomenų šaltiniai** | Naudoti Formize **debesis nepriklausomus jungiklius** (S3, Azure Blob, GCS) ir konfigūruoti vieningą **resursų identifikatorių** schemą. |
| **Kryžminės komandos politikos nuosavybė** | Pasinaudoti Formize **rolės pagrindu paremtos prieigos kontrolės (RBAC)**, kad kiekviena domenų komanda valdytų savo politikos failus, o centrinė komanda prižiūrėtų variklį. |
| **Audito takelio nekeičiama** | Susieti Formize su **blokų grandinės inkaru** (pvz., Ethereum arba Hyperledger), kad kriptografiškai užsirašytų kiekvieną kilmės transakciją. |

---

## 5. Saugumo ir atitikties svarstymai

1. **API raktų valdymas** – `FORMIZE_API_KEY` saugokite paslėptų saugyklų (GitHub Secrets, Azure Key Vault) pagalba. Raktus keiskite kas ketvirtį.  
2. **Duomenų minimizavimas** – Formize siųskite tik **metaduomenis** (maišos, schemą, laiko žymas); niekada neperduokite neapdorotų PII duomenų.  
3. **Šifravimas per transportą** – Visi Formize galiniai taškai priverstinai naudoja TLS 1.3.  
4. **Saugojimo politikos** – Nustatykite Formize ištrinti kilmės duomenis, senesnius nei organizacijos saugojimo laiko langas, atitinkantį [GDPR](https://gdpr.eu/) „teisę būti pamirštam“.

---

## 6. Ateities pasiruošimas jūsų valdymo sistemai

- **AI‑pagrįstas politikų generavimas**: naudokite LLM, kad pasiūlytų naujas politikos taisykles pagal stebimą duomenų nuokrypį.  
- **Įvykių valdomas architektūra**: pakeiskite HTTP kvietimus Kafka temomis (`lineage.events`, `policy.violations`) ultra‑mažam vėlavimui.  
- **Savarankiški portalai**: suteikite duomenų mokslininkams galimybę prašyti laikinų politikos išimčių per Formize valdomą UI, su automatizuotais patvirtinimo darbo srautais.

---

## 7. Santrauka

Įterpiant Formize į MLOps CI/CD konvejerius, duomenų valdymas transformuojamas iš **reaktyvaus kontrolės taško** į **nuolatinę, automatizuotą apsaugą**. Fiksuodami kilmės duomenis kiekviename etape, vertindami politiką kaip kodą ir pateikdami realiojo laiko metrikas, organizacijos gali:

- Sumažinti atitikties riziką ir auditų pastangų apimtį.  
- Paspartinti modelio pristatymą, neprarandant duomenų kokybės.  
- Suteikti skaidrius, audituojamus takelius regulatoriams ir vidiniams auditoriams.

Pradėkite nuo vieno konvejerio, tobulinkite politikos apibrėžimus ir mastelinkite horizontaliai. Rezultatas – patikima, patikima AI pristatymo platforma, kuri išlaiko žingsnį su šiuolaikiniu kūrimo greičiu.