Edit Bab

Batal

# Bab 9: DevSecOps - Security Dalam Pipeline DevOps

Bila kita bercakap tentang DevOps, ramai yang fokus pada speed. Deploy laju, iterate cepat, automate semua benda. Tapi ada satu perkara yang selalu jadi mangsa bila kita terlalu ghairah dengan kelajuan: **security**.

Saya pernah buat kesilapan ini. Satu projek kecil, saya push code terus ke production tanpa scan apa-apa. Dua minggu kemudian, saya perasan ada API key yang ter-commit dalam repo. Nasib baik projek tu kecil dan API key tu boleh di-revoke dengan cepat. Tapi bayangkan kalau itu berlaku dalam production system yang handle data pelanggan.

DevSecOps bukan sekadar buzzword. Ia adalah pendekatan di mana security menjadi tanggungjawab semua orang dalam team, bukan hanya security team sahaja. Dan yang paling penting, security dimasukkan dari awal proses development, bukan ditambah di hujung sebagai afterthought.

## Apa yang anda akan belajar:

- Konsep shift-left security dan kenapa ia penting
- SAST tools untuk scan source code
- DAST tools untuk scan running applications
- Container image scanning dengan Trivy dan Grype
- Secrets management yang betul
- Supply chain security dan SBOM
- Compliance as code
- Hands-on: Tambah security scanning dalam CI/CD pipeline

## Shift-Left Security: Tangkap Masalah Lebih Awal

Dalam model tradisional, security testing berlaku di hujung sekali. Developer tulis code, QA test, kemudian baru security team buat assessment. Masalahnya? Kalau jumpa vulnerability di hujung, kos untuk fix adalah sangat tinggi. Code dah deploy, dependencies dah banyak, dan kadang-kadang kena redesign seluruh architecture.

Shift-left bermaksud kita gerakkan security testing ke kiri dalam timeline development. Lebih awal kita tangkap masalah, lebih murah dan mudah untuk fix.

Bayangkan macam ini: lebih senang repair foundation rumah sebelum rumah siap dibina, berbanding selepas rumah dah siap dan orang dah duduk di dalamnya.

> **Nota Beginner:** Shift-left bukan bermaksud security team tak diperlukan lagi. Ia bermaksud developer juga ambil tanggungjawab untuk security, dan tools automatik membantu tangkap masalah common sebelum code sampai ke production.

Dalam konteks CI/CD pipeline, shift-left security bermaksud kita tambah security checks pada setiap stage:

1. **Code commit** - Pre-commit hooks untuk scan secrets
2. **Build stage** - SAST scanning pada source code
3. **Test stage** - DAST scanning pada running application
4. **Package stage** - Container image scanning
5. **Deploy stage** - Infrastructure security checks

## SAST: Static Application Security Testing

SAST tools menganalisis source code tanpa menjalankan aplikasi. Ia scan code anda untuk mencari patterns yang dikenali sebagai vulnerability. Contohnya SQL injection, cross-site scripting (XSS), atau penggunaan cryptographic functions yang lemah.

### SonarQube

SonarQube adalah salah satu SAST tool yang paling popular. Ia bukan sahaja scan untuk security issues, tetapi juga code quality, bugs, dan code smells.

Untuk setup SonarQube dalam homelab, anda boleh gunakan Docker:

```yaml
# docker-compose.yml
version: '3'
services:
  sonarqube:
    image: sonarqube:community
    ports:
      - "9000:9000"
    environment:
      - SONAR_JDBC_URL=jdbc:postgresql://db:5432/sonar
      - SONAR_JDBC_USERNAME=sonar
      - SONAR_JDBC_PASSWORD=sonar
    volumes:
      - sonarqube_data:/opt/sonarqube/data
      - sonarqube_extensions:/opt/sonarqube/extensions
    depends_on:
      - db

db:
    image: postgres:15
    environment:
      - POSTGRES_USER=sonar
      - POSTGRES_PASSWORD=sonar
      - POSTGRES_DB=sonar
    volumes:
      - postgresql_data:/var/lib/postgresql/data

volumes:
  sonarqube_data:
  sonarqube_extensions:
  postgresql_data:
```

Selepas SonarQube running, anda boleh integrate dengan CI/CD pipeline. Dalam GitHub Actions, tambahkan step ini:

```yaml
- name: SonarQube Scan
  uses: sonarqube-quality-gate-action@v1
  env:
    SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
    SONAR_HOST_URL: ${{ secrets.SONAR_HOST_URL }}
```

### Semgrep

Semgrep adalah SAST tool yang lebih ringan dan mudah digunakan. Ia menggunakan pattern-based approach dan mempunyai banyak community rules. Saya suka Semgrep kerana ia cepat dan boleh run secara local tanpa perlu server.

```bash
# Install Semgrep
pip install semgrep

# Scan project dengan default rules
semgrep --config auto .

# Scan dengan specific ruleset
semgrep --config p/owasp-top-ten .
semgrep --config p/secrets .
```

Dalam CI/CD pipeline:

```yaml
- name: Semgrep Scan
  uses: returntocorp/semgrep-action@v1
  with:
    config: >-
      p/security-audit
      p/secrets
      p/owasp-top-ten
```

> **Nota Beginner:** Mula dengan Semgrep kalau anda baru dalam SAST. Ia lebih mudah di-setup, cepat, dan free. SonarQube bagus untuk team yang lebih besar dan perlukan dashboard serta tracking over time.

## DAST: Dynamic Application Security Testing

Kalau SAST scan source code, DAST pula scan running application. Ia bertindak seperti attacker sebenar, menghantar pelbagai jenis request ke application anda untuk mencari vulnerability.

### OWASP ZAP

OWASP ZAP (Zed Attack Proxy) adalah DAST tool open-source yang paling popular. Ia boleh digunakan secara manual melalui GUI, atau secara automatik dalam CI/CD pipeline.

```yaml
# Dalam GitHub Actions
- name: OWASP ZAP Scan
  uses: zaproxy/action-full-scan@v0.7.0
  with:
    target: 'https://staging.myapp.com'
    rules_file_name: '.zap/rules.tsv'
    cmd_options: '-a'
```

Untuk baseline scan yang lebih cepat:

```yaml
- name: OWASP ZAP Baseline Scan
  uses: zaproxy/action-baseline@v0.7.0
  with:
    target: 'https://staging.myapp.com'
```

Satu tip penting: jalankan DAST scan terhadap staging environment, bukan production. DAST scan boleh menjadi agresif dan mungkin menyebabkan side effects pada application anda.

## Container Image Scanning

Bila anda menggunakan containers, anda bukan sahaja perlu scan application code, tetapi juga container images. Base images mungkin mengandungi vulnerability yang sudah diketahui. Libraries yang di-install mungkin sudah outdated.

### Trivy

Trivy daripada Aqua Security adalah container scanner yang saya paling suka. Ia cepat, comprehensive, dan mudah digunakan.

```bash
# Scan container image
trivy image myapp:latest

# Scan dengan severity filter
trivy image --severity HIGH,CRITICAL myapp:latest

# Scan filesystem
trivy fs --security-checks vuln,secret,config .

# Scan Kubernetes cluster
trivy k8s --report summary cluster
```

Dalam CI/CD pipeline:

```yaml
- name: Build Image
  run: docker build -t myapp:${{ github.sha }} .

- name: Trivy Scan
  uses: aquasecurity/trivy-action@master
  with:
    image-ref: 'myapp:${{ github.sha }}'
    format: 'sarif'
    output: 'trivy-results.sarif'
    severity: 'CRITICAL,HIGH'
    exit-code: '1'
```

Setting `exit-code: '1'` bermaksud pipeline akan gagal jika jumpa vulnerability dengan severity HIGH atau CRITICAL. Ini penting untuk memastikan images yang vulnerable tidak sampai ke production.

### Grype

Grype daripada Anchore adalah alternatif kepada Trivy. Ia juga cepat dan mempunyai database vulnerability yang comprehensive.

```bash
# Install Grype
curl -sSfL https://raw.githubusercontent.com/anchore/grype/main/install.sh | sh -s

# Scan image
grype myapp:latest

# Scan dengan output format
grype myapp:latest -o json > grype-results.json

# Fail jika jumpa severity tertentu
grype myapp:latest --fail-on high
```

> **Nota Beginner:** Pilih satu sahaja untuk mula. Trivy atau Grype, kedua-duanya bagus. Anda boleh cuba kedua-dua dan pilih yang mana anda lebih selesa. Yang penting ialah anda ada scanning dalam pipeline.

## Secrets Management

Ini adalah area di mana saya pernah buat kesilapan, dan saya pasti ramai developer lain juga pernah. Hardcode password dalam code, commit API keys ke Git, atau simpan credentials dalam plain text config files.

### HashiCorp Vault

Vault adalah gold standard untuk secrets management. Ia menyimpan secrets secara encrypted, boleh generate dynamic secrets, dan mempunyai audit log yang detailed.

```bash
# Start Vault server (dev mode untuk belajar)
vault server -dev

# Simpan secret
vault kv put secret/myapp/database \
  username="dbuser" \
  password="supersecretpassword"

# Baca secret
vault kv get secret/myapp/database
```

Dalam Kubernetes, anda boleh gunakan Vault Agent Injector untuk automatically inject secrets ke dalam pods:

```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
spec:
  template:
    metadata:
      annotations:
        vault.hashicorp.com/agent-inject: "true"
        vault.hashicorp.com/role: "myapp"
        vault.hashicorp.com/agent-inject-secret-db-creds: "secret/data/myapp/database"
    spec:
      serviceAccountName: myapp
      containers:
        - name: myapp
          image: myapp:latest
```

### Sealed Secrets

Kalau anda menggunakan GitOps (dan anda patut!), ada satu masalah. Macam mana nak simpan secrets dalam Git repo kalau secrets tu sensitive? Sealed Secrets daripada Bitnami menyelesaikan masalah ini.

Sealed Secrets encrypt secrets menggunakan public key, dan hanya controller dalam cluster yang ada private key untuk decrypt.

```bash
# Install kubeseal CLI
brew install kubeseal

# Create sealed secret
kubectl create secret generic myapp-secret \
  --from-literal=password=supersecret \
  --dry-run=client -o yaml | \
  kubeseal --format yaml > sealed-secret.yaml
```

File `sealed-secret.yaml` yang dihasilkan boleh di-commit ke Git dengan selamat kerana ia encrypted. Hanya Sealed Secrets controller dalam cluster anda yang boleh decrypt ia.

## Supply Chain Security

Supply chain attacks semakin menjadi ancaman besar. Ingat insiden SolarWinds? Atau log4j? Anda perlu memastikan bahawa semua components dalam supply chain anda boleh dipercayai.

### Container Image Signing

Gunakan Cosign untuk sign dan verify container images:

```bash
# Install Cosign
brew install cosign

# Generate key pair
cosign generate-key-pair

# Sign image
cosign sign --key cosign.key myregistry/myapp:v1.0

# Verify image
cosign verify --key cosign.pub myregistry/myapp:v1.0
```

### SBOM (Software Bill of Materials)

SBOM adalah senarai lengkap semua components dalam software anda. Ia seperti senarai ramuan pada produk makanan. Jika ada vulnerability baru ditemui dalam sesuatu library, anda boleh dengan cepat check sama ada software anda terjejas.

```bash
# Generate SBOM dengan Syft
syft myapp:latest -o spdx-json > sbom.json

# Scan SBOM untuk vulnerabilities
grype sbom:sbom.json
```

## Compliance as Code

Dalam banyak industri, ada compliance requirements yang perlu dipatuhi. Daripada manually check compliance, anda boleh automate ia menggunakan tools seperti Open Policy Agent (OPA).

```rego
# policy.rego - Pastikan containers tidak run sebagai root
package kubernetes.admission

deny[msg] {
  input.request.kind.kind == "Pod"
  container := input.request.object.spec.containers[_]
  not container.securityContext.runAsNonRoot
  msg := sprintf("Container '%v' mesti run sebagai non-root", [container.name])
}

deny[msg] {
  input.request.kind.kind == "Pod"
  container := input.request.object.spec.containers[_]
  not container.resources.limits
  msg := sprintf("Container '%v' mesti ada resource limits", [container.name])
}
```

> **Nota Beginner:** Compliance as code nampak advanced, tetapi konsepnya simple. Anda tulis rules dalam code, dan system akan automatically check sama ada infrastructure anda comply dengan rules tersebut. Mula dengan rules yang simple dulu.

## Hands-On: Security Scanning Dalam CI/CD Pipeline

Sekarang mari kita gabungkan semua yang kita belajar. Berikut adalah contoh complete CI/CD pipeline dengan security scanning di setiap stage:

```yaml
name: Secure CI/CD Pipeline

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  secret-scan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

- name: Scan for secrets
        uses: trufflesecurity/trufflehog@main
        with:
          extra_args: --only-verified

sast:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

- name: Semgrep SAST Scan
        uses: returntocorp/semgrep-action@v1
        with:
          config: >-
            p/security-audit
            p/secrets
            p/owasp-top-ten

build-and-scan:
    needs: [secret-scan, sast]
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

- name: Build Docker Image
        run: docker build -t myapp:${{ github.sha }} .

- name: Trivy Image Scan
        uses: aquasecurity/trivy-action@master
        with:
          image-ref: 'myapp:${{ github.sha }}'
          format: 'table'
          severity: 'CRITICAL,HIGH'
          exit-code: '1'

- name: Generate SBOM
        uses: anchore/sbom-action@v0
        with:
          image: myapp:${{ github.sha }}
          format: spdx-json
          output-file: sbom.json

- name: Push Image
        if: github.ref == 'refs/heads/main'
        run: |
          docker tag myapp:${{ github.sha }} myregistry/myapp:${{ github.sha }}
          docker push myregistry/myapp:${{ github.sha }}

dast:
    needs: [build-and-scan]
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'
    steps:
      - name: Deploy to Staging
        run: echo "Deploy to staging environment"

- name: OWASP ZAP Baseline Scan
        uses: zaproxy/action-baseline@v0.7.0
        with:
          target: 'https://staging.myapp.com'

deploy:
    needs: [dast]
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'
    steps:
      - name: Deploy to Production
        run: echo "Deploy to production"
```

Pipeline ini menjalankan:
1. **Secret scanning** menggunakan TruffleHog untuk pastikan tiada secrets yang ter-commit
2. **SAST scanning** menggunakan Semgrep untuk scan source code
3. **Container image scanning** menggunakan Trivy
4. **SBOM generation** untuk supply chain visibility
5. **DAST scanning** menggunakan OWASP ZAP terhadap staging

Setiap stage bertindak sebagai quality gate. Jika mana-mana scan gagal, pipeline berhenti dan code tidak sampai ke production.

## Ringkasan

DevSecOps bukan tentang menambah kerja. Ia tentang mengautomasikan security supaya ia berlaku secara konsisten tanpa memperlahankan development process secara ketara.

Perkara utama yang perlu diingat:

- **Shift-left security** bermaksud tangkap masalah lebih awal. Lebih awal anda tangkap, lebih murah untuk fix.
- **SAST tools** seperti SonarQube dan Semgrep scan source code untuk vulnerability.
- **DAST tools** seperti OWASP ZAP scan running applications seperti seorang attacker.
- **Container scanning** dengan Trivy atau Grype pastikan images anda tidak ada known vulnerabilities.
- **Secrets management** menggunakan Vault atau Sealed Secrets, bukan hardcoded credentials.
- **Supply chain security** melalui image signing dan SBOM memberikan visibility terhadap semua components.
- **Compliance as code** mengautomasikan security policies.

Anda tidak perlu implement semua ini sekaligus. Mulakan dengan satu atau dua tools, dan tambahkan secara berperingkat. Yang penting ialah anda mula memikirkan security sebagai bahagian integral dalam DevOps workflow anda, bukan sesuatu yang ditambah kemudian.

Security bukan destination, ia adalah journey. Dan dengan DevSecOps, journey itu menjadi sebahagian daripada setiap commit, setiap build, dan setiap deployment.

\newpage