# საბაზისო Docker Scout სკანი
docker scout cves alpine:latest

# დეტალური სკანირება რეკომენდაციებით
docker scout recommendations alpine:latest

# ორი იმიჯის შედარება სისუსტეებზე
docker scout compare alpine:3.16 alpine:3.17

# სკანირება პოლიტიკის აღსრულებით
docker scout quickview --policy policy.json myapp:latest

# კონტეინერის იმიჯის საბაზისო სკანი
trivy image nginx:latest

# სკანი სიმწვავის (severity) ფილტრით
trivy image --severity HIGH,CRITICAL myapp:latest

# ანგარიშის გენერაცია JSON ფორმატში
trivy image -f json -o results.json myapp:latest

# Dockerfile-ის სკანი საუკეთესო პრაქტიკების დარღვევებზე
trivy config ./Dockerfile

# გაშვებული კონტეინერების სკანი
trivy container $(docker ps -q)

# Snyk CLI-ის ინსტალაცია
npm install -g snyk

# ავთენტიკაცია Snyk-თან
snyk auth

# საბაზისო კონტეინერის სკანი
snyk container test nginx:latest

# კონტეინერის მონიტორინგი მიმდინარე სისუსტეების აღმოჩენისთვის
snyk container monitor nginx:latest

# ტესტი ქასთომ პოლიტიკის ბილიკით
snyk container test --policy-path=./policy nginx:latest

# SBOM გენერაცია კონტეინერიდან
snyk container test --json nginx:latest > sbom.json

# Clair API-ს გამოყენება (მაგალითი curl-ით)
curl -X POST -H "Content-Type: application/json" \
  -d '{"layers": [{"Hash": "sha256:5f70bf18a086007016e948b04aed3b82103a36bea41755b6cddfaf10ace3c6ef"}]}' \
  http://localhost:6060/v1/layers

# სკანი clairctl-ით
clairctl analyze alpine:latest

# სისუსტეების რეპორტის გენერაცია
clairctl report alpine:latest

// Jenkinsfile ინტეგრირებული უსაფრთხოების სკანირებით
pipeline {
    agent {
        docker {
            image 'docker:dind'
            args '--privileged -v /var/run/docker.sock:/var/run/docker.sock'
        }
    }
    
    environment {
        IMAGE_NAME = 'myapp'
        IMAGE_TAG = "${BUILD_NUMBER}"
    }
    
    stages {
        stage('Build') {
            steps {
                sh 'docker build -t ${IMAGE_NAME}:${IMAGE_TAG} .'
            }
        }
        
        stage('Security Scan') {
            steps {
                sh 'docker scout cves ${IMAGE_NAME}:${IMAGE_TAG} --format json > scout-results.json'
                sh 'trivy image ${IMAGE_NAME}:${IMAGE_TAG} --format json --output trivy-results.json'
            }
            post {
                always {
                    archiveArtifacts artifacts: '*-results.json', fingerprint: true
                }
            }
        }
        
        stage('Security Gate') {
            steps {
                script {
                    def trivyStatus = sh(script: '''
                        trivy image --exit-code 1 --severity CRITICAL ${IMAGE_NAME}:${IMAGE_TAG}
                    ''', returnStatus: true)
                    
                    if (trivyStatus != 0) {
                        error "Critical vulnerabilities found in the image"
                    }
                }
            }
        }
        
        stage('Push to Registry') {
            when {
                expression { currentBuild.resultIsBetterOrEqualTo('SUCCESS') }
            }
            steps {
                sh 'docker tag ${IMAGE_NAME}:${IMAGE_TAG} registry.example.com/${IMAGE_NAME}:${IMAGE_TAG}'
                sh 'docker push registry.example.com/${IMAGE_NAME}:${IMAGE_TAG}'
            }
        }
    }
}

# GitHub Actions workflow უსაფრთხოების სკანირებით
name: Build and Scan Container

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

jobs:
  build-and-scan:
    runs-on: ubuntu-latest
    steps:
  - name: კოდის ჩამოტვირთვა (Checkout)
        uses: actions/checkout@v3
      
  - name: Docker Buildx-ის გამართვა
        uses: docker/setup-buildx-action@v2
      
  - name: Docker იმიჯის აგება
        uses: docker/build-push-action@v4
        with:
          context: .
          push: false
          tags: myapp:${{ github.sha }}
          load: true
      
  - name: Trivy სისუსტეების სკანერის გაშვება
        uses: aquasecurity/trivy-action@master
        with:
          image-ref: myapp:${{ github.sha }}
          format: 'sarif'
          output: 'trivy-results.sarif'
          severity: 'CRITICAL,HIGH'
      
  - name: Trivy-ს შედეგების ატვირთვა GitHub Security ჩანართში
        uses: github/codeql-action/upload-sarif@v2
        with:
          sarif_file: 'trivy-results.sarif'
      
  - name: Docker Scout-ის გაშვება
        run: |
          docker scout cves myapp:${{ github.sha }} --format json > scout-results.json
          
  - name: კრიტიკული სისუსტეების შემოწმება
        run: |
          if grep -q "Critical" scout-results.json; then
            echo "Critical vulnerabilities found!"
            exit 1
          fi

# GitLab CI pipeline უსაფრთხოების სკანირებით
stages:
  - build
  - scan
  - deploy

variables:
  IMAGE_NAME: ${CI_REGISTRY_IMAGE}:${CI_COMMIT_SHORT_SHA}

build:
  stage: build
  image: docker:20.10.16
  services:
    - docker:20.10.16-dind
  script:
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
    - docker build -t $IMAGE_NAME .
    - docker push $IMAGE_NAME
  tags:
    - docker

vulnerability_scan:
  stage: scan
  image: aquasec/trivy:latest
  script:
    - trivy image --exit-code 0 --severity LOW,MEDIUM $IMAGE_NAME
    - trivy image --exit-code 1 --severity HIGH,CRITICAL $IMAGE_NAME
  allow_failure: true
  artifacts:
    paths:
      - trivy-results.json
    reports:
      container_scanning: trivy-results.json
  tags:
    - docker

deploy:
  stage: deploy
  script:
    - echo "Deploying $IMAGE_NAME"
  only:
    - main
  when: manual

# SBOM გენერაცია Syft-ით
syft nginx:latest -o json > nginx-sbom.json

# SBOM გენერაცია Docker Scout-ით
docker scout sbom nginx:latest

# SBOM გენერაცია Trivy-ით
trivy image --format cyclonedx nginx:latest > nginx-cyclonedx.json

2. **დამოკიდებულებების მართვა**:
```bash
# დამოკიდებულებების ავტომატური განახლება Dependabot-ით (GitHub)
cat > .github/dependabot.yml <<EOF
version: 2
updates:
  - package-ecosystem: "docker"
    directory: "/"
    schedule:
      interval: "weekly"
EOF

## კონტეინერის გამაგრების საუკეთესო პრაქტიკა

### შეტევის ზედაპირის მინიმიზაცია

კონტეინერების შეტევის ზედაპირის შემცირება შესაძლებელია ფრთხილი დიზაინით:

::steps
### მინიმალური საბაზო იმიჯების გამოყენება
- აირჩიეთ distroless ან Alpine-ზე დაფუძნებული იმიჯები
- ამოიღეთ არასაჭირო იუტილიტები და პაკეტები
- განიხილეთ scratch კონტეინერები კომპილირებადი აპლიკაციებისთვის

### მრავალსაფეხურიანი ბილდები
- განცალკევეთ build და runtime გარემოები
- ჩართეთ მხოლოდ runtime დამოკიდებულებები
- მოერიდეთ build ინსტრუმენტების შეყვანას საბოლოო იმიჯში

### მომხმარებლის ნებართვები
- მოერიდეთ root-ად გაშვებას
- შექმენით და გამოიყენეთ სპეციალური სერვის მომხმარებლები
- გამოიყენეთ მინიმალური პრივილეგიის პრინციპი
```dockerfile
# non-root მომხმარებლის შექმნა და ამ მომხმარებლით გაშვება
FROM alpine:3.17
RUN addgroup -S appgroup && adduser -S appuser -G appgroup
USER appuser

docker run --cap-drop=ALL --cap-add=NET_BIND_SERVICE myapp

# Docker Compose უსაფრთხოების პარამეტრებით
version: '3.8'
services:
  secure-app:
    image: myapp:latest
    read_only: true
    security_opt:
      - no-new-privileges:true
      - seccomp=default.json
    cap_drop:
      - ALL
    cap_add:
      - NET_BIND_SERVICE
    tmpfs:
      - /tmp:rw,noexec,nosuid,size=64M
    volumes:
      - app-data:/data:ro
    user: "1000:1000"

volumes:
  app-data:

# გაშვებული კონტეინერების პერიოდული სკანირება
cat > /etc/cron.daily/scan-containers <<EOF
#!/bin/bash
trivy container \$(docker ps -q) --format json > /var/log/container-scan-\$(date +%F).json
EOF
chmod +x /etc/cron.daily/scan-containers

# Falco-ს წესის მაგალითი კონტეინერის უსაფრთხოების მონიტორინგისთვის
- rule: Terminal Shell in Container
  desc: A shell was spawned in a container with an attached terminal
  condition: >
    container.id != "" and
    shell_procs and container and
    (proc.terminal != "" or container.entrypoint_parsed.jawt == true)
  output: >
    Shell spawned in a container with terminal (user=%user.name
    container_id=%container.id container_name=%container.name
    shell=%proc.name parent=%proc.pname cmdline=%proc.cmdline)
  priority: NOTICE
  tags: [container, shell]

# Docker audit ლოგირების ჩართვა
cat > /etc/docker/daemon.json <<EOF
{
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "10m",
    "max-file": "5"
  },
  "log-level": "info",
  "debug": true
}
EOF
systemctl restart docker

# OPA Rego პოლიტიკა კონტეინერის უსაფრთხოებისთვის
package container.security

default allow = false

# მხოლოდ დამტკიცებული რეესტრებიდან იმიჯების დაშვება
allow {
    startswith(input.image, "registry.company.com/")
}

# უარყავი, თუ იმიჯს აქვს კრიტიკული სისუსტეები
deny {
    input.vulnerabilities[_].severity == "CRITICAL"
}

# non-root მომხმარებლის მოთხოვნა
deny {
    input.config.User == "root"
}

# მხოლოდ-კითხვის ფაილური სისტემის მოთხოვნა
deny {
    not input.hostConfig.ReadonlyRootfs
}

# Docker Content Trust-ის კონფიგურაცია
export DOCKER_CONTENT_TRUST=1

# იმიჯის ხელმოწერა push-ის დროს
docker push myregistry.com/myapp:latest

# ხელმოწერილი იმიჯის ვერიფიკაცია
docker trust inspect --pretty myregistry.com/myapp:latest

# GCP Binary Authorization პოლიტიკის მაგალითი
apiVersion: binaryauthorization.k8s.io/v1
kind: Policy
metadata:
  name: default
spec:
  defaultAdmissionRule:
    evaluationMode: REQUIRE_ATTESTATION
    enforcementMode: ENFORCED_BLOCK_AND_AUDIT_LOG
    requireAttestationsBy:
      - projects/example-project/attestors/security-scan
      - projects/example-project/attestors/quality-gate
  clusterAdmissionRules:
    us-central1.prod-cluster:
      evaluationMode: REQUIRE_ATTESTATION
      enforcementMode: ENFORCED_BLOCK_AND_AUDIT_LOG
      requireAttestationsBy:
        - projects/example-project/attestors/security-scan
        - projects/example-project/attestors/quality-gate
        - projects/example-project/attestors/legal-approval

# კონტეინერის გაშვება gVisor-ით
docker run --runtime=runsc myapp:latest

# კონტეინერის გაშვება Kata Containers-ით
docker run --runtime=kata myapp:latest

# SLSA ვერიფიკაცია (მაგალითი)
slsa-verifier verify-image \
  --source github.com/myorg/myapp \
  --artifact-hash sha256:abc123... \
  --attestation-path attestation.json

2. **იდენტობაზე დაფუძნებული ავტორიზაცია**: წვდომის გრანულური კონტროლი სამუშაო ტვირთის იდენტობაზე დაყრდნობით
3. **მიკრო-სეგმენტაცია**: მკაცრი ქსელური კონტროლი კონტეინერებს შორის
4. **უწყვეტი ვერიფიკაცია**: კონტეინერის უსაფრთხოების მდგომარეობის მუდმივი ვერიფიკაცია

## დასკვნა

Docker-ის უსაფრთხოების სკანირება და სისუსტეების მართვა არის მძლავრი კონტეინერის უსაფრთხოების სტრატეგიის აუცილებელი კომპონენტი. განვითარების მთელ ციკლში ყოვლისმომცველი სკანირების დანერგვით, ორგანიზაციებს შეუძლიათ ამოიცნონ და გამოასწორონ უსაფრთხოების საკითხები პროდაქშენამდე.

რადგან კონტეინერის ტექნოლოგიები განაგრძობს განვითარებას, უსაფრთხოების პრაქტიკები უნდა ადაპტირდეს ახალი გამოწვევებისა და საფრთხეების საპასუხოდ. ფენოვანი მიდგომა, რომელიც აერთიანებს სისუსტეების სკანირებას, runtime დაცვას, შესაბამისობის მონიტორინგსა და მომარაგების ჯაჭვის უსაფრთხოებას, ქმნის საფუძველს უსაფრთხო კონტეინერიზებული აპლიკაციებისათვის თანამედროვე განთავსების გარემოებში.

ამ გზამკვლევში აღწერილი ინსტრუმენტებისა და ტექნიკების ინტეგრაციით, ორგანიზაციებს შეუძლიათ საგრძნობლად გააძლიერონ თავიანთი კონტეინერის უსაფრთხოების პოზიცია, תוך ერთად შეინარჩუნონ ის მოქნილობა და ეფექტიანობა, რასაც Docker კონტეინერები სთავაზობს.