Kubernetes / Container: mercato

Posizione

un'offerta aperta che ha superato il controllo di qualità e indica almeno due tecnologie

Candidato osservato

un candidato il cui stack contiene questa tecnologia; un dato aggregato: nessun singolo record esce dal perimetro

Candidato abbinabile

non ancora conteggiato

Finestra

offerte aperte nel momento in cui è stato creato lo snapshot

Junior: ingresso tipico: DevOps Middle con esperienza K8s → Junior K8s Engineer (focus approfondito su K8s, ambito più ristretto). Il salto Junior → Middle: dopo il primo deployment K8s su scala di produzione + un Operator personalizzato scritto da sé. Middle → Senior: responsabilità multi-cluster + configurazione di un service mesh in produzione + esperienza operativa su scala di produzione (nodi). Senior → Kubernetes Architect: strategia K8s a livello di organizzazione + federazione multi-cluster + decisioni di architettura cloud-native. Percorso di carriera: DevOps Middle (2-3 anni) → Junior K8s (1-2 anni) → Middle (2-3 anni) → Senior → oppure Kubernetes Architect, K8s Operator developer (programmazione in Go in profondità), o passaggio al K8s nativo dei cloud: team AWS EKS / GCP GKE / Azure AKS.

I principali nel 5: kubernetes, devops, cloud, ci/cd, openshift. Padronanza profonda di Kubernetes: architettura di API server / scheduler / controller-manager / kubelet / etcd, padronanza di RBAC (Roles / ClusterRoles / RoleBindings + token dei ServiceAccount), Network Policies (NetworkPolicy + Cilium CiliumNetworkPolicy), Pod Security Standards (sostituiscono PSP dal 1.25), Resource Quotas + LimitRanges, HPA / VPA / Karpenter (autoscaler moderno: sostituisce Cluster Autoscaler nel contesto AWS), pattern Deployment / StatefulSet / DaemonSet / Job / CronJob. CRD + Operator personalizzati: Operator SDK / Kubebuilder (Go) o KOPF (Python). Progettare CRD + scrivere controller + gestire i reconciliation loop. Padronanza di Helm: scrittura di chart (template / gerarchie di values.yaml / hook / sub-chart / dipendenze), distribuzione tramite registry OCI, library chart. Kustomize: gestione della configurazione basata su overlay, alternativa / complemento a Helm. GitOps: ArgoCD (domina nel 2026: ApplicationSets per il multi-cluster, sync wave, sync hook, gerarchie di progetti) o FluxCD (leggero + nativo Helm). Service mesh: Istio (il più ricco di funzionalità: padronanza di VirtualService / DestinationRule / EnvoyFilter), Linkerd (il più semplice + leggero: control plane basato su Rust), Cilium (in crescita nel 2026: basato su eBPF, sostituisce kube-proxy + fornisce service mesh + Network Policies nel kernel + osservabilità Hubble). Networking: plugin CNI a fondo (Calico / Cilium / Weave / Flannel: scegline uno e approfondiscilo), Gateway API (il sostituto moderno di Ingress: GA 2024, HTTPRoute / Gateway / GatewayClass), Ingress controller (NGINX Ingress / Traefik / Contour / Istio Gateway). Storage: padronanza dei driver CSI, OpenEBS / Longhorn / Rook/Ceph (self-hosted) + CSI cloud (EBS / Persistent Disk / Azure Disk). Osservabilità: padronanza di Prometheus Operator (kube-prometheus-stack), Grafana Loki, OpenTelemetry Collector, Jaeger / Tempo per il tracing distribuito. Sicurezza: OPA Gatekeeper o Kyverno (applicazione delle policy: Kyverno più semplice, in crescita nel 2026), Falco (sicurezza a runtime), Trivy + Snyk Container + Grype (scansione delle immagini), Sigstore + cosign (supply chain: firma + verifica delle immagini), integrazione di External Secrets Operator / Sealed Secrets / Vault. Workflow / orchestrazione: padronanza di Argo Workflows (DAG / step / sospesi / event-driven), Argo Events, Tekton Pipelines, Knative (serverless su K8s). Carichi GPU (in crescita nel 2026 per IA / ML): NVIDIA GPU Operator, MIG (Multi-Instance GPU) per la condivisione delle GPU, Kueue per l'accodamento dei job, Volcano (scheduler batch). Multi-cluster: Karmada (orchestrazione multi-cluster), OpenChoreo, Cluster API (provisioning di cluster K8s tramite K8s), service mesh multi-cluster (Istio ambient mesh: multi-cluster 2024+). Linguaggi: Go principale (ecosistema K8s). Python secondario (Operator KOPF + script personalizzati).

Albero decisionale per l'orchestrazione dei container 2026: 1) Kubernetes: lo standard del settore dal 2018, domina l'orchestrazione dei container in produzione (>80% dell'enterprise). Caso d'uso: qualsiasi cosa oltre le applicazioni containerizzate più semplici + portabilità multi-cloud + enorme ecosistema. Compromessi: alta complessità (curva di apprendimento ripida + carico operativo), ma il mercato non ha alternative. 2) AWS ECS (Elastic Container Service): nativo AWS, più semplice di K8s. Caso d'uso: solo AWS + team piccolo + desiderio di semplicità gestita. Due varianti: ECS su EC2 (gestisci tu i nodi) o ECS Fargate (completamente gestito, senza nodi). Fargate: il migliore per carichi piccoli, costoso su larga scala. Compromessi: vincolo ad AWS, niente multi-cloud, ecosistema più piccolo. 3) Docker Swarm: l'alternativa di Docker a K8s. Stato 2026: morto. Docker Inc si concentra su Docker Desktop + Compose. Da usare solo per la manutenzione di sistemi legacy. Caso d'uso: aziende HashiCorp (che usano già Vault / Consul / Terraform) + desiderio di qualcosa di più semplice di K8s + multipiattaforma (container + VM + applicazioni Java + binari standalone). Compromessi: ecosistema più piccolo (anche se si integra con la mesh Consul), meno community + offerte. Scelta di nicchia. 5) Serverless (Lambda / Cloud Functions / Azure Functions): esegue funzioni senza gestire container. Caso d'uso: carichi event-driven, traffico sporadico, endpoint API semplici. Compromessi: vincolo al fornitore, latenza del cold start, limiti di esecuzione di 15 minuti, debug più difficile. 6) Cloud Run / Knative: container serverless (il meglio dei due mondi). Caso d'uso: applicazioni containerizzate + desiderio di scalabilità serverless (scale-to-zero) senza il carico operativo di K8s. GCP Cloud Run: la migliore implementazione. 7) PaaS moderni: Render, Railway, Fly.io, Heroku: deployment completamente gestito senza infrastruttura. Caso d'uso: startup + team piccoli + carichi piccoli. Raccomandazioni predefinite 2026: Grande enterprise + multi-cloud + a prova di futuro → Kubernetes. Solo AWS + team piccolo → ECS Fargate (o K8s tramite EKS se in crescita). Event-driven sporadico → funzioni serverless. Containerizzato + desiderio di serverless → Cloud Run / Knative. Azienda HashiCorp → Nomad. Un Senior K8s Engineer deve sapere quando K8s è la scelta sbagliata.

Stack K8s di produzione di riferimento 2026: 1) Provisioning del cluster: gestito (EKS / GKE / AKS) oppure Cluster API + provider Cluster API (vsphere / AWS / GCP / Azure) per l'autogestito. 2) CNI (Container Network Interface): Cilium (in crescita: basato su eBPF, sostituisce kube-proxy) oppure Calico (maturo) oppure Flannel (semplice). Cilium consigliato nel 2026: bonus: osservabilità Hubble + applicazione delle Network Policy nel kernel. 3) Ingress / Gateway: Gateway API (moderno, GA nel 2024: HTTPRoute / Gateway) con le implementazioni Cilium Gateway / Istio Gateway / Envoy Gateway / Kong Gateway. Legacy: NGINX Ingress Controller / Traefik / Contour. 4) Service mesh (facoltativo ma consigliato in produzione): Istio (più funzionalità: l'ambient mesh 2024+ evita l'overhead dei sidecar) oppure Linkerd (più semplice) oppure Cilium Service Mesh (basato su eBPF: nessun sidecar). 5) GitOps: ArgoCD (dominante: ApplicationSets per il multi-tenancy, sync waves, hook) oppure FluxCD. 6) Helm + Kustomize: gestione dei manifest. Helm per i pacchetti distribuiti, Kustomize per la configurazione per ambiente basata su overlay. 7) Gestione dei segreti: External Secrets Operator (in crescita: legge da Vault / AWS Secrets Manager / GCP Secret Manager / Azure Key Vault) oppure Sealed Secrets (per segreti cifrati compatibili con GitOps). 8) Applicazione delle policy: Kyverno (più semplice di OPA Gatekeeper, in crescita nel 2026) oppure OPA Gatekeeper. Imporre: label obbligatorie / registry delle immagini / limiti di risorse / security context. 9) Osservabilità: metriche: Prometheus Operator (kube-prometheus-stack) + Grafana + VictoriaMetrics / Mimir per l'archiviazione a lungo termine. 10) Osservabilità: log: Loki + Fluent Bit / Vector (Vector in crescita: scritto in Rust, più veloce). 11) Osservabilità: tracce: OpenTelemetry Collector + Jaeger o Tempo (stack Grafana). 12) Sicurezza a runtime: Falco (CNCF: rilevamento delle minacce a runtime basato su eBPF) + Cilium Tetragon (osservabilità di sicurezza eBPF: alternativa più recente). 13) Sicurezza delle immagini: Trivy (scansione) + Sigstore cosign (firma) + admission controller che verifica le firme. 14) Storage: driver CSI: cloud-native (EBS / Persistent Disk / Azure Disk) oppure OpenEBS / Longhorn / Rook/Ceph per il self-hosted. 15) Backup / DR: Velero (CNCF: esegue il backup delle risorse K8s + dei persistent volume, ripristina su un cluster diverso). Componenti aggiuntivi facoltativi 2026: KEDA (autoscaling guidato dagli eventi), Argo Workflows (batch / pipeline), Knative (serverless su K8s), NVIDIA GPU Operator (per i carichi AI / ML). Un Senior K8s Engineer sceglie + mantiene tutto questo stack: 15+ componenti.

Sì, il 28% delle offerte Kubernetes Engineer è completamente da remoto o ibrido. Il lavoro K8s è nel cloud come standard. Gli outsourcer: quasi sempre da remoto su progetti statunitensi. Russe: ibrido o da remoto dopo il periodo di prova. Aziende tech internazionali: completamente da remoto come standard. Aziende cloud-native (Aiven / Isovalent (Cilium) / Tigera / SUSE Rancher / Rafay): completamente da remoto, premium. Team K8s nelle Big Tech: ibrido come standard. Hub per chi si trasferisce: Polonia / Germania / Canada / Serbia / Georgia / Emirati Arabi Uniti. Inglese per il lavoro K8s internazionale da remoto: indispensabile (la community CNCF parla inglese, le conferenze KubeCon sono in inglese).

Senior Kubernetes Engineer: implementa + mantiene cluster K8s + Operator personalizzati. Il lavoro quotidiano: scrittura di chart Helm, debug dei problemi dei cluster, turni di reperibilità, tuning delle prestazioni, sviluppo di Operator. Molta programmazione (padronanza di Go per gli Operator). Kubernetes Architect: progetta la strategia K8s + federazione multi-cluster + architettura di service mesh + decisioni di architettura cloud-native. Il lavoro quotidiano: scrittura di ADR per le decisioni su K8s, revisioni di progetto, strategia di federazione multi-cluster (Karmada / OpenChoreo), scelta + topologia della service mesh, progettazione del framework di policy di sicurezza, capacity planning. Meno programmazione. Percorso di carriera: Senior K8s Engineer (4-6 anni) → K8s Architect → Principal K8s Architect / Cloud Native Architect. K8s Operator Developer (percorso alternativo: specializzazione con programmazione approfondita): scrive Operator K8s personalizzati in Go. Il lavoro quotidiano: programmazione in Go + progettazione di CRD + controller-runtime + test. Spesso lavora in aziende di prodotto dove K8s è la piattaforma principale (ad es. database nativi Kubernetes: operator K8s di Cockroach / Yugabyte / SingleStore, monitoraggio nativo K8s: integrazioni K8s di Datadog / Dynatrace). Scelta di carriera: Engineer per il lavoro quotidiano in prima persona, Architect per strategia + più team, Operator Developer per programmazione approfondita + ingegneria di prodotto.

Roadmap: 1) Base DevOps solida: Linux + padronanza di Docker + Git + basi di un cloud. 2) Fondamenti di Kubernetes: la Kubernetes Documentation ufficiale (kubernetes.io/docs: da leggere per intero la sezione Concepts), "Kubernetes in Action" di Lukša (il primo libro canonico), "Kubernetes Patterns" di Ibryam / Roß. 3) Pratica con K8s: configura un tuo cluster: kind (Kubernetes in Docker: per lo sviluppo locale), k3s (leggero, per edge / IoT / Raspberry Pi), minikube (a nodo singolo) o gestito nel cloud (EKS / GKE / AKS: idonei al Free Tier). Esegui il deploy di app reali. 4) Certificazione CKA (Certified Kubernetes Administrator): obbligatoria per i ruoli da K8s Engineer. Esame pratico (2 ore di pratica). Risorse: Killer.sh (il miglior esame di prova: incluso nell'acquisto della CKA), corso CKA di KodeKloud. 5) Certificazione CKAD (Certified Kubernetes Application Developer): per il lato sviluppatore. 6) Certificazione CKS (Certified Kubernetes Security Specialist): specializzazione premium. 7) Padronanza di Helm: scrittura dei chart (template / values / hook / dipendenze / library chart). Configura un repository di chart. 8) GitOps con ArgoCD: Application + ApplicationSets + Projects + sync hook. Configura ArgoCD sul tuo cluster + fai il deploy di un'app reale in stile GitOps. 9) Basi di service mesh: installa Istio o Linkerd sul tuo cluster, configura il routing del traffico + l'osservabilità. 10) CRD custom + Operator: programmazione in Go a livello Backend Middle + Operator SDK / Kubebuilder. Scrivi un Operator semplice (ad es. un backup-controller per gli StatefulSet). 11) Stack di osservabilità: installa kube-prometheus-stack + Grafana + Loki + Tempo, configura metriche custom + dashboard + alerting. 12) Stack di sicurezza: installa Falco + OPA Gatekeeper o Kyverno, scrivi policy di sicurezza. 13) Progetto personale avanzato: configurazione K8s di livello produzione con tutti i 15 componenti dello stack sul tuo cluster, documentata come portfolio su GitHub. 14) Contribuisci all'open source: trova una good-first-issue nei repository di Kubernetes / Helm / ArgoCD / Cilium. La community CNCF accoglie bene i nuovi contributori. Corsi russi: Slurm DevOps + K8s, Otus "Kubernetes Educator", Karpov.Courses K8s Track, KubeOps School. Internazionale (EN): talk di KubeCon su YouTube (gratuiti: da guardare assolutamente i 50 talk migliori), Learnk8s (corsi intensivi), KodeKloud Cloud-Native Learning Path, CNCF Curriculum (gratuito). Libri da leggere assolutamente: "Kubernetes Up & Running" di Burns / Beda / Hightower (3ª edizione: gli autori hanno inventato K8s), "Programming Kubernetes" di Hausenblas / Stefan Schimanski (per lo sviluppo di Operator). DevOps Middle → K8s Junior: 4-8 mesi.

307 active open Kubernetes Engineer positions — premium specialisation inside DevOps. Geography: the US, Poland, India. Time to close a Senior K8s Engineer role — 4-10 weeks (faster than SRE, but requires deep specialisation).

Un Senior Kubernetes Engineer gestisce l'intero ciclo dell'ecosistema K8s + operazioni su scala di produzione + leadership tecnica. Padronanza approfondita di Kubernetes: su scala di produzione (nodi), tutti i controller + oggetti API + admission controller + plugin dello scheduler. Padronanza di CRD + Operator personalizzati: programmazione in Go a livello Backend Senior + Operator SDK / Kubebuilder + controller-runtime + gestione dei reconciliation loop + leader election + versionamento delle risorse personalizzate + conversion webhook. Padronanza di Helm: scrittura di chart (template / gerarchie di values / hook / sub-chart / library chart), distribuzione tramite registry OCI, test dei chart (helm-unittest + chart-testing). Padronanza del GitOps: ArgoCD ApplicationSets per il multi-cluster + sync wave + hook + progetti + RBAC + integrazione della gestione dei segreti. Service mesh a fondo: service mesh Istio o Cilium: configurazione in produzione, mesh multi-cluster, mTLS, gestione del traffico, osservabilità. Networking a fondo: funzionamento interno dei plugin CNI (modello eBPF di Cilium o modello BGP di Calico), padronanza della Gateway API (HTTPRoute / Gateway / GatewayClass), progettazione dell'applicazione delle Network Policies. Padronanza della sicurezza: Pod Security Standards + padronanza dell'RBAC (progettazione least-privilege), framework di policy OPA Gatekeeper / Kyverno, sicurezza a runtime (Falco / Cilium Tetragon), sicurezza della supply chain (Sigstore + cosign + admission webhook che verificano le firme). Storage: funzionamento interno dei driver CSI + sviluppo di CSI personalizzati se necessario. Padronanza dell'osservabilità: Prometheus Operator avanzato (CRD ServiceMonitor / PodMonitor / Probe + recording rule + federazione), Grafana avanzato, OpenTelemetry Collector avanzato, tracing distribuito attraverso la mesh. Padronanza del multi-cluster: Cluster API per il provisioning, Karmada / OpenChoreo per la federazione, service mesh multi-cluster (Istio ambient mesh), strategie di DR multi-cluster. Carichi GPU (in crescita nel 2026 per IA / ML): NVIDIA GPU Operator avanzato, configurazione MIG, Kueue per l'accodamento dei job, scheduler batch Volcano. System design per le piattaforme K8s: progettare alla lavagna una piattaforma K8s multi-cluster su scala di 10.000+ nodi + multi-tenancy + multi-regione. Ottimizzazione delle prestazioni: benchmark dei cluster (kube-bench per il CIS / kube-burner per le prestazioni), tuning del control plane, tuning di etcd. Programmazione: padronanza di Go come linguaggio principale (per Operator + strumenti personalizzati). Python come secondo. Soft skill: scrittura di ADR per le decisioni su K8s, scrittura tecnica (documentazione dei chart + documenti di progettazione degli operator), revisione del codice per chart Helm + codice degli Operator, mentoring degli ingegneri K8s Middle, presentazioni alla KubeCon come bonus. Inglese OBBLIGATORIO per Senior+: community, documentazione e conferenze della CNCF sono in inglese. Bonus facoltativi: contributi open source al core di Kubernetes / Helm / ArgoCD / Cilium / Istio: aumentano nettamente il valore di mercato per le assunzioni nei team K8s delle Big Tech.