Compétences DevSecOps à apprendre : cartographie 2026

Les compétences DevSecOps à apprendre en 2026 se structurent autour de 7 piliers interdépendants, acquis typiquement sur 12-18 mois avec 10-15 heures hebdomadaires soutenues pour un profil dev ou DevOps confirmé. Les 4 piliers socle junior (à maîtriser avant embauche) : Git et CI/CD (GitHub Actions dominant scale-ups, GitLab CI grands groupes), conteneurs et Kubernetes (Docker multi-stage non-root distroless, K8s RBAC NetworkPolicy Pod Security Standards), cloud majeur (AWS 60 % du marché FR, alternative Azure ou GCP), Infrastructure as Code (Terraform dominant, scanners Checkov et tfsec). Les 3 piliers confirmé (à acquérir dans les 18-24 mois suivant l'embauche) : SAST/DAST/SCA (Semgrep, OWASP ZAP, Snyk, Trivy, Grype), secrets management (HashiCorp Vault, AWS Secrets Manager, OIDC federation CI/CD), supply chain security (SBOM CycloneDX, SLSA v1.0, Sigstore Cosign signature). Les langages indispensables : Python et Bash obligatoires, Go et YAML fortement recommandés, HCL (Terraform) et Rego (OPA) pour policy-as-code. La séquence certifications recommandée : CompTIA Security+ → HashiCorp Terraform Associate → AWS Security Specialty ou SC-100 → CKS, pour un budget total de 900-1 500 € amorti en 1-2 mois à l'embauche (DevSecOps junior 48-65 k€ brut IDF). Zeroday Cyber Academy recommande la séquentialité (un pilier à la fois avec consolidation active) plutôt que la parallélisation — un candidat maîtrisant profondément 4 piliers convertit mieux en entretien qu'un candidat qui a survolé les 7. Cet article détaille la cartographie complète des 7 piliers, le tooling 2026 par pilier, la priorisation junior versus senior, les soft skills essentielles, l'ordre d'acquisition et notre bilan factuel.

1. Cartographie des 7 piliers de compétences

Observation clé : chaque pilier a une profondeur junior (utilisation correcte des outils standards) et une profondeur senior (configuration avancée, customisation, résolution de problèmes complexes). La progression verticale sur chaque pilier prend 1-3 ans selon l'exposition terrain.

2. Pilier 1 — Git et CI/CD

Compétences junior obligatoires

• Git fluency : commandes standards (clone, branch, commit, merge, rebase, cherry-pick), workflow fork/PR, résolution de conflits, bisect pour debug.
• Workflow : GitFlow ou Trunk-based Development, branches conventions, tagging sémantique SemVer.
• CI/CD de base : écriture d'un workflow GitHub Actions ou GitLab CI simple avec build plus test plus déploiement.
• Variables et secrets : configuration secrets CI, compréhension OIDC federation (vs long-lived keys).
• Artifacts : upload/download, rétention, signature basique.

Compétences senior

• Pipelines complexes : matrix builds, reusable workflows, composite actions, self-hosted runners avec hardening.
• Optimisation : caching efficace, parallélisation tests, stratégies blue/green ou canary.
• Supply chain CI : signature workflow, SLSA provenance, verification chain.
• Monitoring pipeline : métriques DORA, dashboards qualité, alertes.

Outils leaders 2026

• GitHub Actions (dominant scale-ups tech françaises, 70 % part de marché scale-ups).
• GitLab CI (grands groupes CAC 40, secteur public, banque-assurance).
• Jenkins (legacy mais encore présent, migration progressive).
• Atlantis (Terraform workflows GitOps).
• ArgoCD et Flux (GitOps Kubernetes).

3. Pilier 2 — Conteneurs et Kubernetes

Compétences junior obligatoires

• Docker : Dockerfile avec multi-stage builds, non-root user, distroless ou minimal base images, COPY --chown, HEALTHCHECK.
• Docker Compose : local dev, networking, volumes.
• Kubernetes basics : Pods, Services, Deployments, ConfigMaps, Secrets, kubectl fluency.
• Manifests YAML : structure, kustomize overlays, Helm charts basiques.
• Security basics K8s : RBAC (Roles, RoleBindings), NetworkPolicy, Pod Security Standards (baseline, restricted).

Compétences senior

• K8s avancé : Operators, CRDs, Webhooks, admission controllers.
• Hardening : CIS Kubernetes Benchmark, kube-bench, kubescape, Falco runtime.
• Service mesh : Istio ou Linkerd pour mTLS et observabilité.
• Policy-as-code : Kyverno ou OPA Gatekeeper pour admission policies.

Exemple de Dockerfile sécurisé (pattern recommandé 2026) :

# Dockerfile securise pattern recommande 2026.
# Multi-stage build avec distroless et non-root.
 
# --- Stage 1 - Build ---
FROM node:20.10.0-alpine AS builder
WORKDIR /app
 
# Install dependencies avec lockfile stricte
COPY package.json package-lock.json ./
RUN npm ci --only=production && npm cache clean --force
 
# Copy source et build
COPY . .
RUN npm run build
 
# --- Stage 2 - Runtime ---
FROM gcr.io/distroless/nodejs20-debian12:nonroot
 
WORKDIR /app
 
# Copy uniquement les artefacts necessaires (non-root user 65532)
COPY --from=builder --chown=nonroot:nonroot /app/node_modules ./node_modules
COPY --from=builder --chown=nonroot:nonroot /app/dist ./dist
COPY --from=builder --chown=nonroot:nonroot /app/package.json ./
 
# Configuration runtime
USER nonroot
EXPOSE 3000
 
# Health check pour Kubernetes liveness/readiness
HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
  CMD ["node", "-e", "require('http').get('http://localhost:3000/health', (r) => process.exit(r.statusCode === 200 ? 0 : 1))"]
 
CMD ["dist/index.js"]

4. Pilier 3 — Cloud (AWS, Azure, GCP)

Recommandation 2026 : viser un cloud dominant plutôt que multi-cloud superficiel.

AWS (60 % du marché FR)

• IAM : users, roles, policies JSON, permission boundaries, OIDC federation.
• Networking : VPC, subnets, Security Groups, NACLs, VPC endpoints.
• Compute : EC2 (instance profiles, IMDSv2), ECS, EKS, Lambda.
• Storage : S3 (bucket policies, encryption SSE-KMS, Object Lock).
• Secrets : AWS Secrets Manager, Parameter Store.
• Audit : CloudTrail, CloudWatch Logs, AWS Config.
• Security services : GuardDuty, Security Hub, Inspector, Macie.

Azure (surtout banque, secteur public, entreprises historiquement Microsoft)

• Entra ID (ex-Azure AD) : users, groups, Conditional Access, PIM.
• Networking : VNet, NSG, Azure Firewall.
• Compute : VM, AKS, Azure Functions.
• Storage : Blob Storage, Azure Key Vault.
• Audit : Activity Logs, Log Analytics, Defender for Cloud.

GCP (scale-ups tech, éditeurs SaaS B2B)

• IAM : service accounts, custom roles, Workload Identity.
• Networking : VPC, firewall rules, Cloud Armor.
• Compute : Compute Engine, GKE, Cloud Run.
• Storage : Cloud Storage, Cloud KMS, Secret Manager.
• Audit : Cloud Audit Logs, Security Command Center.

Certification cible selon cloud : AWS Certified Security Specialty (300 $), Microsoft SC-100 Cybersecurity Architect (165 $), Google Professional Cloud Security Engineer (200 $).

5. Pilier 4 — Infrastructure as Code

Terraform dominant (plus de 70 % du marché IaC FR 2026).

Compétences junior

• Syntaxe HCL, resources, data sources, variables, outputs.
• Modules réutilisables (Terraform Registry, private registry).
• State remote (S3 plus DynamoDB lock pour AWS, Azure Storage, GCP Cloud Storage).
• Workflow basique : init, plan, apply, destroy.
• Scanners IaC : Checkov (Bridgecrew, 1 000+ policies), tfsec (Aqua), Terrascan.

Compétences senior

• Modules complexes avec validation rules, preconditions, postconditions.
• Workspaces ou Terraform Cloud pour isolation environnements.
• GitOps Terraform avec Atlantis ou Terraform Cloud/Enterprise.
• Custom providers Go.
• Migration plans pour refactorings complexes.

Alternatives à connaître : Pulumi (IaC en langages généraux Python/Go/TypeScript), AWS CDK (CloudFormation généré depuis code), Ansible (configuration management complément).

6. Pilier 5 — SAST/DAST/SCA

SAST (Static Application Security Testing)

• Semgrep (leader open-source 2026, règles OWASP plus custom).
• SonarQube (Community ou Enterprise, qualité plus sécurité).
• Snyk Code (commercial, gratuit pour open-source).
• Checkmarx CxSAST (commercial premium, banque-assurance).

DAST (Dynamic Application Security Testing)

• OWASP ZAP (open-source leader, intégration CI).
• Burp Suite Professional (commercial, référence pentest web).
• Nuclei (template-based, rapide, open-source).

SCA (Software Composition Analysis)

• Snyk (leader commercial, gratuit limité).
• Trivy (Aqua, open-source, images plus filesystems plus IaC plus SBOM).
• Grype (Anchore, open-source, scan SBOM).
• OSV-Scanner (Google, open-source).

Pattern 2026 recommandé : Semgrep en pre-commit et CI plus Trivy en build images plus OWASP ZAP en staging plus Grype pour scan SBOM — tous open-source, couverture 80 % des besoins AppSec. Alternatives commerciales (Snyk, Checkmarx) pour équipes avec budget ou besoins de reporting entreprise avancé.

7. Pilier 6 — Secrets management

Voir article dédié Secrets management pour développeurs pour détails approfondis.

Compétences junior

• Comprendre anti-patterns (hardcoded, committed, dans logs).
• Utiliser un secret manager (Vault, AWS SM, Azure KV, GCP SM) en lecture.
• OIDC federation CI/CD (GitHub Actions avec AWS/Azure/GCP).
• Scanners : Gitleaks, TruffleHog en pre-commit et CI.

Compétences senior

• Administration HashiCorp Vault (unsealing, HA, auth methods, policies).
• Dynamic secrets (DB credentials générés à la demande avec TTL).
• Rotation automatique.
• PKI management.

8. Pilier 7 — Supply chain security

Voir article dédié Qu'est-ce qu'un SBOM pour détails approfondis.

Compétences junior

• Génération SBOM CycloneDX avec Syft.
• Scan vulnérabilités SBOM avec Grype.
• Signature artefacts avec Sigstore Cosign.
• Comprendre SLSA niveaux 1-2.

Compétences senior

• SLSA niveau 3+ (build reproductible isolé).
• Policy-as-code supply chain (attestations OPA, Kyverno image verification).
• OWASP Dependency-Track deployment et administration.
• VEX (Vulnerability Exploitability eXchange) pour réduction bruit.

9. Pipeline DevSecOps complet intégrant les 7 piliers

Exemple concret qui met en œuvre simultanément les 7 piliers — exploitable en portfolio GitHub :

# .github/workflows/devsecops-7-piliers.yml
# Pipeline DevSecOps integrant les 7 piliers de competences 2026.
 
name: DevSecOps 7 Piliers Pipeline
 
on:
  pull_request:
    branches: [main]
  push:
    branches: [main]
 
permissions:
  contents: read
  security-events: write
  id-token: write
  packages: write
 
jobs:
  # --- Pilier 1 : Git et CI/CD baseline ---
  quality-gate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
      - run: npm ci
      - run: npm test -- --coverage
 
  # --- Pilier 5 : SAST + SCA ---
  sast-sca-scan:
    runs-on: ubuntu-latest
    needs: quality-gate
    steps:
      - uses: actions/checkout@v4
      - name: Semgrep SAST (OWASP rules)
        uses: returntocorp/semgrep-action@v1
        with:
          config: p/owasp-top-ten
      - name: Trivy SCA scan dependances
        uses: aquasecurity/trivy-action@master
        with:
          scan-type: fs
          severity: CRITICAL,HIGH
          exit-code: '1'
 
  # --- Pilier 6 : Secrets scanning ---
  secrets-scan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Gitleaks scan historique
        uses: gitleaks/gitleaks-action@v2
 
  # --- Pilier 2 : Conteneurs + hardening ---
  container-build-scan:
    runs-on: ubuntu-latest
    needs: [sast-sca-scan, secrets-scan]
    steps:
      - uses: actions/checkout@v4
      - name: Build distroless image
        run: docker build -t myapp:${{ github.sha }} .
      - name: Trivy image scan
        uses: aquasecurity/trivy-action@master
        with:
          image-ref: myapp:${{ github.sha }}
          severity: CRITICAL,HIGH
          exit-code: '1'
 
  # --- Pilier 4 : IaC Security ---
  iac-security:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Checkov Terraform scan
        uses: bridgecrewio/checkov-action@master
        with:
          directory: infra/terraform
          framework: terraform
          soft_fail: false
 
  # --- Pilier 7 : SBOM + Supply chain ---
  sbom-and-sign:
    runs-on: ubuntu-latest
    needs: container-build-scan
    steps:
      - uses: actions/checkout@v4
      - name: Generate SBOM CycloneDX
        uses: anchore/sbom-action@v0
        with:
          image: myapp:${{ github.sha }}
          format: cyclonedx-json
          output-file: sbom.cdx.json
      - name: Install Cosign
        uses: sigstore/cosign-installer@v3
      - name: Sign image and attach SBOM
        run: |
          cosign sign --yes myapp:${{ github.sha }}
          cosign attest --yes --predicate sbom.cdx.json \
            --type cyclonedx myapp:${{ github.sha }}
 
  # --- Pilier 3 : Deploy cloud (AWS via OIDC federation) ---
  deploy-aws:
    runs-on: ubuntu-latest
    needs: [iac-security, sbom-and-sign]
    if: github.ref == 'refs/heads/main'
    steps:
      - uses: actions/checkout@v4
 
      # Pilier 6 (suite) : OIDC federation - aucun long-lived key
      - name: Configure AWS credentials via OIDC
        uses: aws-actions/configure-aws-credentials@v4
        with:
          role-to-assume: arn:aws:iam::123456789012:role/GithubActionsDeploy
          aws-region: eu-west-3
 
      # Pilier 4 (suite) : Terraform apply avec state remote
      - name: Terraform apply
        run: |
          cd infra/terraform
          terraform init
          terraform apply -auto-approve

Ce pipeline type illustre comment les 7 piliers s'articulent en un workflow unique production-ready : chaque job correspond à un ou deux piliers, avec stop conditions (fail-build sur HIGH vulnerabilities).

10. Soft skills essentielles DevSecOps

Les compétences techniques seules ne suffisent pas. 6 soft skills sont décisives en 2026.

11. Trois anti-patterns d'apprentissage à éviter

Anti-pattern 1 — Dispersion sur 7 piliers en parallèle

Le candidat essaie d'apprendre AWS plus Kubernetes plus Terraform plus Semgrep plus Vault plus SBOM en même temps. Résultat : connaissance superficielle partout, maîtrise nulle part, échec en entretien technique quand un recruteur creuse un sujet.

Solution : séquentialité stricte, 1-2 piliers à la fois avec consolidation active (portfolio, lab, certification).

Anti-pattern 2 — Multi-cloud sans dominant

Le candidat apprend AWS plus Azure plus GCP en parallèle pour « être plus employable ». Résultat : aucun cloud maîtrisé en profondeur, filtrage RH qui exige « 3+ ans AWS » écarte le profil.

Solution : focus sur un cloud dominant (AWS en France), aller en profondeur, ajouter le 2ème cloud à 2-3 ans d'expérience.

Anti-pattern 3 — Certifications sans portfolio

Le candidat empile Security+ plus AWS Security Specialty plus Terraform Associate plus CKS en 12 mois sans jamais produire de projets GitHub démontrables. Résultat : filtrage RH passé, filtrage technique raté faute de démonstrateur concret.

Solution : construire le portfolio en parallèle des certifications — chaque pilier appris produit 1-2 livrables (pipeline, module Terraform, cluster K8s, policies Kyverno).

12. Ordre d'acquisition recommandé sur 12 mois

Alternative intensive : bootcamp 6-9 mois à 30-40 heures hebdomadaires couvrant les 7 piliers en parallèle avec structure et mentoring (voir bootcamp DevSecOps Zeroday Cyber Academy). Fonctionne parce que structuré collectivement — à ne pas reproduire en autodidacte seul.

13. Bilan Zeroday Cyber Academy

Notre avis assumé : la séquentialité avec consolidation active bat la parallélisation pour 90 % des candidats DevSecOps 2026.

Trois règles factuelles observées 2022-2026

1. Maîtriser profondément 4 piliers (Git/CI-CD, conteneurs/K8s, un cloud majeur, Terraform/IaC) avant d'ajouter le 5e. Un candidat qui sait vraiment ce qu'il fait sur 4 piliers convertit mieux qu'un candidat survolant les 7.
2. Portfolio en parallèle des certifications — chaque pilier produit 1-2 livrables GitHub démontrables.
3. Focus sur un cloud dominant (AWS en France) plutôt que multi-cloud superficiel. La bifurcation multi-cloud s'ouvre naturellement à 2-4 ans si les fondations sont solides.

Ce que nous ne cachons pas

• Les bootcamps 3 mois qui survolent les 7 piliers produisent des candidats à signal brouillé — sauf si la structure est très dense avec mentoring et labs intensifs.
• La parallélisation semble gagner du temps mais coûte 30-50 % en apprentissage superficiel.
• Les certifications seules ne suffisent pas — GitHub vide = quasi-éliminatoire en entretien technique 2026.
• Certains piliers sont plus porteurs que d'autres en 2026 : Cloud Security (pénurie structurelle), supply chain security (CRA UE 2027), Kubernetes security (CKS rare). Prioriser ces piliers dans la roadmap.

14. Pour aller plus loin

• Devenir DevSecOps sans expérience : trajectoire complète et certifications.
• Roadmap DevSecOps : roadmap technique structurée.
• Les étapes pour devenir DevSecOps : parcours détaillé.
• Roadmap Cloud Security : spécialisation Cloud Security Engineer.
• SAST vs DAST : comparatif détaillé des deux approches.
• Salaire DevSecOps : fourchettes France 2026.

15. Points clés à retenir

• 7 piliers de compétences DevSecOps : Git/CI-CD, conteneurs/K8s, cloud majeur, IaC, SAST/DAST/SCA, secrets management, supply chain.
• 4 piliers socle junior à maîtriser avant embauche : Git/CI-CD, Docker/K8s, un cloud, Terraform/IaC.
• 3 piliers confirmé dans les 18-24 mois post-embauche : SAST/DAST/SCA avancé, secrets management senior, supply chain security.
• Langages : Python plus Bash obligatoires, Go plus YAML fortement recommandés, HCL plus Rego pour policy-as-code.
• Stack outils 2026 : GitHub Actions/GitLab CI, Docker distroless, Kubernetes RBAC/NetworkPolicy, Terraform plus Checkov, Semgrep plus Trivy plus Grype, HashiCorp Vault plus OIDC, Syft plus Cosign.
• Séquence certifications 12 mois : Security+ → Terraform Associate → AWS Security Specialty ou SC-100 → CKS. Budget 900-1 500 €.
• Séquentialité bat parallélisation : 1-2 piliers à la fois avec consolidation active plutôt que 7 en parallèle.
• Portfolio en parallèle des certifs : chaque pilier produit 1-2 livrables GitHub démontrables.
• Focus un cloud dominant (AWS en France) plutôt que multi-cloud superficiel.
• Portfolio > certifications en entretien technique 2026 : GitHub vide = quasi-éliminatoire.

Le bootcamp DevSecOps Zeroday Cyber Academy couvre les 7 piliers avec structure pédagogique séquentielle, préparation certifications (Security+, Terraform Associate, AWS Security Specialty, CKS), construction portfolio complet (pipeline DevSecOps 7-piliers, modules Terraform sécurisés, cluster K8s hardened avec Kyverno, SBOM plus Cosign), et coaching d'entretien scale-ups tech plus grands groupes régulés NIS 2/DORA/CRA.