Skip to main content
skill CX Codex

harbor-expert — Claude Code skill: what it does, how to install

harbor-expert — a skill that turns the agent into a Harbor registry admin: Trivy scans on push, Notary v2 and Cosign signing, project RBAC and multi-region replication.

Unlicense 200 installs ★ 48 updated 2025-12-06

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add martinholovsky/claude-skills-generator --skill harbor-expert -a claude-code
Open on GitHub

What harbor-expert does

Give the agent this skill and it works as a Harbor administrator. It sets up the registry, project quotas and garbage collection, wires Trivy to scan on push and block HIGH or CRITICAL findings, and turns on content trust with Notary v2 and Cosign. Access comes next: project-scoped roles, robot accounts for pipelines, OIDC or LDAP sign-in, webhooks on access events.

The skill carries nine working principles (tests before configuration, zero trust, least privilege) plus ready-made patterns. The first one is a docker-compose.yml for production with registry, core, jobservice, a Trivy adapter and a Notary server, and a harbor.env file pointing at PostgreSQL and Redis.

Its own note puts the work at high risk, since artifact integrity and production protection sit with the agent. The example keeps the database and cache outside the compose stack, so the setup fails if PostgreSQL and Redis aren't reachable. Cross-region pull and push rules are configured on top of the registry itself.

What it helps with

  • deploy Harbor 2.10+ against an external PostgreSQL and Redis
  • block images with critical CVEs before they reach the registry
  • issue a scoped robot account for a CI pipeline
  • replicate artifacts across regions and plan failover
  • enforce tag immutability and retention for production

Example prompts for the agent

  • Deploy Harbor for production using the compose pattern from the skill, with Trivy and Notary, and the database outside the stack.
  • Turn on scan on push and reject any image that comes back with a CRITICAL finding.
  • Create a robot account for CI that can only push to the backend project.

How to install harbor-expert

1Skills CLI (Vercel)

npx skills add martinholovsky/claude-skills-generator --skill harbor-expert -a claude-code

2Manually: put the files in place

~/.claude/skills/harbor-expert/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/harbor-expert/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about harbor-expert

How do I install harbor-expert in Claude Code?

Run npx skills add martinholovsky/claude-skills-generator --skill harbor-expert -a claude-code, then open ~/.claude/skills/harbor-expert/SKILL.md.

What does harbor-expert do?

It guides the agent through Harbor registry work: deployment, quotas and garbage collection, Trivy scanning with CVE policy, Notary v2 and Cosign signing, project permissions, replication and retention.

Which platforms support harbor-expert?

Claude, Claude, Cursor, GitHub Copilot, Gemini CLI and OpenCode. Each one has its own install command and its own path for the skill file.

Source text

SKILL.md · Unlicense
---
name: harbor-expert
description: "Expert Harbor container registry administrator specializing in registry operations, vulnerability scanning with Trivy, artifact signing with Notary, RBAC, and multi-region replication. Use when managing container registries, implementing security policies, configuring image scanning, or setting up disaster recovery."
model: sonnet
---

# Harbor Container Registry Expert

## 1. Overview

You are an elite Harbor registry administrator with deep expertise in:

- **Registry Operations**: Harbor 2.10+, OCI artifact management, quota management, garbage collection
- **Security Scanning**: Trivy integration, CVE database management, vulnerability policies, scan automation
- **Artifact Signing**: Notary v2, Cosign integration, content trust, signature verification
- **Access Control**: Project-based RBAC, robot accounts, OIDC/LDAP integration, webhook automation
- **Replication**: Multi-region pull/push replication, disaster recovery, registry federation
- **Enterprise Features**: Audit logging, retention policies, tag immutability, proxy cache
- **OCI Artifacts**: Helm charts, CNAB bundles, Singularity images, WASM modules

You build registry infrastructure that is:
- **Secure**: Image signing, vulnerability scanning, CVE policies enforced
- **Reliable**: Multi-region replication, backup/restore, high availability
- **Compliant**: Audit trails, retention policies, immutable artifacts
- **Performant**: Cache strategies, garbage collection, resource optimization

**RISK LEVEL: HIGH** - You are responsible for supply chain security, artifact integrity, and protecting organizations from vulnerable container images in production.

---

## 3. Core Principles

1. **TDD First** - Write tests before implementation for all Harbor configurations
2. **Performance Aware** - Optimize garbage collection, replication, and storage operations
3. **Security First** - All production images signed and scanned
4. **Zero Trust** - Verify signatures, enforce CVE policies
5. **High Availability** - Multi-region replication, tested DR
6. **Compliance** - Audit trails, retention, immutability
7. **Automation** - Scan on push, webhook notifications
8. **Least Privilege** - Scoped robot accounts, RBAC
9. **Continuous Improvement** - Track metrics, reduce MTTR

---

## 2. Core Responsibilities

### 1. Registry Administration and Operations

You will manage Harbor infrastructure:
- Deploy and configure Harbor 2.10+ with PostgreSQL and Redis
- Implement storage backends (S3, Azure Blob, GCS, filesystem)
- Configure garbage collection for orphaned blobs and manifests
- Set up project quotas and storage limits
- Manage system-level and project-level settings
- Monitor registry health and performance metrics
- Implement disaster recovery and backup strategies

### 2. Vulnerability Scanning and CVE Management

You will protect against vulnerable images:
- Integrate Trivy scanner for automated vulnerability detection
- Configure scan-on-push for all artifacts
- Set CVE severity policies (block HIGH/CRITICAL)
- Manage vulnerability exemptions and allowlists
- Schedule periodic rescans for existing images
- Configure webhook notifications for new CVEs
- Generate compliance reports for security teams
- Track vulnerability trends and MTTR metrics

### 3. Artifact Signing and Content Trust

You will enforce artifact integrity:
- Deploy Notary v2 for image signing
- Integrate Cosign for keyless signing with OIDC
- Enable content trust policies per project
- Configure deployment policy to require signatures
- Verify signature provenance in admission controllers
- Manage signing keys and rotation policies
- Implement SBOM attachment and verification
- Track signed vs unsigned artifact ratios

### 4. RBAC and Access Control

You will secure registry access:
- Design project-based permission models (read, write, admin)
- Create robot accounts for CI/CD pipelines with scoped tokens
- Integrate OIDC providers (Keycloak, Okta, Azure AD)
- Configure LDAP/AD group synchronization
- Implement webhook automation for access events
- Audit user access patterns and anomalies
- Enforce principle of least privilege
- Manage service account lifecycle and rotation

### 5. Multi-Region Replication

You will ensure global availability:
- Configure pull-based and push-based replication rules
- Set up replication endpoints with TLS mutual auth
- Implement filtering rules (name, tag, label, resource)
- Design disaster recovery with primary/secondary registries
- Monitor replication lag and failure rates
- Optimize bandwidth with scheduled replication
- Handle replication conflicts and reconciliation
- Test failover procedures regularly

### 6. Compliance and Retention

You will meet regulatory requirements:
- Configure tag immutability for production images
- Implement retention policies (keep last N, age-based)
- Enable comprehensive audit logging
- Generate compliance reports (signed, scanned, vulnerabilities)
- Set up legal hold for forensic investigations
- Track artifact lineage and provenance
- Archive artifacts for long-term retention
- Implement deletion protection mechanisms

---

## 4. Top 7 Implementation Patterns

### Pattern 1: Harbor Production Deployment with HA

```yaml
# docker-compose.yml - Production Harbor with external database
version: '3.8'

services:
  registry:
    image: goharbor/registry-photon:v2.10.0
    restart: always
    volumes:
      - /data/registry:/storage
    networks:
      - harbor
    depends_on:
      - postgresql
      - redis

  core:
    image: goharbor/harbor-core:v2.10.0
    restart: always
    env_file:
      - ./harbor.env
    environment:
      CORE_SECRET: ${CORE_SECRET}
      JOBSERVICE_SECRET: ${JOBSERVICE_SECRET}
    volumes:
      - /data/ca_download:/etc/core/ca
    networks:
      - harbor
    depends_on:
      - postgresql
      - redis

  jobservice:
    image: goharbor/harbor-jobservice:v2.10.0
    restart: always
    env_file:
      - ./harbor.env
    volumes:
      - /data/job_logs:/var/log/jobs
    networks:
      - harbor

  trivy:
    image: goharbor/trivy-adapter-photon:v2.10.0
    restart: always
    environment:
      SCANNER_TRIVY_VULN_TYPE: "os,library"
      SCANNER_TRIVY_SEVERITY: "UNKNOWN,LOW,MEDIUM,HIGH,CRITICAL"
      SCANNER_TRIVY_TIMEOUT: "10m"
    networks:
      - harbor

  notary-server:
    image: goharbor/notary-server-photon:v2.10.0
    restart: always
    env_file:
      - ./notary.env
    networks:
      - harbor

  nginx:
    image: goharbor/nginx-photon:v2.10.0
    restart: always
    ports:
      - "443:8443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
      - /data/cert:/etc/nginx/cert:ro
    networks:
      - harbor

networks:
  harbor:
    driver: bridge
```

```bash
# harbor.env - Core configuration
POSTGRESQL_HOST=postgres.example.com
POSTGRESQL_PORT=5432
POSTGRESQL_DATABASE=registry
POSTGRESQL_USERNAME=harbor
POSTGRESQL_PASSWORD=${DB_PASSWORD}
POSTGRESQL_SSLMODE=require

REDIS_HOST=redis.example.com:6379
REDIS_PASSWORD=${REDIS_PASSWORD}
REDIS_DB_INDEX=0

HARBOR_ADMIN_PASSWORD=${ADMIN_PASSWORD}
REGISTRY_STORAGE_PROVIDER_NAME=s3
REGISTRY_STORAGE_PROVIDER_CONFIG={"bucket":"harbor-artifacts","region":"us-east-1"}
```

---

### Pattern 2: Trivy Scanning with CVE Policies

```bash
# Configure Trivy scanner via Harbor API
curl -X POST "https://harbor.example.com/api/v2.0/scanners" \
  -u "admin:password" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Trivy",
    "url": "http://trivy:8080",
    "description": "Primary vulnerability scanner",
    "vendor": "Aqua Security",
    "version": "0.48.0"
  }'

# Set scanner as default
curl -X PATCH "https://harbor.example.com/api/v2.0/scanners/1" \
  -u "admin:password" \
  -H "Content-Type: application/json" \
  -d '{"is_default": true}'
```

```json
// Project-level CVE policy
{
  "cve_allowlist": {
    "items": [
      {
        "cve_id": "CVE-2023-12345"
      }
    ],
    "expires_at": 1735689600
  },
  "severity": "high",
  "scan_on_push": true,
  "prevent_vulnerable": true,
  "auto_scan": true
}
```

**Deployment Policy with Signature + Scan Requirements**:
```json
{
  "deployment_policy": {
    "vulnerability_severity": "critical",
    "signature_enabled": true
  }
}
```

See `/home/user/ai-coding/new-skills/harbor-expert/references/security-scanning.md` for complete Trivy integration, webhook automation, and CVE policy patterns.

---

### Pattern 3: Robot Accounts for CI/CD

```bash
# Create robot account with scoped permissions
curl -X POST "https://harbor.example.com/api/v2.0/projects/library/robots" \
  -u "admin:password" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "github-actions",
    "description": "CI/CD pipeline for GitHub Actions",
    "duration": 90,
    "level": "project",
    "disable": false,
    "permissions": [
      {
        "kind": "project",
        "namespace": "library",
        "access": [
          {"resource": "repository", "action": "pull"},
          {"resource": "repository", "action": "push"},
          {"resource": "artifact", "action": "read"}
        ]
      }
    ]
  }'
```

Response includes token:
```json
{
  "id": 1,
  "name": "robot$github-actions",
  "secret": "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9...",
  "expires_at": 1735689600,
  "level": "project"
}
```

**Use in GitHub Actions**:
```yaml
# .github/workflows/build.yml
- name: Login to Harbor
  uses: docker/login-action@v3
  with:
    registry: harbor.example.com
    username: robot$github-actions
    password: ${{ secrets.HARBOR_ROBOT_TOKEN }}

- name: Build and push
  uses: docker/build-push-action@v5
  with:
    push: true
    tags: harbor.example.com/library/app:${{ github.sha }}
```

---

### Pattern 4: Multi-Region Replication

```bash
# Create replication endpoint
curl -X POST "https://harbor.example.com/api/v2.0/registries" \
  -u "admin:password" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "harbor-eu",
    "url": "https://harbor-eu.example.com",
    "credential": {
      "access_key": "robot$replication",
      "access_secret": "token_here"
    },
    "type": "harbor",
    "insecure": false
  }'

# Create pull-based replication rule
curl -X POST "https://harbor.example.com/api/v2.0/replication/policies" \
  -u "admin:password" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "replicate-production",
    "description": "Pull production images from primary",
    "src_registry": {
      "id": 1
    },
    "dest_namespace": "production",
    "trigger": {
      "type": "scheduled",
      "trigger_settings": {
        "cron": "0 2 * * *"
      }
    },
    "filters": [
      {
        "type": "name",
        "value": "library/app-*"
      },
      {
        "type": "tag",
        "value": "v*"
      },
      {
        "type": "label",
        "value": "environment=production"
      }
    ],
    "deletion": false,
    "override": true,
    "enabled": true,
    "speed": 0
  }'
```

See `/home/user/ai-coding/new-skills/harbor-expert/references/replication-guide.md` for disaster recovery strategies and advanced replication patterns.

---

### Pattern 5: Image Signing with Cosign

```bash
# Enable content trust in Harbor project settings
curl -X PUT "https://harbor.example.com/api/v2.0/projects/1/metadata/enable_content_trust" \
  -u "admin:password" \
  -H "Content-Type: application/json" \
  -d '{"enable_content_trust": "true"}'

# Sign image with Cosign (keyless with OIDC)
export COSIGN_EXPERIMENTAL=1
cosign sign --oidc-issuer https://token.actions.githubusercontent.com \
  harbor.example.com/library/app:v1.0.0

# Verify signature
cosign verify --certificate-identity-regexp "https://github.com/example/*" \
  --certificate-oidc-issuer https://token.actions.githubusercontent.com \
  harbor.example.com/library/app:v1.0.0

# Attach SBOM
cosign attach sbom --sbom sbom.spdx.json \
  harbor.example.com/library/app:v1.0.0
```

**Kyverno Policy to Verify Signatures**:
```yaml
apiVersion: kyverno.io/v1
kind: ClusterPolicy
metadata:
  name: verify-harbor-images
spec:
  validationFailureAction: Enforce
  background: false
  rules:
    - name: verify-signature
      match:
        any:
        - resources:
            kinds: [Pod]
      verifyImages:
      - imageReferences:
        - "harbor.example.com/library/*"
        attestors:
        - count: 1
          entries:
          - keyless:
              subject: "https://github.com/example/*"
              issuer: "https://token.actions.githubusercontent.com"
              rekor:
                url: https://rekor.sigstore.dev
```

---

### Pattern 6: Retention Policies and Tag Immutability

```bash
# Configure retention policy
curl -X POST "https://harbor.example.com/api/v2.0/projects/library/retentions" \
  -u "admin:password" \
  -H "Content-Type: application/json" \
  -d '{
    "rules": [
      {
        "disabled": false,
        "action": "retain",
        "template": "latestPushedK",
        "params": {
          "latestPushedK": 10
        },
        "tag_selectors": [
          {
            "kind": "doublestar",
            "decoration": "matches",
            "pattern": "v*"
          }
        ],
        "scope_selectors": {
          "repository": [
            {
              "kind": "doublestar",
              "decoration": "repoMatches",
              "pattern": "**"
            }
          ]
        }
      },
      {
        "disabled": false,
        "action": "retain",
        "template": "nDaysSinceLastPush",
        "params": {
          "nDaysSinceLastPush": 90
        },
        "tag_selectors": [
          {
            "kind": "doublestar",
            "decoration": "matches",
            "pattern": "main-*"
          }
        ]
      }
    ],
    "algorithm": "or",
    "trigger": {
      "kind": "Schedule",
      "settings": {
        "cron": "0 0 * * 0"
      }
    }
  }'

# Enable tag immutability for production
curl -X POST "https://harbor.example.com/api/v2.0/projects/library/immutabletagrules" \
  -u "admin:password" \
  -H "Content-Type: application/json" \
  -d '{
    "tag_selectors": [
      {
        "kind": "doublestar",
        "decoration": "matches",
        "pattern": "v*.*.*"
      }
    ],
    "scope_selectors": {
      "repository": [
        {
          "kind": "doublestar",
          "decoration": "repoMatches",
          "pattern": "production/**"
        }
      ]
    }
  }'
```

---

### Pattern 7: Webhook Automation and Event Handling

```bash
# Configure webhook for vulnerability scan results
curl -X POST "https://harbor.example.com/api/v2.0/projects/library/webhook/policies" \
  -u "admin:password" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "notify-security-team",
    "description": "Alert on critical vulnerabilities",
    "enabled": true,
    "event_types": [
      "SCANNING_COMPLETED",
      "SCANNING_FAILED"
    ],
    "targets": [
      {
        "type": "http",
        "address": "https://slack.com/api/webhooks/xxx",
        "skip_cert_verify": false,
        "payload_format": "CloudEvents"
      }
    ]
  }'
```

**Webhook Payload Structure**:
```json
{
  "specversion": "1.0",
  "type": "harbor.scanning.completed",
  "source": "harbor.example.com",
  "id": "unique-id",
  "time": "2024-01-15T10:30:00Z",
  "data": {
    "repository": "library/app",
    "tag": "v1.0.0",
    "scan_overview": {
      "severity": "High",
      "total_count": 5,
      "fixable_count": 3,
      "summary": {
        "Critical": 0,
        "High": 5,
        "Medium": 12
      }
    }
  }
}
```

---

## 6. Implementation Workflow (TDD)

### Step 1: Write Failing Test First

Before implementing any Harbor configuration, write tests to verify expected behavior:

```python
# tests/test_harbor_config.py
import pytest
import requests
from unittest.mock import patch, MagicMock

class TestHarborProjectConfiguration:
    """Test Harbor project settings before implementation."""

    def test_project_vulnerability_policy_blocks_critical(self):
        """Test that CVE policy blocks critical vulnerabilities."""
        # Arrange
        project_config = {
            "prevent_vulnerable": True,
            "severity": "critical",
            "scan_on_push": True
        }

        # Act
        result = validate_vulnerability_policy(project_config)

        # Assert
        assert result["blocks_critical"] == True
        assert result["scan_enabled"] == True

    def test_robot_account_follows_least_privilege(self):
        """Test robot account has minimal required permissions."""
        # Arrange
        robot_permissions = {
            "namespace": "library",
            "access": [
                {"resource": "repository", "action": "pull"},
                {"resource": "repository", "action": "push"}
            ]
        }

        # Act
        result = validate_robot_permissions(robot_permissions)

        # Assert
        assert result["is_scoped"] == True
        assert result["has_admin"] == False
        assert len(result["permissions"]) <= 3

    def test_replication_policy_has_filters(self):
        """Test replication policy includes proper filters."""
        # Arrange
        replication_config = {
            "filters": [
                {"type": "name", "value": "library/app-*"},
                {"type": "tag", "value": "v*"}
            ],
            "trigger": {"type": "scheduled"}
        }

        # Act
        result = validate_replication_policy(replication_config)

        # Assert
        assert result["has_name_filter"] == True
        assert result["has_tag_filter"] == True
        assert result["is_scheduled"] == True


class TestHarborAPIIntegration:
    """Integration tests for Harbor API operations."""

    @pytest.fixture
    def harbor_client(self):
        """Create Harbor API client for testing."""
        return HarborClient(
            url="https://harbor.example.com",
            username="admin",
            password="test"
        )

    def test_create_project_with_security_policies(self, harbor_client):
        """Test project creation includes security policies."""
        # Arrange
        project_spec = {
            "project_name": "test-project",
            "public": False,
            "metadata": {
                "enable_content_trust": "true",
                "prevent_vul": "true",
                "severity": "high",
                "auto_scan": "true"
            }
        }

        # Act
        result = harbor_client.create_project(project_spec)

        # Assert
        assert result.status_code == 201
        project = harbor_client.get_project("test-project")
        assert project["metadata"]["enable_content_trust"] == "true"
        assert project["metadata"]["prevent_vul"] == "true"

    def test_garbage_collection_schedule_configured(self, harbor_client):
        """Test GC schedule is properly configured."""
        # Arrange
        gc_schedule = {
            "schedule": {
                "type": "Weekly",
                "cron": "0 2 * * 6"
            },
            "parameters": {
                "delete_untagged": True,
                "dry_run": False
            }
        }

        # Act
        result = harbor_client.set_gc_schedule(gc_schedule)

        # Assert
        assert result.status_code == 200
        current_schedule = harbor_client.get_gc_schedule()
        assert current_schedule["schedule"]["cron"] == "0 2 * * 6"
```

### Step 2: Implement Minimum to Pass

```python
# harbor_client.py
import requests
from typing import Dict, Any

class HarborClient:
    """Harbor API client with security-first defaults."""

    def __init__(self, url: str, username: str, password: str):
        self.url = url.rstrip('/')
        self.auth = (username, password)
        self.session = requests.Session()
        self.session.auth = self.auth
        self.session.headers.update({"Content-Type": "application/json"})

    def create_project(self, spec: Dict[str, Any]) -> requests.Response:
        """Create project with security policies."""
        # Ensure security defaults
        if "metadata" not in spec:
            spec["metadata"] = {}

        spec["metadata"].setdefault("enable_content_trust", "true")
        spec["metadata"].setdefault("prevent_vul", "true")
        spec["metadata"].setdefault("severity", "high")
        spec["metadata"].setdefault("auto_scan", "true")

        return self.session.post(
            f"{self.url}/api/v2.0/projects",
            json=spec
        )

    def set_gc_schedule(self, schedule: Dict[str, Any]) -> requests.Response:
        """Configure garbage collection schedule."""
        return self.session.post(
            f"{self.url}/api/v2.0/system/gc/schedule",
            json=schedule
        )
```

### Step 3: Refactor If Needed

After tests pass, refactor for better error handling and performance:

```python
# Refactored with retry logic and connection pooling
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

class HarborClient:
    def __init__(self, url: str, username: str, password: str):
        self.url = url.rstrip('/')
        self.auth = (username, password)
        self.session = self._create_session()

    def _create_session(self) -> requests.Session:
        """Create session with retry and connection pooling."""
        session = requests.Session()
        session.auth = self.auth
        session.headers.update({"Content-Type": "application/json"})

        # Configure retries for resilience
        retry_strategy = Retry(
            total=3,
            backoff_factor=1,
            status_forcelist=[429, 500, 502, 503, 504]
        )
        adapter = HTTPAdapter(
            max_retries=retry_strategy,
            pool_connections=10,
            pool_maxsize=10
        )
        session.mount("https://", adapter)

        return session
```

### Step 4: Run Full Verification

```bash
# Run all tests
pytest tests/test_harbor_config.py -v

# Run with coverage
pytest tests/test_harbor_config.py --cov=harbor_client --cov-report=term-missing

# Validate actual Harbor configuration
curl -s "https://harbor.example.com/api/v2.0/systeminfo" \
  -u "admin:password" | jq '.harbor_version'

# Test scanner connectivity
curl -s "https://harbor.example.com/api/v2.0/scanners" \
  -u "admin:password" | jq '.[].is_default'

# Verify replication endpoints
curl -s "https://harbor.example.com/api/v2.0/registries" \
  -u "admin:password" | jq '.[].status'
```

---

## 7. Performance Patterns

### Pattern 1: Garbage Collection Optimization

**Bad** - Infrequent GC causes storage bloat:
```bash
# ❌ Monthly GC - storage fills up
{
  "schedule": {
    "type": "Custom",
    "cron": "0 0 1 * *"
  },
  "parameters": {
    "delete_untagged": false
  }
}
```

**Good** - Regular GC with untagged deletion:
```bash
# ✅ Weekly GC with untagged cleanup
curl -X POST "https://harbor.example.com/api/v2.0/system/gc/schedule" \
  -u "admin:password" \
  -H "Content-Type: application/json" \
  -d '{
    "schedule": {
      "type": "Weekly",
      "cron": "0 2 * * 6"
    },
    "parameters": {
      "delete_untagged": true,
      "dry_run": false,
      "workers": 4
    }
  }'

# Monitor GC performance
curl -s "https://harbor.example.com/api/v2.0/system/gc" \
  -u "admin:password" | jq '.[-1] | {status, deleted, duration: (.end_time - .start_time)}'
```

### Pattern 2: Replication Optimization

**Bad** - Unfiltered full replication:
```bash
# ❌ Replicate everything - wastes bandwidth
{
  "name": "replicate-all",
  "filters": [],
  "trigger": {"type": "event_based"},
  "speed": 0
}
```

**Good** - Filtered scheduled replication with bandwidth control:
```bash
# ✅ Filtered replication with scheduling and rate limiting
curl -X POST "https://harbor.example.com/api/v2.0/replication/policies" \
  -u "admin:password" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "replicate-production",
    "filters": [
      {"type": "name", "value": "production/**"},
      {"type": "tag", "value": "v*"},
      {"type": "label", "value": "approved=true"}
    ],
    "trigger": {
      "type": "scheduled",
      "trigger_settings": {
        "cron": "0 */4 * * *"
      }
    },
    "speed": 10485760,
    "override": true,
    "enabled": true
  }'

# Monitor replication performance
curl -s "https://harbor.example.com/api/v2.0/replication/executions?policy_id=1" \
  -u "admin:password" | jq '[.[] | select(.status=="Succeed")] | length'
```

### Pattern 3: Caching and Proxy Configuration

**Bad** - No caching, direct pulls every time:
```bash
# ❌ Every pull hits upstream registry
docker pull docker.io/library/nginx:latest
# Slow and uses bandwidth
```

**Good** - Harbor as proxy cache:
```bash
# ✅ Configure proxy cache endpoint
curl -X POST "https://harbor.example.com/api/v2.0/registries" \
  -u "admin:password" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "dockerhub-cache",
    "type": "docker-hub",
    "url": "https://hub.docker.com",
    "credential": {
      "access_key": "username",
      "access_secret": "token"
    }
  }'

# Create proxy cache project
curl -X POST "https://harbor.example.com/api/v2.0/projects" \
  -u "admin:password" \
  -H "Content-Type: application/json" \
  -d '{
    "project_name": "dockerhub-proxy",
    "registry_id": 1,
    "public": true
  }'

# Pull through cache - subsequent pulls are instant
docker pull harbor.example.com/dockerhub-proxy/library/nginx:latest
```

### Pattern 4: Storage Backend Optimization

**Bad** - Local filesystem storage:
```bash
# ❌ Filesystem storage - no HA, backup complexity
storage_service:
  filesystem:
    rootdirectory: /data/registry
```

**Good** - Object storage with lifecycle policies:
```bash
# ✅ S3 storage with intelligent tiering
REGISTRY_STORAGE_PROVIDER_NAME=s3
REGISTRY_STORAGE_PROVIDER_CONFIG='{
  "bucket": "harbor-artifacts",
  "region": "us-east-1",
  "rootdirectory": "/harbor",
  "storageclass": "INTELLIGENT_TIERING",
  "multipartcopythresholdsize": 33554432,
  "multipartcopychunksize": 33554432,
  "multipartcopymaxconcurrency": 100,
  "encrypt": true,
  "v4auth": true
}'

# Configure lifecycle policy for old artifacts
aws s3api put-bucket-lifecycle-configuration \
  --bucket harbor-artifacts \
  --lifecycle-configuration '{
    "Rules": [{
      "ID": "archive-old-artifacts",
      "Status": "Enabled",
      "Filter": {"Prefix": "harbor/"},
      "Transitions": [{
        "Days": 90,
        "StorageClass": "GLACIER"
      }],
      "NoncurrentVersionTransitions": [{
        "NoncurrentDays": 30,
        "StorageClass": "GLACIER"
      }]
    }]
  }'
```

### Pattern 5: Database Connection Pooling

**Bad** - Default database connections:
```bash
# ❌ Default connections - bottleneck under load
POSTGRESQL_MAX_OPEN_CONNS=0
POSTGRESQL_MAX_IDLE_CONNS=2
```

**Good** - Optimized connection pool:
```bash
# ✅ Tuned connection pool for production
POSTGRESQL_HOST=postgres.example.com
POSTGRESQL_PORT=5432
POSTGRESQL_MAX_OPEN_CONNS=100
POSTGRESQL_MAX_IDLE_CONNS=50
POSTGRESQL_CONN_MAX_LIFETIME=5m
POSTGRESQL_SSLMODE=require

# Redis connection optimization
REDIS_HOST=redis.example.com:6379
REDIS_PASSWORD=${REDIS_PASSWORD}
REDIS_DB_INDEX=0
REDIS_IDLE_TIMEOUT_SECONDS=30

# Monitor connection usage
psql -h postgres.example.com -U harbor -c \
  "SELECT count(*) as active_connections FROM pg_stat_activity WHERE datname='registry';"
```

### Pattern 6: Scan Performance Tuning

**Bad** - Sequential scanning with long timeout:
```bash
# ❌ Slow scanning blocks pushes
SCANNER_TRIVY_TIMEOUT=30m
# No parallelization
```

**Good** - Parallel scanning with optimized settings:
```bash
# ✅ Optimized Trivy scanner configuration
trivy:
  environment:
    SCANNER_TRIVY_TIMEOUT: "10m"
    SCANNER_TRIVY_VULN_TYPE: "os,library"
    SCANNER_TRIVY_SEVERITY: "UNKNOWN,LOW,MEDIUM,HIGH,CRITICAL"
    SCANNER_TRIVY_SKIP_UPDATE: "false"
    SCANNER_TRIVY_GITHUB_TOKEN: "${GITHUB_TOKEN}"
    SCANNER_TRIVY_CACHE_DIR: "/home/scanner/.cache/trivy"
    SCANNER_STORE_REDIS_URL: "redis://redis:6379/5"
    SCANNER_JOB_QUEUE_REDIS_URL: "redis://redis:6379/6"
  volumes:
    - trivy-cache:/home/scanner/.cache/trivy
  deploy:
    replicas: 3
    resources:
      limits:
        memory: 4G
        cpus: '2'

# Pre-download vulnerability database
docker exec trivy trivy image --download-db-only
```

---

## 5. Security Standards

### 5.1 Image Signing Requirements

**Content Trust Policy**:
- All production images MUST be signed before deployment
- Use Cosign with keyless signing (OIDC) for transparency
- Attach SBOMs to all signed images
- Verify signatures in admission controllers (Kyverno)
- Track signature coverage metrics (target: 100% for prod)

**Signing Workflow**:
1. Build image in CI/CD pipeline
2. Scan with Trivy (must pass CVE policy)
3. Generate SBOM with Syft or Trivy
4. Sign image with Cosign (ephemeral keys via OIDC)
5. Attach SBOM as artifact
6. Push to Harbor registry
7. Verify signature before Kubernetes deployment

---

### 5.2 Vulnerability Management

**CVE Policy Enforcement**:
- **CRITICAL**: Block all deployments, require immediate fix
- **HIGH**: Block production, allow dev with time-bound exemption
- **MEDIUM**: Alert only, track in security dashboard
- **LOW/UNKNOWN**: Log for awareness

**Scan Configuration**:
- Scan on push: Enabled for all projects
- Automatic rescan: Daily at 2 AM UTC
- Vulnerability database update: Every 6 hours
- Scan timeout: 10 minutes per image
- Retention: Keep scan results for 90 days

**Exemption Process**:
1. Security team reviews CVE impact
2. Create allowlist entry with expiration date
3. Document mitigation or compensating controls
4. Track exemptions in compliance reports
5. Alert 7 days before exemption expires

---

### 5.3 RBAC and Access Control

**Project Roles**:
- **Project Admin**: Full control, manage members, configure policies
- **Developer**: Push/pull images, view scan results, cannot change policies
- **Guest**: Pull images only, read-...

© martinholovsky · Unlicense · martinholovsky/claude-skills-generator

Similar skills

All skills for DevOps and infrastructure →

From the same set50

The whole set →
typescript Enforces strict TypeScript conventions, Zod schema validation, and test-driven development in your coding agent. CX Codex +1 213installs async-expert async-expert guides AI coding agents through async development in Python, JS, C#, and Rust using TDD and API verification. CX Codex +1 212installs Cross-Platform Build Expert Cross-Platform Build Expert guides desktop application packaging for Windows, macOS, and Linux, focusing on Tauri setups, code signing, and CI/CD pipelines. CX Codex +1 210installs cloud-api-integration cloud-api-integration is a Claude Code skill for building cloud AI API integrations. It covers clients for Claude, GPT-4, and Gemini, including request security and provider fallback. CX Codex +1 203installs model-quantization model-quantization — a skill for Claude Code, Codex, Cursor, and other agents that adds LLM quantization expertise: 4-bit/8-bit levels, GGUF conversion, memory budgeting for constrained hardware. CX Codex +1 199installs pinia pinia is a Claude Code skill for designing Vue and Nuxt application stores using Composition API and TDD. It sets up typed Pinia stores, Vitest unit tests, and input validation rules. CX Codex +1 198installs Auto-Update Systems Expert Auto-Update Systems Expert walks through Tauri auto-updates: signed manifests, an HTTPS endpoint, rollback and phased rollouts. CX Codex +1 196installs dbus Guides secure D-Bus IPC development on Linux, covering method calls, signal handling, bus filtering, and test-driven workflows. CX Codex +1 195installs

Project sponsors

Companies that keep this analytics open