Kubernetes / Conteneurs : marché

Offre

une offre ouverte ayant passé le contrôle qualité et citant au moins deux technologies

Candidat observé

un candidat dont la stack contient cette technologie ; un agrégat — aucune fiche individuelle ne sort du périmètre

Candidat correspondant

pas encore compté

Fenêtre

offres ouvertes au moment de la création de l'instantané

Junior — entrée typique : DevOps Middle avec une expérience de K8s → Ingénieur K8s Junior (focus K8s en profondeur, périmètre plus étroit). Le saut Junior → Middle — après le premier déploiement K8s à l'échelle de la production + un opérateur personnalisé écrit. Middle → Senior — responsabilité multi-clusters + mise en place d'un service mesh en production + expérience d'exploitation à l'échelle de la production (nœuds). Senior → Architecte Kubernetes — stratégie K8s à l'échelle de l'organisation + fédération multi-clusters + décisions d'architecture cloud-native. Parcours de carrière : DevOps Middle (2-3 ans) → K8s Junior (1-2 ans) → Middle (2-3 ans) → Senior → soit Architecte Kubernetes, soit développeur d'opérateurs K8s (programmation Go en profondeur), soit passage au K8s natif d'un fournisseur cloud — équipes AWS EKS / GCP GKE / Azure AKS.

Top 5 : kubernetes, devops, cloud, ci/cd, openshift. Maîtrise approfondie de Kubernetes : architecture API server / scheduler / controller-manager / kubelet / etcd, maîtrise du RBAC (Roles / ClusterRoles / RoleBindings + jetons de ServiceAccount), Network Policies (NetworkPolicy + CiliumNetworkPolicy de Cilium), Pod Security Standards (remplacent les PSP depuis 1.25), Resource Quotas + LimitRanges, HPA / VPA / Karpenter (autoscaler moderne — remplace Cluster Autoscaler dans le contexte AWS), patterns Deployment / StatefulSet / DaemonSet / Job / CronJob. CRD personnalisées + opérateurs : Operator SDK / Kubebuilder (Go) ou KOPF (Python). Conception de CRD + écriture de contrôleurs + gestion des boucles de réconciliation. Maîtrise de Helm : écriture de charts (templates / hiérarchies de values.yaml / hooks / sous-charts / dépendances), distribution via registre OCI, library charts. Kustomize : gestion de configuration par overlays, alternative / complément à Helm. GitOps : ArgoCD (domine en 2026 — ApplicationSets pour le multicluster, sync waves, sync hooks, hiérarchies de projets) ou FluxCD (léger + natif Helm). Service mesh : Istio (le plus de fonctionnalités — maîtrise de VirtualService / DestinationRule / EnvoyFilter), Linkerd (le plus simple + léger — plan de contrôle en Rust), Cilium (en hausse en 2026 — basé sur eBPF, remplace kube-proxy + fournit un service mesh + les Network Policies dans le noyau + l'observabilité Hubble). Réseau : plugins CNI en profondeur (Calico / Cilium / Weave / Flannel — en choisir un et l'approfondir), Gateway API (remplaçant moderne d'Ingress — GA en 2024 — HTTPRoute / Gateway / GatewayClass), contrôleurs Ingress (NGINX Ingress / Traefik / Contour / Istio Gateway). Stockage : maîtrise des drivers CSI, OpenEBS / Longhorn / Rook/Ceph (auto-hébergés) + CSI cloud (EBS / Persistent Disk / Azure Disk). Observabilité : maîtrise de Prometheus Operator (kube-prometheus-stack), Grafana Loki, OpenTelemetry Collector, Jaeger / Tempo pour le traçage distribué. Sécurité : OPA Gatekeeper ou Kyverno (application des politiques — Kyverno plus simple, en hausse en 2026), Falco (sécurité au runtime), Trivy + Snyk Container + Grype (scan d'images), Sigstore + cosign (chaîne d'approvisionnement — signature + vérification d'images), External Secrets Operator / Sealed Secrets / intégration Vault. Workflows / orchestration : maîtrise d'Argo Workflows (DAG / étapes / suspendus / pilotés par événements), Argo Events, Tekton Pipelines, Knative (serverless sur K8s). Charges GPU (en hausse en 2026 pour l'IA / le ML) : NVIDIA GPU Operator, MIG (Multi-Instance GPU) pour le partage de GPU, Kueue pour la mise en file des jobs, Volcano (ordonnanceur batch). Multicluster : Karmada (orchestration multicluster), OpenChoreo, Cluster API (provisionnement de clusters K8s via K8s), service mesh multicluster (Istio ambient mesh — multicluster depuis 2024+). Langages : Go en premier (écosystème K8s). Python en second (opérateurs KOPF + scripts sur mesure).

Arbre de décision pour l'orchestration de conteneurs 2026 : 1) Kubernetes — standard du secteur depuis 2018, domine l'orchestration de conteneurs en production (>80 % des entreprises). Cas d'usage : tout ce qui dépasse les applications conteneurisées les plus simples + portabilité multi-cloud + immense écosystème. Compromis : complexité élevée (courbe d'apprentissage raide + charge opérationnelle), mais le marché n'a pas d'alternative. 2) AWS ECS (Elastic Container Service) — natif AWS, plus simple que K8s. Cas d'usage : uniquement AWS + petite équipe + recherche de simplicité managée. Deux variantes : ECS sur EC2 (vous gérez les nœuds) ou ECS Fargate (entièrement managé, sans nœuds). Fargate — idéal pour les petits workloads, coûteux à grande échelle. Compromis : dépendance à AWS, pas de multi-cloud, écosystème plus restreint. 3) Docker Swarm — l'alternative de Docker à K8s. Statut 2026 : mort. Docker Inc se concentre sur Docker Desktop + Compose. À n'utiliser que pour la maintenance legacy. Cas d'usage : environnement HashiCorp (utilisant déjà Vault / Consul / Terraform) + recherche de plus de simplicité que K8s + multi-plateforme (conteneurs + VM + applications Java + binaires autonomes). Compromis : écosystème plus restreint (même s'il s'intègre au mesh Consul), moins de communauté + d'offres. Choix de niche. 5) Serverless (Lambda / Cloud Functions / Azure Functions) — exécute des fonctions sans gérer de conteneurs. Cas d'usage : workloads événementiels, trafic sporadique, endpoints d'API simples. Compromis : dépendance au fournisseur, latence de cold start, limites d'exécution de 15 minutes, débogage plus difficile. 6) Cloud Run / Knative — conteneurs serverless (le meilleur des deux mondes). Cas d'usage : applications conteneurisées + besoin d'un scaling serverless (scale-to-zero) sans la charge opérationnelle de K8s. GCP Cloud Run — la meilleure implémentation. 7) PaaS modernes : Render, Railway, Fly.io, Heroku — déploiement entièrement managé sans infrastructure. Cas d'usage : startups + petites équipes + petits workloads. Recommandations par défaut 2026 : Grande entreprise + multi-cloud + pérennité → Kubernetes. Uniquement AWS + petite équipe → ECS Fargate (ou K8s via EKS en cas de croissance). Événementiel sporadique → fonctions serverless. Conteneurisé + besoin de serverless → Cloud Run / Knative. Environnement HashiCorp → Nomad. Un Senior K8s Engineer doit savoir quand K8s est le mauvais choix.

Stack K8s de production de référence 2026 : 1) Provisionnement des clusters — managé (EKS / GKE / AKS) ou Cluster API + fournisseurs Cluster API (vsphere / AWS / GCP / Azure) pour l'auto-géré. 2) CNI (Container Network Interface) — Cilium (en croissance — basé sur eBPF, remplace kube-proxy) ou Calico (mature) ou Flannel (simple). Cilium recommandé 2026 — bonus : observabilité Hubble + application des Network Policies dans le noyau. 3) Ingress / Gateway — Gateway API (moderne, GA 2024 — HTTPRoute / Gateway) avec les implémentations Cilium Gateway / Istio Gateway / Envoy Gateway / Kong Gateway. Historique : NGINX Ingress Controller / Traefik / Contour. 4) Service mesh (facultatif mais recommandé en production) : Istio (le plus de fonctionnalités — l'ambient mesh 2024+ évite le surcoût des sidecars) ou Linkerd (plus simple) ou Cilium Service Mesh (basé sur eBPF — pas de sidecars du tout). 5) GitOps — ArgoCD (dominant — ApplicationSets pour le multi-tenant, sync waves, hooks) ou FluxCD. 6) Helm + Kustomize — gestion des manifestes. Helm pour les paquets distribués, Kustomize pour la configuration par environnement à base d'overlays. 7) Gestion des secrets — External Secrets Operator (en croissance — récupère depuis Vault / AWS Secrets Manager / GCP Secret Manager / Azure Key Vault) ou Sealed Secrets (secrets chiffrés compatibles GitOps). 8) Application des politiques — Kyverno (plus simple qu'OPA Gatekeeper, en croissance 2026) ou OPA Gatekeeper. Imposer : labels obligatoires / registres d'images / limites de ressources / contextes de sécurité. 9) Observabilité — métriques : Prometheus Operator (kube-prometheus-stack) + Grafana + VictoriaMetrics / Mimir pour le stockage à long terme. 10) Observabilité — journaux : Loki + Fluent Bit / Vector (Vector en croissance — écrit en Rust, plus rapide). 11) Observabilité — traces : OpenTelemetry Collector + Jaeger ou Tempo (stack Grafana). 12) Sécurité à l'exécution : Falco (CNCF — détection des menaces à l'exécution basée sur eBPF) + Cilium Tetragon (observabilité de sécurité eBPF — alternative plus récente). 13) Sécurité des images : Trivy (scan) + Sigstore cosign (signature) + contrôleur d'admission vérifiant les signatures. 14) Stockage : pilotes CSI — natifs du cloud (EBS / Persistent Disk / Azure Disk) ou OpenEBS / Longhorn / Rook/Ceph en auto-hébergé. 15) Sauvegarde / PRA : Velero (CNCF — sauvegarde les ressources K8s + les volumes persistants, restaure vers un autre cluster). Modules complémentaires facultatifs 2026 : KEDA (autoscaling piloté par les événements), Argo Workflows (batch / pipelines), Knative (serverless sur K8s), NVIDIA GPU Operator (pour les charges IA / ML). Un ingénieur K8s Senior choisit + maintient toute cette stack — 15+ composants.

Oui, 28 % des offres d'ingénieur Kubernetes sont entièrement à distance ou hybrides. Le travail K8s se fait par défaut dans le cloud. Les sociétés d'outsourcing — presque toujours à distance sur des projets américains. Entreprises russes — hybride ou à distance après la période d'essai. Entreprises tech internationales — tout à distance standard. Entreprises cloud-native (Aiven / Isovalent (Cilium) / Tigera / SUSE Rancher / Rafay) — tout à distance premium. Équipes K8s des Big Tech — hybride standard. Pôles d'expatriation : Pologne / Allemagne / Canada / Serbie / Géorgie / Émirats arabes unis. L'anglais pour le télétravail K8s international — indispensable (la communauté CNCF est anglophone, les conférences KubeCon sont en anglais).

Ingénieur Kubernetes Senior — met en œuvre + maintient les clusters K8s + les opérateurs sur mesure. Au quotidien : écriture de charts Helm, débogage des problèmes de cluster, rotation d'astreinte, optimisation des performances, développement d'opérateurs. Beaucoup de programmation (maîtrise de Go pour les opérateurs). Architecte Kubernetes — conçoit la stratégie K8s + la fédération multi-clusters + l'architecture de service mesh + les décisions d'architecture cloud-native. Au quotidien : rédaction d'ADR pour les décisions K8s, revues de conception, stratégie de fédération multi-clusters (Karmada / OpenChoreo), choix + topologie du service mesh, conception du cadre de politiques de sécurité, planification de capacité. Moins de programmation. Parcours de carrière : Ingénieur K8s Senior (4-6 ans) → Architecte K8s → Architecte K8s Principal / Architecte Cloud Native. Développeur d'opérateurs K8s (voie alternative — spécialisation approfondie en programmation) — écrit des opérateurs K8s sur mesure en Go. Au quotidien : programmation Go + conception de CRD + controller-runtime + tests. Travaille souvent dans des entreprises produit où K8s est la plateforme principale (p. ex. bases de données natives Kubernetes — opérateurs K8s de Cockroach / Yugabyte / SingleStore, monitoring natif K8s — intégrations K8s de Datadog / Dynatrace). Choix de carrière : Ingénieur pour le concret au quotidien, Architecte pour la stratégie + le multi-équipes, Développeur d'opérateurs pour la programmation en profondeur + l'ingénierie produit.

Feuille de route : 1) Socle DevOps solide — Linux + maîtrise de Docker + Git + bases d'un cloud. 2) Fondamentaux de Kubernetes — la documentation officielle de Kubernetes (kubernetes.io/docs — lire entièrement la section Concepts), « Kubernetes in Action » de Lukša (le premier livre canonique), « Kubernetes Patterns » d'Ibryam / Roß. 3) Pratique de K8s — monter votre propre cluster : kind (Kubernetes in Docker — pour le développement local), k3s (léger, pour l'edge / l'IoT / le Raspberry Pi), minikube (nœud unique) ou un service managé (EKS / GKE / AKS — éligibles à l'offre gratuite). Déployer de vraies applications. 4) Certification CKA (Certified Kubernetes Administrator) — indispensable pour les postes d'ingénieur K8s. Examen pratique (2 heures de mise en pratique). Ressources : Killer.sh (le meilleur examen blanc — inclus avec l'achat du CKA), formation CKA de KodeKloud. 5) Certification CKAD (Certified Kubernetes Application Developer) — pour le côté développeur. 6) Certification CKS (Certified Kubernetes Security Specialist) — spécialité premium. 7) Maîtrise de Helm — écriture de charts (templates / values / hooks / dépendances / library charts). Mettre en place un dépôt de charts. 8) GitOps avec ArgoCD — Application + ApplicationSets + Projects + sync hooks. Installer ArgoCD sur votre propre cluster + déployer une vraie application en mode GitOps. 9) Bases du service mesh — installer Istio ou Linkerd sur votre propre cluster, configurer le routage du trafic + l'observabilité. 10) CRD personnalisés + Operators — programmation Go au niveau Backend Middle + Operator SDK / Kubebuilder. Écrire un Operator simple (par ex. un contrôleur de sauvegarde pour les StatefulSets). 11) Stack d'observabilité — installer kube-prometheus-stack + Grafana + Loki + Tempo, configurer des métriques personnalisées + tableaux de bord + alertes. 12) Stack de sécurité — installer Falco + OPA Gatekeeper ou Kyverno, écrire des politiques de sécurité. 13) Projet personnel avancé : une configuration K8s de niveau production avec les 15 composants de la stack sur votre propre cluster — à documenter comme portfolio GitHub. 14) Contribuer à l'open source — trouver des good-first-issue dans les dépôts Kubernetes / Helm / ArgoCD / Cilium. La communauté CNCF accueille bien les nouveaux contributeurs. Formations russes : Slurm DevOps + K8s, Otus « Kubernetes Educator », Karpov.Courses K8s Track, KubeOps School. International (EN) : conférences KubeCon sur YouTube (gratuites — regarder absolument les 50 meilleures), Learnk8s (formations intensives), KodeKloud Cloud-Native Learning Path, CNCF Curriculum (gratuit). Livres à lire absolument : « Kubernetes Up & Running » de Burns / Beda / Hightower (3e édition — les auteurs ont inventé K8s), « Programming Kubernetes » de Hausenblas / Stefan Schimanski (pour le développement d'Operators). DevOps Middle → K8s Junior — 4-8 mois.

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 Ingénieur Kubernetes Senior prend en charge le cycle complet de l'écosystème K8s + l'exploitation à l'échelle de la production + le leadership technique. Maîtrise approfondie de Kubernetes : à l'échelle de la production (nœuds), tous les contrôleurs + objets API + admission controllers + plugins du scheduler. Maîtrise des CRD + Operators personnalisés : programmation Go au niveau Backend Senior + Operator SDK / Kubebuilder + controller-runtime + gestion des boucles de réconciliation + élection de leader + versionnage des ressources personnalisées + webhooks de conversion. Maîtrise de Helm : écriture de charts (templates / hiérarchies de values / hooks / sous-charts / charts de bibliothèque), distribution via registre OCI, tests de charts (helm-unittest + chart-testing). Maîtrise du GitOps : ArgoCD ApplicationSets pour le multi-cluster + sync waves + hooks + projets + RBAC + intégration de la gestion des secrets. Service mesh en profondeur : Istio ou service mesh Cilium — mise en place en production, mesh multi-cluster, mTLS, gestion du trafic, observabilité. Réseau en profondeur : fonctionnement interne des plugins CNI (modèle eBPF de Cilium ou modèle BGP de Calico), maîtrise de la Gateway API (HTTPRoute / Gateway / GatewayClass), conception de l'application des Network Policies. Maîtrise de la sécurité : Pod Security Standards + maîtrise du RBAC (conception du moindre privilège), cadre de politiques OPA Gatekeeper / Kyverno, sécurité à l'exécution (Falco / Cilium Tetragon), sécurité de la chaîne d'approvisionnement (Sigstore + cosign + webhooks d'admission vérifiant les signatures). Stockage : fonctionnement interne des drivers CSI + développement de CSI personnalisés si nécessaire. Maîtrise de l'observabilité : Prometheus Operator avancé (CRD ServiceMonitor / PodMonitor / Probe + recording rules + fédération), Grafana avancé, OpenTelemetry Collector avancé, traçage distribué à travers le mesh. Maîtrise du multi-cluster : Cluster API pour le provisionnement, Karmada / OpenChoreo pour la fédération, service mesh multi-cluster (Istio ambient mesh), stratégies de reprise multi-cluster. Charges GPU (en hausse en 2026 pour l'IA / le ML) : NVIDIA GPU Operator avancé, configuration MIG, Kueue pour la mise en file des jobs, scheduler batch Volcano. Conception de systèmes pour les plateformes K8s : concevoir au tableau blanc une plateforme K8s multi-cluster à l'échelle de 10 000+ nœuds + multi-tenant + multi-région. Optimisation des performances : benchmark de clusters (kube-bench pour le CIS / kube-burner pour la performance), réglage du control plane, réglage d'etcd. Programmation : maîtrise de Go en langage principal (pour les Operators + l'outillage sur mesure). Python en secondaire. Soft skills : rédaction d'ADR pour les décisions K8s, rédaction technique (documentation des charts + documents de conception des operators), revue de code des charts Helm + du code des Operators, mentorat d'ingénieurs K8s Middle, présentations à KubeCon en bonus. Anglais INDISPENSABLE pour Senior+ — la communauté CNCF / la documentation / les conférences sont en anglais. Bonus facultatif : contributions open source au cœur de Kubernetes / Helm / ArgoCD / Cilium / Istio — augmentent fortement la valeur sur le marché pour le recrutement dans les équipes K8s des Big Tech.