
# AI‑põhine vastavuse integreerimine CI/CD töövoogudesse

Tänapäeva hüperkonkurentses SaaS‑maastikus ei ole enam **kiirus** ja **usaldusväärsus** eraldiseisvad eesmärgid — need peavad eksisteerima koos. Arendusmeeskonnad saadavad koodi mitu korda päevas, samas kui turva‑ ja vastavusmeeskonnad palutakse siiski koostada põhjalikud auditi tõendid iga suurema väljalaske järel. Tekkinud hõõrdumine tekitab kitsaskohti, viivitab tehinguid ja suurendab mitte‑vastavuse riski.

Tutvuge **Procurize’iga**, AI‑põhise platvormiga, mis koondab turvaküsimustikud, poliitikadokumendid ja vastavust tõendavad materjalid. Kuigi paljud kliendid kasutavad Procurize’i juba väliste auditide vastuste automatiseerimiseks, tekib uus võimalus: **selle automatiseerimise otse integreerimine teie CI/CD (Järjepidev Integreerimine / Järjepidev Käivitamine) torujuhtmetesse**. Koheldes vastavust koodina ja kasutades reaalajas AI‑abi, saavad organisatsioonid saavutada **pideva turvakindluse** — samamoodi, nagu nad juba saavutavad pidevat tarnet.

See artikkel selgitab, miks vastavuse automatiseerimise integreerimine CI/CD‑sse oluline on, kirjeldab arhitektuurilisi mustreid, mis selle võimaldavad, ning pakub samm‑sammult rakendusjuhendit koos koodinäidetega. Olenemata sellest, kas olete **DevSecOps** juht, **CISO**, või tootejuht, saate praktilise teekaardi, kuidas muuta vastavus post‑väljalaske kontrollnimekirjast **alati‑sisse lülitatavaks kaitse‑rajal**.

## Miks traditsiooniline vastavus on kitsaskoht

| Traditsiooniline lähenemine | AI‑integreeritud CI/CD |
|-----------------------------|------------------------|
| Käsitsi küsimustiku täitmine pärast väljalaset | Automaatilised, poliitikapõhised vastused genereeritud ehituse ajal |
| Keskusrepo ajakohastamisperiood kvartali kaupa | Reaalajas poliitika uuendused levivad kohe |
| Audiitorid nõuavad tõendeid nädalaid pärast väljalaset | Tõendifailid lisatakse igale ehitusartefaktile |
| Vastavusmeeskond toimib väravavaotjatena, aeglustades tarnet | Vastavus muutub ühiskohustuslikuks, sisseehitatud torujuhtmesse |

**Peamised probleempunktid**:

1. **Viivitus** – Turvatõendid toodetakse tihti nädalaid pärast väljalaset, suurendades regressiooni tõenäosust.  
2. **Inimviga** – Käsitsi poliitikavastuste transkribeerimine põhjustab ebakõlasid.  
3. **Topeltkirjutus** – Meeskonnad haldavad eraldi poliitikat dokumente auditite ja sisekasutuse jaoks.  
4. **Nähtavuse puudumine** – Insenerid näevad vastavuse olekut harva, enne kui audititaotlus ilmneb.  

Vastavuse liigutamine CI/CD‑voogu aitab need probleemid leevendada, muutes vastavuse **ennustatavaks, andmete‑põhiseks funktsiooniks**.

## Põhimõtted: Poliitika koodina, AI‑genereeritud vastused ja tõendid artefaktidena

1. **Poliitika koodina** – Salvestage oma turvapoliitikad (nt **[SOC 2](https://secureframe.com/hub/soc-2/what-is-soc-2)**, **[ISO 27001](https://www.iso.org/standard/27001)**, **[GDPR](https://gdpr.eu/)** jne) versioonikontrollitud repos (nt Git). Iga poliitika on väljendatud masinloetavas formaadis (YAML/JSON), mida tööriistad saavad parsida.  

2. **AI‑genereeritud vastused** – Procurize’i suurkeelemodell (LLM) suudab töödelda poliitikade määratlusi ja automaatselt genereerida lühikesed, auditi‑valmis vastused küsimustiku üksustele. AI hindab ka usaldustasemeid, näidates, kus on ikka vaja inimese ülevaatust.  

3. **Tõendiartefaktid** – Ehitusprotsessi käigus toodetakse muutumatuid tõendeid (nt konfiguratsioonisnapshotid, juurdepääsulogid, testiraportid). Procurize lingib need artefaktid genereeritud vastustega, luues **ühte tõeallikat** auditoritele.  

Koos moodustavad need kolm kihti **pideva vastavuse tagasisilmitsõlme**:

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

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

**Komponendid**:

- **Poliitikarepositoorium** — Keskne Git-repos, kus on poliitikade määratlused (`policies/` kaust).
- **CI server** — Käivitab ehituse, testimise, staatilise analüüsi ja käivitab vastavusetapid.
- **Tõendi generaator** — Skriptid, mis loovad JSON/YAML tõendeid (nt `evidence/aws-iam.json`).
- **Procurize API** — Kaks lõpp-punkti:
  - `/policies` poliitikakomplekti üleslaadimiseks või tõmbamiseks.
  - `/answers` tõendite esitamiseks ja AI‑genereeritud küsimustikuvastuste saamiseks.
- **Vastavuse metaandmete pood** — Kerge andmebaas (nt DynamoDB), mis salvestab iga ehituse vastavuse seisundi.
- **Armatuurlaud** — Olemasolev Procurize UI või kohandatud vaade, mis näitab vastavust iga väljalaske kohta.

## Samm‑sammuline rakendusjuhend

### 1. Valmistage oma poliitikarepositoorium ette

Loo Git‑repo (või alammodul), kuhu salvestad iga vastavusraamistiku YAML‑faili.

```yaml
# policies/soc2.yaml
framework: SOC 2
controls:
  - id: CC6.1
    description: "Andmete krüpteerimine puhkeandmetel"
    requirement: "Kõik tootmisandmed tuleb krüpteerida kasutades AES‑256."
    evidence_type: "Krüpteerimise konfiguratsioon"
  - id: CC6.2
    description: "Andmete krüpteerimine liikumisel"
    requirement: "TLS 1.2+ peab olema sunditud kogu välise suhtluse puhul."
    evidence_type: "TLS konfiguratsioon"
```

Kinnita repo ning kaitse `main` haru; ainult vastavusmeeskond võib teha muudatusi. Arendajad tõmbavad poliitikad torujuhtme käigus.

### 2. Lisage CI‑etapp tõendite kogumiseks

GitHub Actions näide, mis käivitub testimise järel.

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

Etapp loob `evidence/` kausta, mis rahuldab poliitikate `evidence_type` nõudeid.

### 3. Kutsuge Procurize AI vastuste teenus

Loo väike skript (`procurize-submit.sh`), mis loeb tõendeid, kutsub API‑d ja kirjutab AI‑genereeritud vastused JSON‑i.

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

# API võti keskkonnamuutujast
API_KEY="${PROCURIZE_API_KEY}"
# Poliitikareposi URL
POLICY_REPO="https://github.com/yourorg/compliance-policies.git"
EVIDENCE_DIR="evidence"

# (Valikuline) tõmba värskeimad poliitikad, kui need pole juba kohal
git clone "$POLICY_REPO" policies_tmp
tar -czf policies.tar.gz -C policies_tmp .

# Kutsu Procurize vastuste API-d
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

# Salvesta vastused CI‑artefaktiks
jq . answers.json > compliance/answers-${GITHUB_SHA}.json
```

Lisage CI‑samm, mis käivitab skripti ja laeb `answers-*.json` artefaktina üles.

```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. Salvestage vastavuse metaandmed

Paigaldage kerge Lambda (või muu serverless funktsioon), mis käivitub artefakti üleslaadimise sündmusel, loeb `answers.json` ja kirjutab kirje DynamoDB‑sse.

```python
import json, boto3, os

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

def handler(event, context):
    # Sündmus eeldab S3 objekti signaali
    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}
```

Nüüd on igal ehitusel vastavuse kirje, mida saab näha Procurize’i armatuurlaudades või oma kohandatud UI‑s.

### 5. Jõustage väravad (valikuline)

Kui soovite, et torujuhtme **ebaõnnestuks**, kui usaldustase on madal, lisage lõplik etapp, mis kontrollib DynamoDB kirjet ja katkestab koostöö.

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

Kui värav läbib, liigub artefakt tootmiskeskkonda. Kui see ebaõnnestub, saavad arendajad viivitamatult teada ja saavad enne väljalaske tegemist poliitika lünki parandada.

## Saavutatud eelised

| Mõõdik | Traditsiooniline protsess | Integreeritud CI/CD protsess |
|--------|---------------------------|------------------------------|
| Keskmine küsimustiku läbivaatamise aeg | 10–14 päeva | 2–4 tundi |
| Käsitsi töö (tunnid) ühe väljalaske kohta | 12–20 tundi | ≤ 2 tundi (peamiselt ülevaatus) |
| Auditi tõendite täielikkus | 70‑80 % | 95‑100 % |
| Vastavusega seotud väljalaske takistuste sagedus | 1 sprinti kohta | < 0,1 sprinti kohta |

Lisaks kiirusele vähendab integratsioon **riskide** hajutamist, tagades, et iga commit hinnatakse viimaste poliitikate vastu, ning **parandab auditeeritavust** läbi muutumatute tõendite linkimise igale ehitusele.

## Levinud takistused ja kuidas neid vältida

1. **Vananenud poliitikaklassi vahemälu** — Veenduge, et CI‑töö võtaks alati värskeima poliitikarepositooriumi.  
2. **Liigne sõltuvus AI‑st** — Konfigureerige AI‑teenus tähistama kõiki vastuseid, mis on usaldustaseme all (nt 85 %).  
3. **Tõendite suuruse plahvatus** — Säilitage tõendid pakkitud arhiivides ja kustutage vanemad artefaktid pärast säilitamisperioodi, mida määrab teie vastavusraamistik.  
4. **API‑võtmete turvalisus** — Hoidke Procurize'i mandaate oma CI saladustehoidlasse (nt GitHub Secrets, Azure Key Vault). Vahetage need regulaarselt.

## Mustri laiendamine: CI‑st CD‑valitsemiseni

Kui vastavus on **CI‑s** sisseehitatud, saate sama kaitse **CD‑sse** laiendada:

- **Deploy‑taseme poliitika kontroll** — Enne Helm‑chart’i kasutuselevõttu käivitage reegel‑kood kontroll, mis valideerib Kubernetes RBAC‑i, võrgupoliitikad ja salvestatud saladused vastavalt samadele YAML‑definitsioonidele, mida kasutati ehituse ajal.  
- **Reaalajas tõendite voog** — Kasutage agente (nt Falco, OpenTelemetry), et pidevalt suunata turvaeventid Procurize'i tõendite poodi, sulandades nii **pideva** vastavuse.  
- **Ise‑teenindusvastavuse portaali** — Avaldage klientidele lugemisõigusega vaade vastavusarmatuurlaudale, muutes oma vastavuspositsiooni turunduslikuks eeliskäiksiks.

## TL;DR

- Salvestage kõik turvapoliitikad Giti, kasutades **policy‑as‑code** formaati (YAML/JSON).  
- Lisage CI‑etapid, mis **koguvad muutumatuid tõendeid** ja saadavad need Procurize’i **AI‑vastuse API‑le**.  
- Salvestage AI‑genereeritud vastused ja usaldustasemed metaandmete poesse.  
- Kasutage **vastavusväravat**, et blokeerida väljalasked, mis ei vasta usaldustaseme künnistele.  
- Saate peaaegu reaalajas auditi valmisoleku, vähendate käsitsi tööd ja kiirendate turuletoomist.  

Integreerides Procurize’i AI‑põhise vastavusplatvormi oma CI/CD‑töövoogu, muudate vastavuse perioodilised kontrollpunktid **pidevaks, automatiseeritud kaitseks** — samamoodi nagu kaasaegne DevOps käsitleb testimist, turvalisust ja jälgitavust.

## Vaata veel

- NIST CSF integreerimine CI/CD torujuhtmetesse (NIST SP 800‑53)  
- GitHub Actions turvalise tarkvaratarneahela jaoks  
- Microsoft Azure Policy as Code juhend