
# ԱԻ‑ն ռավետված Համաձայնության Ինտեգրումը CI/CD Աշխատակարգերում

Այսօրվա հիդրոշուխժելի SaaS միջավայրը պահանջում է **առաջադիմություն** և **հուսալիություն**՝ այլևս անհամապատասխան նպատակներ, այլ դեռ դառնա գծի միատարածված: Ծրագրավորման թիմերը ծածկով հորինում են կոդը մի քանի անգամ օրինա, իսկ ապահովության և համաձայնության թիմերը դեռ պահանջում են հղել բարդ աուդիտի փաստաթղթեր ամեն մի մեծ ಬಿಡುಗադրման jälkeen: Այս ցանկություն առաջացնում է շունչապակիներ, հետաձգում գործընթացը և աճում շահագրգռված չհամապատասխանության ռիսկը:

Ձեզ հետ է **Procurize**, ԱԻ‑չափված հարթակը, որը կենտրոնացնում է անվտանգության հարցազուգարքերը, քաղաքականության փաստաթղթերը և համաձայնության ապացուցները: Երբ հաճախորդները արդեն օգտագործում են Procurize‑ն՝ ավտոմատացնելից արտաքին ակնառու ճշտերը, նոր եռանդը գլխավորում է՝ **արտադրյալը նույնտեղում տեղադրել ձեր CI/CD (Continuous Integration / Continuous Deployment) գծերում**: Համաձայնությունը համար կոդի համահղողում և իրական ժամանակի ԱԻ‑սպասարկմամբ, կազմակերպությունները կարող են ձեռք բերել **շարունակական ապահովության ապահովում**—ինչպես արդեն անպատճենելիորեն ձեռք են բերել շարունակական թողարկում:

Այս հոդվածը բացատրուում է, թե ինչու է համապատասխանիաթհագործումը CI/CD‑ում կարևոր, նկարագրում է այն ճարտարապետական ձևավորումները, որոնք կատարում են դա, և տրամադրում է քայլ առ քայլ իրականացման ուղեցույց՝ կոդի հատվածներով: Անկախաբար թե դուք **DevSecOps‑ի** ղեկավարն եք, **CISO**‑ն, թե արտադրանքի կառավարիչ, դուք կստանաք գործնական դասարան՝ փոխարինելով համաձայնությունը պոաստ‑հրապարակման միակ պուշակին **ամեն ժամանակ ազատ միջակների**:

---

## Ի՞նչու են ավանդական համաձայնությունները շունչապակին

| Ավանդական մոտեցում | ԱԻ‑ինտուգված CI/CD |
|----------------------|----------------------|
| ձեռքով հարցազուգարքների լրացում թողարկումից հետո | Ավտոմատացված, քաղաքականության վրա հիմնված պատասխաններ կառուցվածքային ժամանակ |
| Կենտրոնացված պահելի թարմացումին կատարվում է եռամսյակական | Իրական ժամանակի քաղաքականության թարմացումները անմիջապես տարածված են |
| Աուդիտորներ պահանջում են ապացույցներ շաբաթների հետո | Ապացույցների փաստաթղթեր կցված են յուրաքանչյուր կառուցվածքային (build) ակտիֆակտի հետ |
| Համաձայնության թիմը հանդիսանում է դարպասակ, դանդաղեցնելով տարածումը | Համաձայնությունը դառնում է ընդհանուր պատասխանատվություն, տեղադրված է գծում |

**Հիմնական ցավալի կետերը**՝

1. **Լատենցիա** – Անպարտական ապացույցները հաճախ ինպուտում են շուտից հետո մի քանի շաբաթ, որը ավելացնում է ռեգրեսիայի (regression) ռիսկը:
2. **Մարդու սխալ** – Ձեռնարկների դեսկագրողություն (transcription) անպատվիրում է անհամապատասխանություն:
3. **Դիրքավորություն** – Թիմերը պահում են առանձին քաղաքականության փաստաթղթեր աուդիտների համար և ներքին օգտագործման համար:
4. **Տեսանելիության բացի** – Ինժեներները շրջանում չեն տեսնում համաձայնության կարգավիճակը մինչև աուդիթի պահանջը առաջադրվի:

CI/CD‑ում համաձայնությունը տեղափոխելով, դուք ստանում եք այդ խնդիրների լուծում, դարձնելով համաձայնությունը **նախազգուշական, տվյալների‑հանդիպված գործառություն**:

---

## Գլխավոր ընկալումներ: Քաղաքականություն որպես կոդ, ԱԻ‑ն գեներացված պատասխաններ, և ապացույցները որպես ակտիֆակտներ

1. **Քաղաքականություն որպես կոդ** – Պահպանեք ձեր անվտանգության քաղաքականությունները (օրինակ՝ **[SOC 2](https://secureframe.com/hub/soc-2/what-is-soc-2)**, **[ISO 27001](https://www.iso.org/standard/27001)**, **[GDPR](https://gdpr.eu/)** և այլն) Central Git ռեպոզիտարայում: Յուրաքանչյուր քաղաքականություն պետք է լինի մեքենայով ընթերցվող ձևաչափ (YAML/JSON) որը կարող է ռեալիզացվել գործիքների կողմից:

2. **ԱԻ‑ն գեներացված պատասխաններ** – Procurize-ի մեծ-լեզվի մոդելը (LLM) կարող է ներգրավել քաղաքականության սահմանումները և ավտոմատ գեներացնել կարճ, աուդիտային պատասխաններ հարցազուգարքների տարրերի համար: ԱԻ‑ն նաև գնահատում է վստահության մակարդակը, նշելով, որտեղ դեռ անհրաժեշտ է մարդու դիտարկում:

3. **Ապացույցների ակտիֆակտներ** – Կազմվածքի (build) ընթացքում գծերը ստեղծում են անհեռացված ապացույցներ (օրինակ՝ կոնֆիգուրացիոն սնապներ, հասանելիության լոգերը, թեստավորման հաշվետվություններ): Procurize-ը կապում է այդ ակտիֆակտները գեներացված պատասխանների հետ, ստեղծելով **ամենակողմնայն աղբյուր** աուդիտորի համար:

Այս երեք շերտերը միասին կազմում են **շարունակական համաձայնության հետադարձ ճկունություն**.

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

**Բաղադրիչները**՝

- **Policy Repository** – Կենդանի Git ռեպոզիտարիք քաղաքականության սահմանմամբ (`policies/` թղթապանակ)։
- **CI Server** – Եազակայական կառուցվածք, թեստավորում, վիճակագրական վերլուծություն և սոցիալական համապատասխանության քայլերի կատարում:
- **Evidence Generator** – Ստորացված մեխանիզմներ, որոնք արտածում են JSON/YAML ապացույց (օրինակ՝ `evidence/aws-iam.json`)։
- **Procurize API** – Երկու վերջակետեր.
  - `/policies` – քաղաքականության թարմացում կամ ապա‑բեռնվածություն:
  - `/answers` – Հայտարարում ապացույցը և ստանում ԱԻ‑ն գեներացված պատասխանները:
- **Compliance Metadata Store** – Թեթև DB (օրինակ՝ DynamoDB), որը պահում է յուրաքանչյուր կառուցվածքի համաձայնության կարգավիճակը:
- **Dashboard** – Procurize UI կամ հատուկ դիտում, որը ցույց է տալիս համաձայնությունը ամեն թողարկման համար:

---

## Քայլ‑առ‑քայլ իրականացման ուղեցույց

### 1. Կազմե՛ք ձեր քաղաքականության ռեպոզիտարիթը

Ստեղծեք Git ռեպոզիտարի (կամ ենթամոդուլի) հետ, որը պահում է յուրաքանչյուր համաձայնության շրջանակը որպես YAML ֆայլ:

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

Commit‑ը պահեք և նախշեք `main` ճյուղը՝ միայն համաձայնության թիմը կարող է միանալու փոփոխություն։ Ծրագրավորողները պետք է փոխարկել վերջին քաղաքականությունը որպես մի մասը գծի:

### 2. Ավելացրեք CI‑ի փուլ՝ ապացույցների հավաքմանը

Ձեր CI‑ի կազմավորումում (օրինակ՝ GitHub Actions) ավելացրեք աշխատանքը, որը կատարում է թեստերից հետո.

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

Այս աշխատանքը ստեղծում է `evidence/` թղթապանակ, որտեղ գտնվում են JSON կամ տեքստային ֆայլեր, որոնք բավարարում են `evidence_type`‑ին, գրանցված քաղաքականությունում:

### 3. Կարողացեք Procurize AI Answer Service‑ը

Ստեղծեք փոքրիսցրիպտ (`procurize-submit.sh`), որը կկարդա ապացույցը, կանչի Procurize API‑ին և կհաշվի ԱԻ‑ն գեներացված պատասխանները JSON‑ում:

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

Ավելացրեք նոր CI‑ի քայլ, որը կգործի այս սկրիպտը և կբեռնավորի `answers-*.json`‑ը որպես ակտիֆակտ.

```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. Պահպանեք համաձայնության մետատվյալները

Դեպք մեկ զրահ‑բազմաչափ (Lambda կամ այլ serverless) ծառայություն, որը գործարկվում է ակտիֆակտների բեռնման պահումի (artifact upload) ժամը, վերլուծում `answers.json`‑ը և գրառում է ռեկորդը 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}
```

Այժմ յուրաքանչյուր կառուցվածք ունի համապատասխանական համաձայնության գրանցում, որը տեսանելի է Procurize‑ի վահանակում կամ ձեր սեփական UI‑ում:

### 5. Պաշտպանեք դարպասակները (պարտադիր)

Եթե ձեր գծին կցուցադրվի **հնարավորության** (confidence) ցածր, կարող եք գրաֆիկի վերջին ավելացնել քայլ, որը արգելում է սսարք (pipeline) փոխարկմանը:

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

Երբ գրաֆիկը անցնում է, հիվանդակները անցնում են արտադրանք: Եթե դարպասակները չբաց լինեն, ծրագրավորողները հնարավորություն կունենան ստանալ առողջ և արագ հարմարումներ՝ ցուցադրողը դեռ փակ չի լինում:

---

## Հատկորոշված հաջողություններ

| Չափ չափ | Ավանդական գործընթաց | Համլ աշխարհի (CI/CD) գործընթաց |
|----------|------------------------|--------------------------------|
| Քննել հարցազուգարքների միջին տառին | 10–14 օր | 2–4 ժամ |
| Ձեռնարկի աշխատանքի (person‑hours) մեկ թողարկումում | 12–20 ժամ | ≤ 2 ժամ (հիմնվում է վերանայում) |
| Աւդիթի ապացուցների ամբողջականություն | 70‑80 % | 95‑100 % |
| Համաձայնություն‑վերցվող թողարկումների արգելակների հաճախականություն | 1/սպրինտ | < 0.1/սպրինտ |

Իրագա արագությունը, ինտեգրումը **կրճատում է ռիսկերը**, ապահովելով, որ յուրաքանչյուր commit‑ը գնահատվում է վերջին քաղաքականության վրա, և **բարձրացնում է աւդիտելի տարբերակ**՝ ապացույցների աննշան կարգով կապված կառուցվածքի հետ:

---

## Ընդհանուր սխալներ և կախվածությունները

1. **Էջակցված քաղաքականության քաշ** – Համոզվածված լինի, որ CI‑ի աշխատանքը միշտ է վերցնում վերջին քաղաքականության ռեպոզիտարիթը: Օգտագործեք lock‑file կամ checksum՝ հաստատելու տարբերակների ճշտությունը:
2. **ԱԻ‑ի առավելաբար կախվածություն** – Կազմակերպեք ԱԻ‑ի ծառայությունը լոգավորման ստորին՝ ամեն անգամ, երբ պատասխանը գտնվում է վստահության սանդղակի (threshold) (օրինակ՝ 85 %): Ձեռագործները պետք է կողմնորոշված լինել:
3. **Ապացույցի չափի պսուպեր** – Սեղմեք ապացրելները քաղցկեղի (compressed) արխիվներով և ջնջեք հին ակտիֆակտները համաձայնական կառավարման սահմանված պահման ժամկետին:
4. **API բանալիների անվտանգություն** – Պահպանեք Procurize-ի տուրճերը CI‑ի գաղտնի ծածկագրումում (GitHub Secrets, Azure Key Vault): Կրկնակի պլանավորեք պտտանցը:

---

## Փուլը ընդլայնելով․ CI‑ից CD‑ի կառավարում

Երբ համաձայնությունը էրադված **CI**‑ում, կարելի է ընդլայնել նույն պաշտպանությունները **CD** (բաշխում) և **runtime**՝ դիտում:

- **Deploy‑time քաղաքականության վավերությունը** – Helm‑ի էլքարարը նախքան թողարկումը, կատարել քաղաքականության‑որպես‑կոդ ստուգում, որը վավերացնում է Kubernetes‑ի RBAC‑ը, ցանցի քաղաքականությունները և գաղտնիքների կառավարմանը՝ նույն YAML‑ներում, որոնք օգտագործվում են կառուցվածքի ժամանակ:
- **Runtime ապացույցների հոսք** – Օգտագործեք գործիքներ (օրինակ՝ Falco, OpenTelemetry)՝ որպեսզի անսահմանափակապարարտված անվտանգության իրադարձությունները ուղարկվի Procurize‑ի ապացույցների խոնավայրում, լրացնելով շրջանակների (continuous) համաձայնության պտույտը:
- **Ինքնուրույն համաձայնության պորտալ** – Առաջադրիս կցված ապացույցների աղյուսակները հաճախորդների համար, դարձնելով ձեր համաձայնական ռեկորդները մրցունակ սնպող:

---

## TL;DR

- **Կենտրոնացրեք բոլոր անվտանգության քաղաքականությունները Git‑ում**, որպես **քաղաքականություն‑որպես‑կոդ** (YAML/JSON):
- **CI‑ի քայլեր**՝ հավաքեք անհեռացված ապացույց և ուղարկեք Procurize‑ի **ԱԻ‑ն գեներացված հարցազուգարքի API**‑ին:
- **Պահպանեք ԱԻ‑ն գեներացված պատասխանները և վավերության գնահատումները** մետատվյալների խոհարանի մեջ:
- **Օգտագործեք համաձայնության դարպասակ**, որ արգելում է թողարկումները, եթե վստահության սանդղակը չի համապատասխանում:
- **Ստացված արդյունք**՝ մոտ-դրական աուդիտային պատրաստություն, աշխատունակության նվազեցում և շուտ շուրտը աշխատանքի շուկայի:

Procurize-ի ԱԻ‑ն ուղարկված համաձայնության հարթակը ձեր CI/CD‑ում, փոխում է համաձայնությունը ժամանակավոր, ավտոմատ պաշտպանված **համաձայնեցված** համակարգ՝, սարսափալի կերպով նմանեցված դիտել արգելափակված ու բացառիկ կոդային շղթաները:

---

## Նշված նյութեր

- [NIST CSF ինտեգրում CI/CD‑ի հետ (NIST SP 800‑53)](https://csrc.nist.gov/publications/detail/sp/800-53/rev-5/final)  
- [GitHub Actions՝ ապահով ծրագրովի պալատին] (https://github.com/github/securitylab)  
- [Microsoft Azure‑ի քաղաքականություն‑որպես‑կոդ ուղեցույց] (https://learn.microsoft.com/azure/governance/policy/)