
# Integracija AI‑pogonene usklađenosti u CI/CD radne tokove

U današnjem hiper‑konkurentnom SaaS okruženju, **brzina** i **povjerenje** više nisu odvojeni ciljevi—moraju koegzistirati. Timovi za razvoj isporučuju kod više puta dnevno, dok se timovima za sigurnost i usklađenost i dalje traži da proizvedu opsežnu revizijsku dokumentaciju nakon svakog većeg izdanja. Nastali trenje stvara uska grla, odgađa prodaju i povećava rizik od neusklađenosti.

Upoznajte **Procurize**, AI‑pogonenu platformu koja centralizira sigurnosne upitnike, dokumente politika i dokaze usklađenosti. Dok mnogi klijenti već koriste Procurize za automatizaciju odgovora na vanjske revizije, nova granica se pojavila: **ugradnja te automatizacije izravno u vaše CI/CD (Continuous Integration / Continuous Deployment) pipelineove**. Tretiranjem usklađenosti kao koda i iskorištavanjem AI pomoći u stvarnom vremenu, organizacije mogu postići **kontinuiranu sigurnosnu garanciju**—na isti način na koji već ostvaruju kontinuiranu isporuku.

Ovaj članak objašnjava zašto je integracija automatizacije usklađenosti u CI/CD važna, opisuje arhitektonske obrasce koji to omogućuju i pruža detaljan vodič korak po korak s primjercima koda. Bilo da ste **DevSecOps** voditelj, **CISO** ili produkt menadžer, dobit ćete praktičnu mapu puta koja usklađenost pretvara iz popisa provjera nakon izdanja u **stalni zaštitni mehanizam**.

---

## Zašto je tradicionalna usklađenost usporavajući faktor

| Tradicionalni pristup | AI‑integrirani CI/CD |
|-----------------------|----------------------|
| Ručno ispunjavanje upitnika nakon izdanja | Automatizirani, politikama vođeni odgovori generirani tijekom gradnje |
| Ažuriranja središnjeg repozitorija kvartalno | Ažuriranja politika u stvarnom vremenu propagiraju se odmah |
| Revizori traže dokaze tjednima nakon izdanja | Dokazi se prilažu svakom artefaktu builda |
| Tim za usklađenost djeluje kao čuvar, usporava isporuku | Usklađenost postaje zajednička odgovornost ugradnja u pipeline |

**Ključne bolne točke**:

1. **Latencija** – Dokazi sigurnosti često se proizvode tjednima nakon izdanja, povećavajući šansu za regresiju.  
2. **Ljudska pogreška** – Ručno prepisivanje odgovora na politike dovodi do nedosljednosti.  
3. **Dupliciranje** – Timovi održavaju odvojene dokumente politika za revizije i za internu upotrebu.  
4. **Nedostatak vidljivosti** – Inženjeri rijetko vide status usklađenosti sve dok se ne pojavi zahtjev za reviziju.

Premještanjem usklađenosti u CI/CD tok, ublažavate ove probleme i pretvarate usklađenost u **prediktivnu, podatkovno‑vođenu funkciju**.

---

## Osnovni pojmovi: Politika kao kod, AI‑generirani odgovori i dokazi kao artefakti

1. **Politika kao kod** – Pohranite svoje sigurnosne politike (npr. **[SOC 2](https://secureframe.com/hub/soc-2/what-is-soc-2/)**, **[ISO 27001](https://www.iso.org/standard/27001)**, **[GDPR](https://gdpr.eu/)**) u repozitorij pod verzioniranjem (npr. Git). Svaka politika je izražena u strojno čitljivom formatu (YAML/JSON) koji alati mogu parsirati.  

2. **AI‑generirani odgovori** – Procurize‑ov LLM motor može "pročitati" definicije politika i automatski generirati sažete, revizijski spremne odgovore na upitnike. AI također ocjenjuje razinu povjerenja, označavajući gdje je još potrebna ljudska revizija.  

3. **Dokazi‑artefakti** – Kao dio builda, pipeline proizvodi nepromjenjive dokaze (npr. snimke konfiguracija, zapise pristupa, izvještaje testova). Procurize povezuje te artefakte s generiranim odgovorima, stvarajući **jedinstveni izvor istine** za revizore.

Zajedno, ove tri razine čine **povratnu petlju kontinuirane usklađenosti**:

```
git push → CI pipeline → AI answer generation → Evidence attachment → Compliance dashboard update
```

---

## Arhitektonska shema

```mermaid
graph LR
    A[Developer commits code] --> B["CI Server (Jenkins/GitHub Actions)"]
    B --> C["Policy Repository (Git)"]
    B --> D["Build & Test Stage"]
    D --> E["Generate Evidence Artifacts"]
    C --> F["Procurize Policy Engine (API)"]
    E --> G["Procurize AI Answer Service (API)"]
    F --> G
    G --> H[Compliance Metadata Store]
    H --> I[Compliance Dashboard / Auditors]
    style A fill:#f9f,stroke:#333,stroke-width:2px
    style I fill:#bbf,stroke:#333,stroke-width:2px
```

**Komponente**:

- **Policy Repository** – Centralni Git repozitorij s definicijama politika (`policies/` folder).  
- **CI Server** – Pokreće build, test, statičku analizu i aktivira korake usklađenosti.  
- **Evidence Generator** – Skripte koje izlučuju JSON/YAML dokaze (npr. `evidence/aws-iam.json`).  
- **Procurize API** – Dva krajnja točka:  
  - `/policies` za učitavanje ili dohvaćanje najnovijeg skupa politika.  
  - `/answers` za slanje dokaza i primanje AI‑generiranih odgovora.  
- **Compliance Metadata Store** – Lagana baza (npr. DynamoDB) koja bilježi status usklađenosti svakog builda.  
- **Dashboard** – Postojeći Procurize UI ili prilagođeni prikaz koji pokazuje usklađenost po izdanju.

---

## Vodič korak po korak

### 1. Pripremite svoj repozitorij politika

Kreirajte Git repozitorij (ili sub‑modul) koji pohranjuje svaku usklađenost kao YAML datoteku.

```yaml
# policies/soc2.yaml
framework: SOC 2
controls:
  - id: CC6.1
    description: "Encryption of data at rest"
    requirement: "All production data must be encrypted using AES‑256."
    evidence_type: "Encryption Configuration"
  - id: CC6.2
    description: "Encryption of data in transit"
    requirement: "TLS 1.2+ must be enforced for all external communication."
    evidence_type: "TLS Configuration"
```

Commitajte repozitorij i zaštitite `main` granu; samo tim za usklađenost smije spajati promjene. Programeri povlače najnovije politike kao dio pipelinea.

### 2. Dodajte CI fazu za prikupljanje dokaza

U vašoj CI konfiguraciji (primjer za GitHub Actions) dodajte posao koji se izvršava nakon testova.

```yaml
name: CI
on:
  push:
    branches: [main]

jobs:
  build-and-test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Run unit tests
        run: npm test

  collect-evidence:
    needs: build-and-test
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Export AWS IAM policy snapshot
        run: |
          aws iam get-account-authorization-details > evidence/aws-iam.json
      - name: Export TLS config
        run: |
          grep -i 'tls' /etc/nginx/nginx.conf > evidence/tls-config.txt
      - name: Upload evidence as artifact
        uses: actions/upload-artifact@v3
        with:
          name: compliance-evidence
          path: evidence/
```

Posao kreira mapu `evidence/` s JSON ili tekst datotekama koje zadovoljavaju `evidence_type` definiran u politikama.

### 3. Pozovite Procurize AI Answer Service

Napravite mali skript (`procurize-submit.sh`) koji čita dokaze, poziva Procurize API i zapisuje AI‑generirane odgovore u JSON datoteku.

```bash
#!/usr/bin/env bash
set -euo pipefail

API_KEY="${PROCURIZE_API_KEY}"
POLICY_REPO="https://github.com/yourorg/compliance-policies.git"
EVIDENCE_DIR="evidence"

# Fetch latest policies (optional if policies are already checked out)
git clone "$POLICY_REPO" policies_tmp
tar -czf policies.tar.gz -C policies_tmp .

# Call Procurize answer API
curl -s -X POST "https://api.procurize.com/v1/answers" \
  -H "Authorization: Bearer $API_KEY" \
  -F "policies=@policies.tar.gz" \
  -F "evidence=@${EVIDENCE_DIR}" \
  -o answers.json

# Store answers as CI artifact for later stages
jq . answers.json > compliance/answers-${GITHUB_SHA}.json
```

Dodajte novi CI korak koji izvršava ovaj skript i učitava `answers-*.json` kao artefakt.

```yaml
  generate-answers:
    needs: collect-evidence
    runs-on: ubuntu-latest
    env:
      PROCURIZE_API_KEY: ${{ secrets.PROCURIZE_API_KEY }}
    steps:
      - uses: actions/checkout@v3
      - name: Download evidence artifact
        uses: actions/download-artifact@v3
        with:
          name: compliance-evidence
          path: evidence/
      - name: Run Procurize submission script
        run: ./procurize-submit.sh
      - name: Upload answers artifact
        uses: actions/upload-artifact@v3
        with:
          name: compliance-answers
          path: compliance/
```

### 4. Sačuvajte metapodatke usklađenosti

Postavite laganu Lambda (ili serverless funkciju) koja se aktivira na događaj upload‑a artefakta, parsira `answers.json` i zapisuje zapis u DynamoDB:

```python
import json, boto3, os

ddb = boto3.resource('dynamodb')
table = ddb.Table(os.getenv('COMPLIANCE_TABLE'))

def handler(event, context):
    # Assume S3 event with object key of answers JSON
    s3 = boto3.client('s3')
    bucket = event['Records'][0]['s3']['bucket']['name']
    key = event['Records'][0]['s3']['object']['key']
    obj = s3.get_object(Bucket=bucket, Key=key)
    answers = json.loads(obj['Body'].read())

    record = {
        'build_id': answers['metadata']['build_id'],
        'status': 'COMPLIANT' if answers['overall_confidence'] > 0.9 else 'REVIEW_NEEDED',
        'timestamp': answers['metadata']['timestamp'],
        'summary': answers['summary']
    }
    table.put_item(Item=record)
    return {'statusCode': 200}
```

Sada svaki build ima odgovarajući unos usklađenosti vidljiv na Procurize‑ovom dashboardu ili bilo kojem prilagođenom UI‑ju.

### 5. Provedite gate‑ove (opcionalno)

Ako želite da pipeline **ne uspije** kada je povjerenje nisko, dodajte završnu fazu koja provjerava DynamoDB i zaustavlja build ako je status `REVIEW_NEEDED`.

```yaml
  compliance-gate:
    needs: generate-answers
    runs-on: ubuntu-latest
    steps:
      - name: Check compliance status
        run: |
          STATUS=$(aws dynamodb get-item \
            --table-name ${{ secrets.COMPLIANCE_TABLE }} \
            --key '{"build_id": {"S": "${{ github.sha }}"}}' \
            --query 'Item.status.S')
          if [[ "$STATUS" != "COMPLIANT" ]]; then
            echo "Compliance gate failed: $STATUS"
            exit 1
          fi
```

Kad gate prođe, artefakt se nastavlja prema produkciji. Ako ne, programeri odmah dobivaju povratnu informaciju i mogu otkloniti praznine u politici prije nego što se izdanje pošalje.

---

## Ostvarene prednosti

| Metrika | Tradicionalni proces | Integrirani CI/CD proces |
|---------|----------------------|--------------------------|
| Prosjek vremena za popunjavanje upitnika | 10–14 dana | 2–4 sata |
| Ručni rad (osoba‑sati) po izdanju | 12–20 sati | ≤ 2 sata (većinom revizija) |
| Potpunost revizijskih dokaza | 70‑80 % | 95‑100 % |
| Učestalost blokadera uzrokovanih usklađenošću | 1 po sprintu | < 0.1 po sprintu |

Osim brzine, integracija **smanjuje rizik** jer svaki commit evaluira najnoviji skup politika, i **poboljšava auditabilnost** putem nepromjenjivih dokaza povezanih s svakim buildom.

---

## Uobičajene zamke i kako ih izbjeći

1. **Zastarijela keširana politika** – Osigurajte da CI posao uvijek povlači najnoviji repozitorij politika. Koristite lock‑file ili checksum za provjeru svježine.  
2. **Pretjerana ovisnost o AI‑ju** – Postavite AI uslugu da označi odgovore ispod praga povjerenja (npr. 85 %). Ljudski revizori moraju zatvoriti te praznine.  
3. **Eksplozija veličine dokaza** – Pohranite dokaze u komprimirane arhive i čistite starije artefakte prema retenzijskom periodu određenom vašim okvirom usklađenosti.  
4. **Sigurnost API ključeva** – Čuvajte Procurize vjerodajnice u spremištu tajni CI‑ja (npr. GitHub Secrets, Azure Key Vault). Redovito rotirajte ključeve.

---

## Proširivanje obrasca: od CI do CD upravljanja

Kada je usklađenost ugrađena u **CI**, možete isti pristup proširiti na **CD** (implementaciju) i **runtime** nadzor:

- **Validacija politika pri implementaciji** – Prije puštanja Helm charta, pokrenite provjeru politike‑kao‑kod koja evaluira Kubernetes RBAC, mrežne politike i upravljanje tajnama protiv istih YAML definicija koje se koriste u fazi izgradnje.  
- **Streaming runtime dokaza** – Upotrijebite agente (npr. Falco, OpenTelemetry) za kontinuirano slanje sigurnosnih događaja u Procurize‑ov spremnik dokaza, zatvarajući petlju za *kontinuiranu* usklađenost.  
- **Portal samoposluživanja usklađenosti** – Omogućite čitanje dashboarda usklađenosti vašim klijentima, pretvarajući usklađenost u tržišnu prednost.

---

## TL;DR

- Pohranite sve sigurnosne politike u Git kao **politiku‑kao‑kod** (YAML/JSON).  
- Dodajte CI korake koji **prikupljaju nepromjenjive dokaze** i šalju ih Procurize‑ovom **API‑ju za AI odgovore**.  
- Sačuvajte AI‑generirane odgovore i ocjene povjerenja u metapodatkovnu bazu.  
- Koristite **compliance gate** da blokirate izdanja koja ne zadovoljavaju pragu povjerenja.  
- Postignite gotovo real‑time spremnost za reviziju, smanjite ručni rad i ubrzajte vrijeme izlaska na tržište.  

Ugradnjom Procurize‑ove AI‑pogonene platforme u vaš CI/CD tok, usklađenost prelazi iz periodičnog kontrolnog popisa u **kontinuiranu, automatiziranu zaštitu**—kao što moderni DevOps tretira testiranje, sigurnost i observability.  

---

## Pogledajte i

- [NIST CSF Integracija s CI/CD pipelineovima (NIST SP 800‑53)](https://csrc.nist.gov/publications/detail/sp/800-53/rev-5/final)  
- [GitHub Actions za sigurne softverske lančane opskrbe](https://github.com/github/securitylab)  
- [Microsoft Azure Policy as Code vodič](https://learn.microsoft.com/azure/governance/policy/)