Merhaba! Ben

Federico Calò

Sviluppatore Software | Divulgatore Tecnico

Creo applicazioni web moderne e strumenti digitali personalizzati per aiutare le attività a crescere attraverso l'innovazione tecnologica. La mia passione è unire informatica ed economia per generare valore reale.

İletişime Geç

Hakkımda

La mia passione per l'informatica è nata tra i banchi dell'Istituto Tecnico Commerciale di Maglie, dove ho scoperto il potere della programmazione e il fascino di creare soluzioni digitali. Fin da subito, ho capito che l'informatica non era solo codice, ma uno strumento straordinario per trasformare idee in realtà.

Durante gli studi superiori in Sistemi Informativi Aziendali, ho iniziato a intrecciare informatica ed economia, comprendendo come la tecnologia possa essere il motore della crescita per qualsiasi attività. Questa visione mi ha accompagnato all'Università degli Studi di Bari, dove ho conseguito la Laurea in Informatica, approfondendo le mie competenze tecniche e la mia passione per lo sviluppo software.

Oggi metto questa esperienza al servizio di imprese, professionisti e startup, creando soluzioni digitali su misura che automatizzano processi, ottimizzano risorse e aprono nuove opportunità di business. Perché la vera innovazione inizia quando la tecnologia incontra le esigenze reali delle persone.

Yeteneklerim

Analisi Dati & Modelli Previsionali

Trasformo i dati in insights strategici con analisi approfondite e modelli predittivi per decisioni informate

Süreç Otomasyonu

Creo strumenti personalizzati che automatizzano operazioni ripetitive e liberano tempo per attività a valore aggiunto

Özel Sistemler

Sviluppo sistemi software su misura, dalle integrazioni tra piattaforme alle dashboard personalizzate

const federico = {
  nome: "Federico Calò",
  ruolo: "Sviluppatore Software",
  città: "Bari, Italia",
  missione: "Aiutare attraverso l'informatica",
  passioni: [
    "Codice Pulito",
    "Innovazione",
    "Crescita Continua"
  ]
};

Misyonum

Credo fermamente che l'informatica sia lo strumento più potente per trasformare le idee in realtà e migliorare la vita delle persone.

Teknolojiyi Demokratikleştirmek

La mia missione è rendere l'informatica accessibile a tutti: dalle piccole imprese locali alle startup innovative, fino ai professionisti che vogliono digitalizzare la propria attività. Ogni realtà merita di sfruttare le potenzialità del digitale.

BT ve İş Dünyasını Birleştirmek

Non è solo questione di scrivere codice: è capire come la tecnologia possa generare valore reale. Intrecciando competenze informatiche e visione economica, aiuto le attività a crescere, ottimizzare processi e raggiungere nuovi traguardi di efficienza e redditività.

Özel Çözümler Oluşturmak

Ogni attività è unica, e così devono esserlo le soluzioni. Sviluppo strumenti personalizzati che rispondono alle esigenze specifiche di ciascun cliente, automatizzando processi ripetitivi e liberando tempo per ciò che conta davvero: far crescere il business.

İşletmenizi Teknolojiyle Dönüştürün

Che tu gestisca un negozio, uno studio professionale o un'azienda, posso aiutarti a sfruttare le potenzialità dell'informatica per lavorare meglio, più velocemente e in modo più intelligente.

Konuşalım →

Unisciti alla Community

Entra nella community di sviluppatori dove discutiamo di software, AI, architettura e DevOps. Condividi idee, fai domande e cresci insieme a noi.

Canale

FC Dev Blog

Ricevi notifiche su nuovi articoli, serie complete, tips settimanali e tool in evidenza. Contenuti bilingui IT/EN direttamente nel tuo Telegram.

Nuovi articoli appena pubblicati
Tips e code snippets settimanali
Sondaggi sugli argomenti futuri

Iscriviti al Canale

Gruppo

FC Dev Community

Una community bilingue IT/EN per sviluppatori. Discussioni, Q&A, aiuto reciproco e networking con altri professionisti del settore.

Discussioni su articoli e tecnologie
Help coding e code review
Opportunità di lavoro e collaborazione

Unisciti al Gruppo

Topic di Discussione

Visualizza

Master SQL

RoadMap.sh

Novembre 2024

Visualizza

Oracle Certified Foundations Associate

Oracle

Ottobre 2024

Visualizza

People Leadership Credential

Connect

Settembre 2024

Linguaggi & Tecnologie

Java

Python

JavaScript

Angular

React

TypeScript

SQL

PHP

CSS/SCSS

Node.js

Docker

Git

💼

12/2024 - Presente

Custom Software Engineering Analyst

Accenture

Bari, Puglia, Italia · Ibrida Analisi e sviluppo di sistemi informatici attraverso l'utilizzo di Java e Quarkus in Health and Public Sector. Formazione continua su tecnologie moderne per la creazione di soluzioni software personalizzate ed efficienti e sugli agenti.

💼

06/2022 - 12/2024

Analista software e Back End Developer Associate Consultant

Links Management and Technology SpA

Esperienza nell'analisi di sistemi software as-is e flussi ETL utilizzando PowerCenter. Formazione completata su Spring Boot per lo sviluppo di applicazioni backend moderne e scalabili. Sviluppatore Backend specializzato in Spring Boot, con esperienza in progettazione di database, analisi, sviluppo e testing dei task assegnati.

💼

02/2021 - 10/2021

Programmatore software

Adesso.it (prima era WebScience srl)

Esperienza nell'analisi AS-IS e TO-BE, evoluzioni SEO ed evoluzioni website per migliorare le performance e l'engagement degli utenti.

🎓

2018 - 2025

Laurea in Informatica

Università degli Studi di Bari Aldo Moro

Bachelor's degree in Computer Science, focusing on software engineering, algorithms, and modern development practices.

📚

2013 - 2018

Diploma - Sistemi Informativi Aziendali

Istituto Tecnico Commerciale di Maglie

Technical diploma specializing in Business Information Systems, combining IT knowledge with business management.

İletişime Geç

Aklınızda bir proje mi var? Konuşalım! Formu doldurun, en kısa sürede dönüş yapacağım.

* Campi obbligatori. I tuoi dati saranno utilizzati solo per rispondere alla tua richiesta.

Kubernetes'te otomatik ölçeklendirme: HPA, VPA, KEDA ve Karpenter

Kubernetes'in üretimdeki temel avantajlarından biri otomatik olarak ölçeklendirme yeteneğidir talebe yanıt olarak iş yükleri. Ancak çoğu takım yalnızca bir kısmını kullanıyor Kullanılabilir otomatik ölçeklendirme yeteneklerinin sayısı: CPU ölçeklendirmeyle bir HPA yapılandırırlar ve bu şekilde bırakırlar. Sonuç? Yük altında yavaşlayan yetersiz tedarik edilmiş bölmeler veya aşırı tedarik edilmiş düğümler sebepsiz yere bütçeleri yakıyorlar.

Kubernetes dört tamamlayıcı otomatik ölçeklendirme düzeyi sunar: HPA ölçek yatay olarak CPU/bellek/özel ölçümlerdeki Pod'lar, VPA düzeltmek kaynak isteklerini otomatik olarak, KEDA olaya dayalı ölçeklendirmeyi etkinleştir herhangi bir kaynak (kuyruklar, veritabanları, Prometheus ölçümleri), e Marangoz Düğümlerin provizyonunu 30 saniyeden daha kısa sürede, geleneksel Küme Otomatik Ölçekleyiciden %40 daha hızlı sağlar CNCF 2025 kriterlerine göre. Bu makalede bunların üretimde birlikte nasıl kullanılacağı gösterilmektedir.

Ne Öğreneceksiniz

Yatay Kapsül Otomatik Ölçekleyici (HPA) özel ve harici ölçümlerle nasıl çalışır?
Otomatik doğru boyutlandırma için Dikey Pod Otomatik Ölçekleyiciyi (VPA) yapılandırma
KEDA: SQS, Kafka, Redis ve Prometheus kuyruklarında olay odaklı otomatik ölçeklendirme
Karpenter: NodePool ve NodeClass ile tam zamanında düğüm sağlama
Kombinasyon Modeli: HPA ve KEDA'yı çakışma olmadan birlikte kullanın
Sorun giderme: HPA'nız neden beklediğiniz gibi ölçeklenmiyor?
Flep döngülerinden ve soğuk başlatmalardan kaçınmak için en iyi uygulamalar

Yatay Kapsül Otomatik Ölçekleyici (HPA)

Bir Dağıtımın kopya sayısını ölçeklendiren HPA ve Kubernetes bileşeni, StatefulSet o ReplicaSet gözlemlenen ölçümlere dayalıdır. HPA denetleyicisi her seferinde metrikleri sorgular. 15 saniye (yapılandırılabilir) ve istenen kopya sayısını aşağıdaki formülle hesaplayın:

desiredReplicas = ceil(currentReplicas * (currentMetricValue / desiredMetricValue))

Çırpınmayı (sürekli yukarı ve aşağı ölçeklendirme) önlemek için HPA'nın bir stabilizasyon süresi vardır: Varsayılan olarak ölçek küçültme için 5 dakika ve ölçek büyütme için 0 saniye.

CPU ve Bellekte HPA

CPU ve bellek ile temel konfigürasyon. Belleğe ölçeklendirmek için uygulamanın yük azaldığında belleği boşaltması gerekir, aksi takdirde ölçek küçültme asla gerçekleşmez:

# hpa-basic.yaml
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: api-server-hpa
  namespace: production
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: api-server
  minReplicas: 2
  maxReplicas: 20
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 60  # scala quando CPU media > 60%
    - type: Resource
      resource:
        name: memory
        target:
          type: AverageValue
          averageValue: "512Mi"  # scala quando memoria media > 512Mi
  behavior:
    scaleUp:
      stabilizationWindowSeconds: 0  # scala su immediatamente
      policies:
        - type: Percent
          value: 100
          periodSeconds: 60  # max raddoppio delle repliche al minuto
        - type: Pods
          value: 4
          periodSeconds: 60  # o max 4 pod al minuto
      selectPolicy: Max  # usa la policy piu aggressiva
    scaleDown:
      stabilizationWindowSeconds: 300  # 5 minuti prima di scalare giu
      policies:
        - type: Percent
          value: 25
          periodSeconds: 60  # riduce max 25% delle repliche al minuto
      selectPolicy: Min

Prometheus Adaptörü aracılığıyla Özel Metriklere sahip HPA

Uygulama metriklerini (saniye başına istek sayısı, kuyruk uzunluğu vb.) ölçeklendirmek için Prometheus metriklerini Özel Metrics Kubernetes API'si olarak gösteren Prometheus Bağdaştırıcısı:

# Installa Prometheus Adapter
helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm install prometheus-adapter prometheus-community/prometheus-adapter \
  --namespace monitoring \
  --set prometheus.url=http://kube-prometheus-stack-prometheus.monitoring.svc \
  --set prometheus.port=9090

# prometheus-adapter-config.yaml - regola di mapping metrica
rules:
  custom:
    - seriesQuery: 'http_requests_total{namespace!="",pod!=""}'
      resources:
        overrides:
          namespace: {resource: "namespace"}
          pod: {resource: "pod"}
      name:
        matches: "^(.*)_total$"
        as: "${1}_per_second"
      metricsQuery: 'sum(rate(<<.Series>>{<<.LabelMatchers>>}[2m])) by (<<.GroupBy>>)'

---
# hpa-custom-metric.yaml
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: api-server-rps-hpa
  namespace: production
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: api-server
  minReplicas: 2
  maxReplicas: 50
  metrics:
    - type: Pods
      pods:
        metric:
          name: http_requests_per_second
        target:
          type: AverageValue
          averageValue: "1000"  # 1000 req/s per Pod

Harici Metriklerle HPA

Harici ölçümler, uzunluk gibi küme dışındaki kaynaklara göre ölçeklendirme yapmanıza olanak tanır SQS kuyruğunun veya tüketilmemiş Kafka mesajlarının sayısı:

# hpa-external-metric.yaml
# Scala in base alla lunghezza di una coda SQS
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: worker-queue-hpa
  namespace: production
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: queue-worker
  minReplicas: 1
  maxReplicas: 100
  metrics:
    - type: External
      external:
        metric:
          name: sqs_approximate_number_of_messages_visible
          selector:
            matchLabels:
              queue: "job-queue-prod"
        target:
          type: AverageValue
          averageValue: "10"  # 10 messaggi per worker

# Verifica stato HPA
kubectl get hpa -n production -w
kubectl describe hpa api-server-hpa -n production

Dikey Pod Otomatik Ölçekleyici (VPA)

VPA, Pod'larınızın gerçek CPU ve bellek kullanımını izler ve otomatik olarak ayarlar ben resources.requests e limits. Ve sorunun çözümü Kaynak isteklerinin "çöp girişi, çöp çıkışı": eğer sizinkinin kaç kaynağa ihtiyacı olduğunu bilmiyorsanız Pod, VPA senin için öğreniyor.

VPA ve HPA: Çatışmalara Dikkat Edin

modunda VPA kullanmayın Auto HPA'nın CPU veya belleğe ölçeklendirilmesiyle birlikte: iki kontrolör çatışacaktır. Doğru kombinasyon şu şekildedir: VPA modunda Off o Initial kaynak istekleri için ve çoğaltmalar için HPA özel metriklerde. Veya sorunu önlemek için HPA yerine KEDA'yı kullanın.

VPA Kurulumu ve Yapılandırması

# Installa VPA
git clone https://github.com/kubernetes/autoscaler.git
cd autoscaler/vertical-pod-autoscaler
./hack/vpa-install.sh

# oppure con Helm
helm repo add fairwinds-stable https://charts.fairwinds.com/stable
helm install vpa fairwinds-stable/vpa --namespace vpa --create-namespace

---
# vpa-recommendation.yaml - modalita Off (solo raccomandazioni)
apiVersion: autoscaling.k8s.io/v1
kind: VerticalPodAutoscaler
metadata:
  name: api-server-vpa
  namespace: production
spec:
  targetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: api-server
  updatePolicy:
    updateMode: "Off"  # Off|Initial|Recreate|Auto
  resourcePolicy:
    containerPolicies:
      - containerName: api-server
        minAllowed:
          cpu: "100m"
          memory: "128Mi"
        maxAllowed:
          cpu: "4"
          memory: "4Gi"
        controlledResources: ["cpu", "memory"]
        controlledValues: RequestsAndLimits

# Leggi le raccomandazioni VPA
kubectl describe vpa api-server-vpa -n production
# Output tipico:
#   Recommendation:
#     Container Recommendations:
#       Container Name: api-server
#         Lower Bound:    cpu: 100m, memory: 256Mi
#         Target:         cpu: 450m, memory: 512Mi
#         Uncapped Target: cpu: 450m, memory: 512Mi
#         Upper Bound:    cpu: 2000m, memory: 2Gi

Otomatik Modda VPA

# vpa-auto.yaml - aggiorna automaticamente i resource (riavvia i Pod)
apiVersion: autoscaling.k8s.io/v1
kind: VerticalPodAutoscaler
metadata:
  name: background-worker-vpa
  namespace: production
spec:
  targetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: background-worker
  updatePolicy:
    updateMode: "Auto"  # Riavvia i Pod con i nuovi resource
    minReplicas: 2      # Non aggiornare se le repliche sono meno di 2
  resourcePolicy:
    containerPolicies:
      - containerName: worker
        minAllowed:
          cpu: "200m"
          memory: "256Mi"
        maxAllowed:
          cpu: "2"
          memory: "2Gi"

KEDA: Olay Odaklı Otomatik Ölçeklendirme

KEDA (Kubernetes Olay Odaklı Otomatik Ölçeklendirme), HPA'yı aşağıdakilerle genişleten bir CNCF operatörüdür: 60'tan fazla önceden oluşturulmuş ölçekleyici: AWS SQS, Azure Service Bus, Kafka, RabbitMQ, Redis, Prometheus, Datadog ve çok daha fazlası. KEDA, aşağıdaki durumlarda bir dağıtımı 0 kopyaya ölçekleyebilir: hiçbir olay yoktur ve ilk olay geldiğinde bunu 1'e geri ayarlayın.

KEDA kurulumu

# Installa KEDA via Helm
helm repo add kedacore https://kedacore.github.io/charts
helm repo update
helm install keda kedacore/keda \
  --namespace keda \
  --create-namespace \
  --version 2.14.0

# Verifica
kubectl get pods -n keda

Kafka için ScaledObject

Kafka konusundan tüketen bir çalışan, tüketici grubunun gecikmesine göre ölçeklenir:

# keda-kafka-scaledobject.yaml
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: kafka-consumer-scaler
  namespace: production
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: kafka-consumer
  pollingInterval: 15       # controlla ogni 15 secondi
  cooldownPeriod: 30        # aspetta 30s prima di scalare a 0
  minReplicaCount: 0        # scala a zero se non ci sono messaggi
  maxReplicaCount: 50
  advanced:
    restoreToOriginalReplicaCount: true
    horizontalPodAutoscalerConfig:
      behavior:
        scaleDown:
          stabilizationWindowSeconds: 30
  triggers:
    - type: kafka
      metadata:
        bootstrapServers: kafka-broker.kafka.svc:9092
        consumerGroup: my-consumer-group
        topic: orders-topic
        lagThreshold: "100"     # 100 messaggi per replica
        offsetResetPolicy: latest
        allowIdleConsumers: "false"
        scaleToZeroOnInvalidOffset: "false"
      authenticationRef:
        name: kafka-auth  # TriggerAuthentication con credenziali Kafka

AWS SQS için ScaledObject

# keda-sqs-scaledobject.yaml
apiVersion: v1
kind: Secret
metadata:
  name: aws-credentials
  namespace: production
data:
  AWS_ACCESS_KEY_ID: BASE64_KEY
  AWS_SECRET_ACCESS_KEY: BASE64_SECRET
---
apiVersion: keda.sh/v1alpha1
kind: TriggerAuthentication
metadata:
  name: aws-trigger-auth
  namespace: production
spec:
  secretTargetRef:
    - parameter: awsAccessKeyID
      name: aws-credentials
      key: AWS_ACCESS_KEY_ID
    - parameter: awsSecretAccessKey
      name: aws-credentials
      key: AWS_SECRET_ACCESS_KEY
---
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: sqs-worker-scaler
  namespace: production
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: sqs-worker
  minReplicaCount: 0
  maxReplicaCount: 100
  triggers:
    - type: aws-sqs-queue
      authenticationRef:
        name: aws-trigger-auth
      metadata:
        queueURL: https://sqs.eu-west-1.amazonaws.com/123456789/job-queue
        queueLength: "5"       # 5 messaggi per replica
        awsRegion: eu-west-1
        identityOwner: pod     # usa IRSA se disponibile

Prometheus'ta ScaledObject

# keda-prometheus-scaledobject.yaml
# Scala in base a una query Prometheus personalizzata
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: api-latency-scaler
  namespace: production
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: api-server
  minReplicaCount: 2
  maxReplicaCount: 30
  triggers:
    - type: prometheus
      metadata:
        serverAddress: http://kube-prometheus-stack-prometheus.monitoring.svc:9090
        metricName: http_request_duration_p99
        threshold: "0.5"  # scala se P99 latency > 500ms
        query: histogram_quantile(0.99, sum(rate(http_request_duration_seconds_bucket{job="api-server"}[2m])) by (le))

# Verifica stato KEDA
kubectl get scaledobject -n production
kubectl describe scaledobject kafka-consumer-scaler -n production

Karpenter: Tam Zamanında Düğüm Sağlama

Karpenter, AWS ve şimdi de CNCF projesi tarafından oluşturulan yeni nesil düğüm sağlayıcısıdır. Önceden tanımlanmış düğüm gruplarıyla çalışan Cluster Autoscaler'ın aksine Karpenter bekleyen Pod'ların gerektirdiği tam özelliklere sahip provizyon düğümleri: örnek türü, alan, isteğe bağlı veya anlık kapasite, CPU/GPU. Sonuç: 30-60 saniyede temel hazırlık Küme Otomatik Ölçekleyici için 3-5 dakikaya karşılık.

Marangoz Mimarlık

Karpenter, Cluster Autoscaler'ın tamamen yerini alıyor. İki ana CRD'si vardır:

Düğüm Havuzu: Karpenter'in oluşturabileceği düğümlerin gereksinimlerini tanımlar (örnek türleri, bölgeler, kusurlar, etiketler, sınırlar)
NodeClass (AWS'de EC2NodeClass): bulut sağlayıcıya özel yapılandırma (AMI, alt ağ, güvenlik grupları, kullanıcı verileri)

EKS'ye Marangoz kurulumu

# Prerequisiti: IRSA configurata per Karpenter
export CLUSTER_NAME="my-production-cluster"
export AWS_ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)
export AWS_REGION=eu-west-1

# Installa Karpenter con Helm
helm repo add karpenter https://charts.karpenter.sh/
helm repo update

helm upgrade --install karpenter karpenter/karpenter \
  --namespace karpenter \
  --create-namespace \
  --version 1.0.0 \
  --set serviceAccount.annotations."eks.amazonaws.com/role-arn"=arn:aws:iam::${AWS_ACCOUNT_ID}:role/KarpenterControllerRole \
  --set settings.clusterName=${CLUSTER_NAME} \
  --set settings.interruptionQueue=${CLUSTER_NAME} \
  --set controller.resources.requests.cpu=1 \
  --set controller.resources.requests.memory=1Gi

Üretim için NodePool ve EC2NodeClass

# karpenter-nodepool.yaml
apiVersion: karpenter.sh/v1
kind: NodePool
metadata:
  name: general-purpose
spec:
  template:
    metadata:
      labels:
        node-type: general-purpose
    spec:
      nodeClassRef:
        apiVersion: karpenter.k8s.aws/v1
        kind: EC2NodeClass
        name: default
      requirements:
        - key: karpenter.sh/capacity-type
          operator: In
          values: ["on-demand", "spot"]  # preferisce spot, fallback on-demand
        - key: kubernetes.io/arch
          operator: In
          values: ["amd64"]
        - key: karpenter.k8s.aws/instance-category
          operator: In
          values: ["c", "m", "r"]  # compute, memory, general
        - key: karpenter.k8s.aws/instance-generation
          operator: Gt
          values: ["2"]  # solo istanze di generazione 3+
        - key: karpenter.k8s.aws/instance-cpu
          operator: In
          values: ["4", "8", "16", "32"]
      taints: []
      expireAfter: 720h    # ricicla nodi ogni 30 giorni
      terminationGracePeriod: 48h
  limits:
    cpu: "500"             # max 500 vCPU in questo NodePool
    memory: 2000Gi
  disruption:
    consolidationPolicy: WhenEmptyOrUnderutilized
    consolidateAfter: 1m  # consolida nodi vuoti dopo 1 minuto
    budgets:
      - nodes: "20%"      # non drainare piu del 20% dei nodi alla volta
---
apiVersion: karpenter.k8s.aws/v1
kind: EC2NodeClass
metadata:
  name: default
spec:
  amiFamily: AL2023
  amiSelectorTerms:
    - alias: al2023@latest   # usa sempre la AMI piu recente
  subnetSelectorTerms:
    - tags:
        karpenter.sh/discovery: "my-production-cluster"
  securityGroupSelectorTerms:
    - tags:
        karpenter.sh/discovery: "my-production-cluster"
  instanceProfile: KarpenterNodeInstanceProfile
  blockDeviceMappings:
    - deviceName: /dev/xvda
      ebs:
        volumeSize: 100Gi
        volumeType: gp3
        iops: 3000
        encrypted: true
  metadataOptions:
    httpEndpoint: enabled
    httpProtocolIPv6: disabled
    httpPutResponseHopLimit: 1   # sicurezza: blocca access IMDSv1 da container
    httpTokens: required         # richiede IMDSv2

GPU İş Yükleri için NodePool

# karpenter-gpu-nodepool.yaml
apiVersion: karpenter.sh/v1
kind: NodePool
metadata:
  name: gpu-nodes
spec:
  template:
    metadata:
      labels:
        node-type: gpu
    spec:
      nodeClassRef:
        apiVersion: karpenter.k8s.aws/v1
        kind: EC2NodeClass
        name: gpu-nodeclass
      requirements:
        - key: karpenter.sh/capacity-type
          operator: In
          values: ["on-demand"]  # GPU spot non disponibile in tutte le zone
        - key: karpenter.k8s.aws/instance-family
          operator: In
          values: ["g5", "p3", "p4d"]  # GPU instance families
      taints:
        - key: nvidia.com/gpu
          effect: NoSchedule      # solo Pod che tollerano questo taint
  limits:
    cpu: "128"
    memory: 1024Gi
    nvidia.com/gpu: "32"          # max 32 GPU in questo NodePool

Konsolidasyon ve Maliyet Optimizasyonu

# Forza la consolidazione immediata (utile per test)
kubectl annotate node  karpenter.sh/do-not-disrupt-

# Vedi i nodi creati da Karpenter
kubectl get nodes -l karpenter.sh/nodepool=general-purpose -o wide

# Vedi le decisioni di Karpenter in tempo reale
kubectl logs -n karpenter -l app.kubernetes.io/name=karpenter -f | grep -E "launched|terminated|consolidated"

# Vedi quanto sta costando ogni nodo (con Kubecost)
kubectl get nodeclaims -o json | jq '.items[] | {name: .metadata.name, type: .status.providerID, price: .metadata.annotations["karpenter.sh/nodepool"]}'

HPA, KEDA ve Karpenter'ı birleştirin

Olgun bir üretim kümesinde bu üç bileşen sinerjik olarak çalışır:

KEDA Olaylara göre Pod'ları 0'dan N'ye ölçeklendirin (Kafka gecikmesi, SQS derinliği, Prometheus sorgusu)
Marangoz Bekleyen Pod'ları algılar ve 30-60 saniye içinde gereken tam özelliklere sahip düğümleri hazırlar
VPA (Kapalı modunda), manuel olarak veya CI/CD hattı aracılığıyla uyguladığınız kaynak isteği önerilerini sağlar

Üretim için Önerilen Desen

Durum bilgisi olmayan sunucu API'si: Prometheus'ta KEDA (P99 gecikmesi) + Karpenter genel amaçlı NodePool
Kuyruk çalışanı: SQS/Kafka'da minReplicas=0 ile KEDA + isteğe bağlı/spot karışımıyla Karpenter
Database/StatefulSet: minReplicas >= 2 ile Otomatik modda VPA, bellekte HPA yok
Toplu işler: K8s İşlerinin sonlandırılması için KEDA ScaledJob (ScaledObject değil)
HPA'yı CPU'da KEDA ile birlikte kullanmayın; targetMetrics'te çakışmalara yol açar

Toplu İş için KEDA ScaledJob

# keda-scaledjob.yaml - per batch job che terminano
apiVersion: keda.sh/v1alpha1
kind: ScaledJob
metadata:
  name: ml-training-job
  namespace: production
spec:
  jobTargetRef:
    template:
      spec:
        containers:
          - name: trainer
            image: my-registry/ml-trainer:latest
            resources:
              requests:
                cpu: "2"
                memory: "4Gi"
                nvidia.com/gpu: "1"
              limits:
                nvidia.com/gpu: "1"
            tolerations:
              - key: nvidia.com/gpu
                operator: Exists
                effect: NoSchedule
        restartPolicy: Never
  pollingInterval: 30
  maxReplicaCount: 20
  successfulJobsHistoryLimit: 5
  failedJobsHistoryLimit: 3
  triggers:
    - type: aws-sqs-queue
      authenticationRef:
        name: aws-trigger-auth
      metadata:
        queueURL: https://sqs.eu-west-1.amazonaws.com/123456789/ml-jobs
        queueLength: "1"   # 1 job per task
        awsRegion: eu-west-1

HPA ve KEDA sorun giderme

# HPA non scala? Controlla lo stato
kubectl describe hpa api-server-hpa -n production
# Cerca: "AbleToScale", "ScalingActive", "DesiredReplicas"
# Errore comune: "failed to get cpu utilization" = metrics-server non installato

# Verifica che metrics-server funzioni
kubectl top pods -n production
kubectl top nodes

# KEDA non scala a zero? Controlla il cooldownPeriod
kubectl get scaledobject kafka-consumer-scaler -n production -o yaml | grep -A5 "conditions"

# Karpenter non provisiona?
kubectl get pods --field-selector=status.phase=Pending -A
kubectl describe pod  | grep "Events" -A20
# Cerca: "0/N nodes are available" + il motivo del pending

# Vedi log Karpenter
kubectl logs -n karpenter -l app.kubernetes.io/name=karpenter --tail=50 | grep -i "error\|warning\|launched"

# Simula provisioning senza applicare
kubectl annotate pods  karpenter.sh/do-not-disrupt=true

En İyi Uygulamalar ve Anti-Kalıplar

Otomatik Ölçeklendirmeye İlişkin En İyi Uygulamalar

Kritik hizmetler için her zaman minReplicas'ı >= 2 olarak ayarlayın: 0'dan ölçeklendirme soğuk başlatma gerektirir; Üretimdeki API'ler için en az 2 minimum kopya bulundurun
PodDisruptionBudget'ı kullanın: Karpenter/HPA'nın birleştirme sırasında çok fazla Kapsül boşaltmasını önleyin
Doğru kaynak isteklerini yapılandırın: HPA, kaynak isteklerindeki kullanım yüzdesini hesaplar; çok düşükse asla ölçeklenmez
Sıkı hazırlık araştırması: Kubernetes, trafiği göndermeden önce Pod'un Hazır olmasını bekler; Hazırlık araştırmaları olmadan, yeni ölçeklenen Kapsüller hazır olmadan önce trafik alır
Monitör kapakları: HPA birkaç dakikada bir yukarı ve aşağı ölçekleniyorsa, stabilizationWindowSeconds küçültme
Karpenter ile topoloji yayılma kısıtlamalarını kullanın: Sağlama sırasında bile yüksek kullanılabilirlik için Pod'ları bölgelere dağıtın

Kaçınılması Gereken Anti-Desenler

Kaynak istekleri tanımlanmamış HPA: HPA, konteyner spesifikasyonunda istekler olmadan kullanım yüzdesini hesaplayamıyor
CPU/Bellekte VPA Otomatik + HPA: iki denetleyici kaynaklar için rekabet eder ve tutarsız ölçeklendirmeye neden olur; Her ikisini de istiyorsanız özel metriklerde KEDA'yı kullanın
maxReplicas çok düşük: yoğun trafiğiniz 100 Kapsül ancak maxReplicas ve 20 Kapsül gerektiriyorsa, otomatik ölçeklendirme yeterli değildir ve hizmet kötüleşir
Karpenter'in bütçesi kesintiye uğramadan: olmadan disruption.budgets, Karpenter gece boyunca konsolidasyon sırasında düğümlerin %100'ünü boşaltabilir
KEDA'da oy verme aralığı çok düşük: un pollingInterval Harici kaynaklarda (SQS, harici API'ler) 5 saniyeden uzun süre kullanılması çok fazla API çağrısına ve olası kısıtlamalara neden olur

Sonuçlar ve Sonraki Adımlar

Kubernetes'te etkili otomatik ölçeklendirme tek bir çözüm değil çoklu bir stratejidir seviyeler: Pod'ların olay odaklı ölçeklendirilmesi için KEDA, kullanıma dayalı ölçeklendirme için HPA kaynak taleplerini optimize etmek için VPA ve tedarik için Karpenter düğümlerden çabuk kurtul. Bu araçlar birlikte kullanıldığında maliyetleri %30-50 oranında azaltabilir Statik olarak sağlanan kümelerle karşılaştırıldığında yüksek SLA'ları korur.

Başarının anahtarı, kaynak isteklerinin doğru yapılandırılmasıdır (VPA burada yardımcı olur), Ölçeklendirmek için doğru ölçümleri seçmek (her zaman CPU ve yanıt değil) ve ölçeklendirme davranışının yapılandırılması (stabilizasyon dönemleri, oran sınırlaması) Performansı iyileştirmek yerine kötüleştirebilecek salınımlardan kaçınmak için.