🏗️ Harbor + Nexus 하이브리드 아키텍처: 베스트 퍼포먼스

🎯 최적 성능 아키텍처 설계

📐 아키텍처 원칙

1. 역할 분리 기반 설계

Harbor (Container Specialist):
  역할: 컨테이너 이미지 전용
  대상: 운영 환경, 프로덕션 워크로드
  최적화: 컨테이너 푸시/풀 성능

Nexus (Package Repository):
  역할: 개발 의존성 패키지
  대상: 개발 환경, 빌드 프로세스
  최적화: Maven/npm 빌드 성능

2. 네트워크 지역성 최적화

배치 전략:
  Harbor: Kubernetes 클러스터 근접
  Nexus: 개발팀/CI 서버 근접
  
목적: 네트워크 레이턴시 최소화

🏛️ 베스트 퍼포먼스 아키텍처

Architecture Diagram

graph TB
    subgraph "Development Zone"
        DEV[개발자 PC]
        IDE[IDE/VSCode]
        CI[CI/CD Pipeline]
    end
    
    subgraph "Build Zone"
        NEXUS[Nexus Repository]
        BUILD[Build Servers]
        CACHE[Build Cache]
    end
    
    subgraph "Container Zone"
        HARBOR[Harbor Registry]
        SCAN[Security Scanner]
        REPLICA[Harbor Replica]
    end
    
    subgraph "Runtime Zone"
        K8S[Kubernetes Cluster]
        PODS[Application Pods]
        PROXY[Pull-through Cache]
    end
    
    DEV --> IDE
    IDE --> NEXUS
    CI --> NEXUS
    CI --> BUILD
    BUILD --> HARBOR
    HARBOR --> SCAN
    HARBOR --> K8S
    HARBOR --> REPLICA
    PROXY --> HARBOR
    K8S --> PODS

🚀 성능 최적화 전략

1. Harbor 클러스터 설계

# harbor-performance.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: harbor-performance-config
data:
  harbor.yml: |
    # 성능 최적화 설정
    database:
      type: postgresql
      postgresql:
        host: postgres-cluster.db.svc.cluster.local
        port: 5432
        database: registry
        username: harbor
        password: ${HARBOR_DB_PASSWORD}
        # 연결 풀 최적화
        max_idle_conns: 50
        max_open_conns: 1000
        conn_max_lifetime: 5m
    
    redis:
      # Redis 클러스터 사용
      host: redis-cluster.cache.svc.cluster.local:6379
      password: ${REDIS_PASSWORD}
      # 연결 풀 설정
      db: 0
      pool:
        max_idle: 100
        max_active: 1000
        idle_timeout: 300s
    
    storage:
      # 고성능 스토리지 백엔드
      s3:
        region: us-west-2
        bucket: harbor-registry-prod
        # 멀티파트 업로드 최적화
        multipartcopythresholdsize: 32MB
        multipartcopymaxconcurrency: 100
        # 청킹 최적화
        chunksize: 5MB
        
    # 로그 레벨 최적화 (운영 환경)
    log:
      level: warn
      
    # 성능 튜닝
    core:
      # 워커 프로세스 수 최적화
      workers: 16
      # 요청 타임아웃
      timeout: 300s
      
    registry:
      # 레지스트리 성능 설정
      workers: 8
      # 스토리지 드라이버 최적화
      storage_driver_config: |
        maintenance:
          uploadpurging:
            enabled: true
            age: 168h
            interval: 24h
            dryrun: false

2. Nexus 성능 최적화

# nexus-performance.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: nexus-performance-config
data:
  nexus.properties: |
    # JVM 힙 메모리 최적화
    -Xms4G
    -Xmx8G
    -XX:MaxDirectMemorySize=6G
    
    # GC 최적화
    -XX:+UseG1GC
    -XX:MaxGCPauseMillis=200
    -XX:G1HeapRegionSize=16m
    
    # 성능 튜닝
    -Dnexus.cleanup.retainDays=30
    -Dnexus.scripts.allowCreation=false
    
    # 데이터베이스 연결 풀
    nexus.datastore.connectionPool.maxPoolSize=50
    nexus.datastore.connectionPool.minPoolSize=10
    
    # HTTP 커넥터 최적화
    nexus.jetty.connector.http.acceptors=4
    nexus.jetty.connector.http.selectors=8
    
  cleanup.properties: |
    # 정리 작업 최적화
    cleanup.policy.retention.days=30
    cleanup.policy.last.downloaded.days=7
    cleanup.policy.last.blob.updated.days=3

3. 네트워크 최적화

# network-optimization.yaml
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: registry-network-optimization
spec:
  podSelector:
    matchLabels:
      app: harbor
  policyTypes:
  - Ingress
  - Egress
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          name: kube-system
    - namespaceSelector:
        matchLabels:
          name: development
    ports:
    - protocol: TCP
      port: 80
    - protocol: TCP
      port: 443
  
---
# 캐싱 레이어 추가
apiVersion: v1
kind: Service
metadata:
  name: harbor-cache-proxy
  annotations:
    # 연결 유지 최적화
    service.beta.kubernetes.io/aws-load-balancer-connection-idle-timeout: "300"
    # 스티키 세션
    service.beta.kubernetes.io/aws-load-balancer-target-group-attributes: stickiness.enabled=true
spec:
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: 8080
    name: http
  - port: 443
    targetPort: 8443
    name: https
  selector:
    app: harbor-proxy

🔄 워크플로우 기반 최적화

개발 단계 (Nexus 최적화)

# nexus-dev-optimization.yaml
Development Workflow:
  Phase 1 - Dependency Resolution:
    Tool: Nexus Repository
    Optimization:
      - Local SSD storage for Maven/.m2 cache
      - Nexus proxy repositories for public repos
      - Aggressive caching (7 days retention)
      - Parallel downloads enabled
    
    Performance Metrics:
      - Maven dependency resolution: < 30s
      - npm install: < 2 minutes
      - Nexus response time: < 100ms
      
  Configuration:
    maven:
      proxy_repositories:
        maven-central:
          remote_url: https://repo1.maven.org/maven2/
          cache_policy: "cache_for_7_days"
          download_policy: "parallel_max_10"
    
    npm:
      proxy_repositories:
        npmjs:
          remote_url: https://registry.npmjs.org/
          cache_policy: "cache_for_3_days"
          metadata_max_age: 1440  # 24 hours

빌드 단계 (Harbor 준비)

# build-stage-optimization.yaml
Build Workflow:
  Phase 2 - Container Build:
    Optimization:
      - Multi-stage Docker builds
      - Layer caching optimization
      - Parallel build stages
      - Build cache reuse
    
    Docker Build Config:
      DOCKER_BUILDKIT: 1
      BUILDKIT_PROGRESS: plain
      # 빌드 캐시 최적화
      build_args:
        - BUILDKIT_INLINE_CACHE=1
        - MAX_PARALLEL_DOWNLOADS=10
      
    Performance Targets:
      - Docker build time: < 5 minutes
      - Layer reuse rate: > 80%
      - Cache hit rate: > 70%

배포 단계 (Harbor 최적화)

# harbor-deployment-optimization.yaml
Deployment Workflow:
  Phase 3 - Container Registry:
    Tool: Harbor
    Optimization:
      - Pull-through cache for base images
      - Image layer deduplication
      - Parallel layer downloads
      - Regional replication
    
    Harbor Performance Config:
      registry:
        # 병렬 다운로드 최적화
        maxconcurrentuploads: 10
        maxconcurrentdownloads: 10
        
        # 청크 사이즈 최적화 (네트워크 대역폭 기반)
        # 고대역폭: 32MB, 일반: 5MB, 저대역폭: 1MB
        chunksize: 5242880  # 5MB
        
        # 타임아웃 설정
        timeout:
          read: 300s
          write: 300s
          
      # 스토리지 최적화
      storage:
        cache:
          blobdescriptor: redis
          # 메타데이터 캐시
          layerinfo: redis

🌐 멀티 리전 최적화

지역별 배치 전략

# multi-region-architecture.yaml
Regional Distribution:
  
  Primary Region (US-West):
    Harbor Primary:
      role: master
      storage: AWS S3 (us-west-2)
      capacity: 10TB
      performance: High IOPS SSD
      
    Nexus Primary:
      role: master
      storage: EBS GP3 (10,000 IOPS)
      capacity: 5TB
      
  Secondary Region (US-East):
    Harbor Replica:
      role: read-replica
      replication: real-time
      storage: AWS S3 (us-east-1)
      
    Nexus Cache:
      role: proxy-cache
      cache_size: 1TB
      cache_policy: "most_accessed_artifacts"
      
  Asian Region (AP-Northeast):
    Harbor Replica:
      role: read-replica
      replication: scheduled (every 4 hours)
      storage: AWS S3 (ap-northeast-1)
      
    Nexus Proxy:
      role: proxy-only
      cache_size: 500GB

네트워크 최적화

# network-performance.yaml
Network Optimization:
  
  CDN Integration:
    Harbor:
      - CloudFlare for image layers
      - Edge caching for frequently accessed images
      - Automatic cache invalidation
      
    Nexus:
      - Regional proxy servers
      - Smart routing based on client location
      
  Bandwidth Management:
    Upload:
      - Compression enabled
      - Delta sync for image layers
      - Resumable uploads
      
    Download:
      - Parallel connections (max 8)
      - Connection pooling
      - Keep-alive connections
      
  Monitoring:
    Metrics:
      - Network latency per region
      - Bandwidth utilization
      - Cache hit rates
      - Error rates

⚡ 성능 모니터링 및 최적화

성능 메트릭 수집

# monitoring-setup.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: performance-monitoring
data:
  prometheus.yml: |
    global:
      scrape_interval: 15s
      
    scrape_configs:
      # Harbor 메트릭
      - job_name: 'harbor'
        static_configs:
          - targets: ['harbor:8080']
        metrics_path: /api/v2.0/metrics
        
      # Nexus 메트릭
      - job_name: 'nexus'
        static_configs:
          - targets: ['nexus:8081']
        metrics_path: /service/metrics/prometheus
        
    # 성능 임계값 알림
    rule_files:
      - "performance_alerts.yml"
      
  performance_alerts.yml: |
    groups:
      - name: registry_performance
        rules:
          # Harbor 성능 알림
          - alert: HarborHighLatency
            expr: harbor_http_request_duration_seconds{quantile="0.95"} > 2
            for: 5m
            labels:
              severity: warning
            annotations:
              summary: "Harbor high latency detected"
              
          # Nexus 성능 알림
          - alert: NexusHighMemoryUsage
            expr: nexus_jvm_memory_used_bytes / nexus_jvm_memory_max_bytes > 0.85
            for: 5m
            labels:
              severity: warning
            annotations:
              summary: "Nexus high memory usage"

자동 스케일링

# auto-scaling.yaml
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: harbor-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: harbor-core
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: 80
  # 커스텀 메트릭 기반 스케일링
  - type: Object
    object:
      metric:
        name: harbor_concurrent_requests
      target:
        type: Value
        value: "100"
        
---
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: nexus-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: nexus
  minReplicas: 1
  maxReplicas: 3
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 75

🔧 CI/CD 파이프라인 최적화

파이프라인 단계별 최적화

# optimized-pipeline.yaml
Pipeline Stages:
  
  Stage 1 - Build Dependencies (Nexus):
    optimization:
      - Cache Maven/npm dependencies locally
      - Use Nexus proxy for faster downloads
      - Parallel dependency resolution
      
    implementation:
      cache_strategy: "aggressive"
      parallel_downloads: true
      local_cache_size: "10GB"
      
  Stage 2 - Application Build:
    optimization:
      - Use cached dependencies
      - Multi-stage Docker builds
      - Build cache reuse
      
    implementation:
      docker_buildkit: true
      cache_from: 
        - "harbor.company.com/cache/app-base:latest"
      build_args:
        - BUILDKIT_INLINE_CACHE=1
        
  Stage 3 - Security Scan (Harbor):
    optimization:
      - Scan only new layers
      - Parallel vulnerability scanning
      - Cache scan results
      
    implementation:
      scan_policy: "incremental"
      parallel_scanners: 4
      cache_scan_results: "7_days"
      
  Stage 4 - Deploy (Harbor):
    optimization:
      - Pre-pull images to nodes
      - Use image pull secrets
      - Optimize image pull policy
      
    implementation:
      image_pull_policy: "IfNotPresent"
      image_pull_secrets: ["harbor-registry-secret"]
      pre_pull_images: true

📊 성능 벤치마크 및 목표

성능 KPI

Performance Targets:

Harbor (Container Registry):
  Image Push:
    - Small images (< 100MB): < 30 seconds
    - Medium images (100MB-1GB): < 2 minutes  
    - Large images (> 1GB): < 5 minutes
    
  Image Pull:
    - First pull: < 1 minute per GB
    - Cached pull: < 10 seconds
    - Parallel pulls: 10+ concurrent
    
  API Response:
    - Catalog API: < 200ms
    - Manifest API: < 100ms
    - Blob API: < 50ms
    
Nexus (Package Repository):
  Maven Dependencies:
    - Initial build: < 5 minutes
    - Incremental build: < 30 seconds
    - Dependency resolution: < 100ms per artifact
    
  npm Packages:
    - npm install: < 2 minutes
    - npm ci: < 1 minute
    - Package search: < 500ms
    
  Storage Performance:
    - Read IOPS: > 10,000
    - Write IOPS: > 5,000
    - Throughput: > 1GB/s

🚀 최종 권장 아키텍처

Production-Ready Architecture

Recommended Setup:

Infrastructure:
  Harbor Cluster:
    - 3 nodes (master-master-master)
    - 16 CPU, 32GB RAM per node
    - 1TB NVMe SSD per node
    - S3 backend storage (multi-region)
    
  Nexus Cluster:
    - 2 nodes (active-passive)
    - 8 CPU, 16GB RAM per node  
    - 500GB NVMe SSD per node
    - PostgreSQL backend
    
  Network:
    - 10Gbps internal network
    - CDN for global distribution
    - Load balancers with health checks
    
Deployment Strategy:
  Phase 1: Infrastructure Setup (Week 1-2)
  Phase 2: Harbor Production Deployment (Week 3)
  Phase 3: Nexus Migration/Setup (Week 4)
  Phase 4: CI/CD Integration (Week 5-6)
  Phase 5: Performance Tuning (Week 7-8)
  
Monitoring:
  - Prometheus + Grafana dashboards
  - Custom performance metrics
  - Automated alerting
  - Capacity planning reports

이 아키텍처는 각 도구의 강점을 최대화하면서 성능 오버헤드를 최소화하는 설계입니다! 🎯