Skip to content
Learni
Voir tous les tutoriels
DevOps

Comment implémenter Platform Engineering avec Backstage en 2026

14 minINTERMEDIATE
DevOpsTerraformKubernetesBackstagePlatform Engineering
Read in English

Introduction

Le Platform Engineering émerge comme une discipline clé en 2026, visant à construire des Internal Developer Platforms (IDP) self-service pour les développeurs. Au lieu de perdre du temps sur l'infrastructure, les devs se concentrent sur le code métier grâce à des abstractions comme des templates prêts-à-l'emploi, des pipelines automatisés et une observabilité intégrée.

Pourquoi c'est crucial ? Selon les études de Gartner, 80% des entreprises adoptent des IDP d'ici 2026 pour réduire le toil (tâches manuelles) de 50%. Backstage, développé par Spotify et adopté par Netflix/LinkedIn, est l'outil open-source de référence : un portail unifié pour catalogues de services, scaffolding, docs et CI/CD.

Ce tutoriel vous guide pas à pas pour créer une IDP basique avec Backstage : installation locale, configuration avancée avec PostgreSQL, ajout d'un plugin custom TypeScript pour Terraform, et déploiement Docker. À la fin, vous aurez une plateforme fonctionnelle, scalable vers Kubernetes. Idéal pour les ingénieurs intermédiaires en DevOps. (148 mots)

Prérequis

  • Node.js 20+ et Yarn 1.22+
  • Docker et Docker Compose
  • Connaissances de base en TypeScript et YAML
  • Compte GitHub pour les templates (optionnel)
  • 4 Go RAM minimum pour les services

Création du projet Backstage

terminal
npx @backstage/create-app@latest ./platform-idp --type nodejs --force
cd platform-idp
yarn install
yarn tsc

Cette commande initialise un projet Backstage complet avec un backend Node.js, frontend React et packages prêts. L'option --force écrase les fichiers existants si besoin. Évitez npm car Yarn est optimisé pour les monorepos de Backstage ; testez avec yarn dev pour vérifier.

Configuration initiale

Une fois le projet créé, Backstage tourne en sandbox avec SQLite. Nous allons passer à PostgreSQL pour la prod-like et activer des plugins essentiels comme le scaffolder (génération de projets) et TechDocs (docs auto-générés).

Configuration app-config.yaml

app-config.yaml
app:
  baseUrl: http://localhost:3000
  bindConfig:
    port: 3000
backend:
  baseUrl: http://localhost:7007
  listen:
    port: 7007
  cors:
    origin: http://localhost:3000
  database:
    client: pg
    connection:
      host: localhost
      port: 5432
      user: backstage
      password: backstage
      database: backstage
  auth:
    providers:
      github:
        clientId: ${GITHUB_CLIENT_ID}
        clientSecret: ${GITHUB_CLIENT_SECRET}
proxy:
  '/catalog':
    target: http://localhost:7007/catalog-provider
  '/scaffolder':
    target: http://localhost:7007/scaffolder
techdocs:
  builder: local
github:
  baseUrl: https://github.com
  token: ${GITHUB_TOKEN}

Ce fichier centralise toute la config : PostgreSQL pour persistance, proxy pour microservices internes, auth GitHub et TechDocs local. Remplacez les variables d'env (GITHUB_*) par vos creds. Piège : sans cors.origin, le frontend bloque ; toujours redémarrer après changements.

Docker Compose pour services

docker-compose.yml
version: '3.8'
services:
  postgres:
    image: postgres:15
    environment:
      POSTGRES_USER: backstage
      POSTGRES_PASSWORD: backstage
      POSTGRES_DB: backstage
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data
  backstage:
    build: .
    ports:
      - "3000:3000"
      - "7007:7007"
    environment:
      POSTGRES_HOST: postgres
      POSTGRES_USER: backstage
      POSTGRES_PASSWORD: backstage
      POSTGRES_DATABASE: backstage
      GITHUB_TOKEN: ${GITHUB_TOKEN}
    depends_on:
      - postgres
volumes:
  postgres_data:

Ce compose orchestre PostgreSQL et Backstage en conteneurs. Le build utilise le Dockerfile du projet. Lancez avec docker compose up -d ; exposez les vars env. Attention au volume persistant pour éviter la perte de données lors des restarts.

Lancement et premiers tests

Démarrez avec yarn dev en local ou docker compose up. Accédez à http://localhost:3000. Créez un user, importez un repo GitHub via Catalog. Testez le scaffolder pour générer un projet 'guestbook'.

Plugin custom TypeScript pour Terraform

packages/backend/src/plugins/terraform.ts
import { createRouter } from '@backstage/router';
import { PluginEnvironment } from '@backstage/backend-common';
import express from 'express';

export async function createRouterTerraform(env: PluginEnvironment) {
  const router = createRouter();

  router.get('/provision', async (req, res) => {
    const { clusterName } = req.query;
    // Simule appel Terraform CLI ou API
    const output = {
      status: 'provisioned',
      cluster: clusterName,
      endpoints: [`https://${clusterName}.example.com`]
    };
    res.json(output);
  });

  return router;
}

// Dans index.ts du backend :
// router.use('/api/terraform', await createRouterTerraform(env));

Ce plugin ajoute une API /api/terraform/provision pour simuler le provisioning IaC. Intégrez-le dans packages/backend/src/index.ts. C'est extensible à un vrai exec de terraform apply. Piège : gérez les erreurs async avec try/catch pour éviter les crashes backend.

Template scaffolder Terraform

templates/terraform-aws/default.yaml
apiVersion: scaffolder.backstage.io/v1beta3
kind: Template
metadata:
  name: terraform-aws-vpc
  title: AWS VPC Terraform
  description: Déploie une VPC AWS via Terraform
  tags:
    - terraform
    - aws
  owner: platform-team
spec:
  owner: platform-team
  type: service
  parameters:
    - title: Nom VPC
      type: string
      ui:widget: text
      required: true
      validation:
        $$js: "((value) => /^[a-zA-Z0-9-]+$/.test(value))"
  steps:
    - id: terraform-init
      name: Init Terraform
      action: debug:log
      input:
        message: "Provisioning VPC ${{ parameters.vpcName }}"
    - id: publish
      name: Publier template
      action: publish:github
      input:
        repoUrl: github.com?repo=platform-idp&branch=main
        defaultBranch: true
  output:
    links:
      - title: Terraform Plan
        url: https://console.aws.amazon.com
        icon: cloud

Ce template YAML permet aux devs de générer un projet Terraform VPC via UI. Il valide l'input et publie sur GitHub. Placez-le dans templates/ et importez dans Catalog. Évitez les steps sans action valide pour prévenir les échecs scaffolding.

Déploiement en prod avec Helm

terminal-helm
helm repo add backstage https://backstage.github.io/charts
helm repo update
helm install backstage backstage/backstage \
  --namespace backstage --create-namespace \
  --set backend.extraEnv.GITHUB_TOKEN=$GITHUB_TOKEN \
  --set postgresql.auth.postgresPassword=backstage

Ce script déploie Backstage sur Kubernetes via Helm chart officiel. Assurez-vous d'avoir kubectl contexté. Personnalisez avec vos secrets ; surveillez les pods avec kubectl logs. Piège commun : oublier le namespace cause des conflits de ports.

Bonnes pratiques

  • Sécurisez les secrets : Utilisez Vault ou Kubernetes Secrets au lieu d'env vars en clair.
  • Monitorez avec Prometheus : Ajoutez le plugin Backstage pour Grafana dashboards.
  • GitOps tout : Stockez configs YAML en Git et appliquez via ArgoCD.
  • Scale horizontal : Configurez replicas backend >1 pour >50 users.
  • RBAC strict : Limitez les templates scaffolding aux équipes autorisées.

Erreurs courantes à éviter

  • DB non persistante : Sans volumes Docker, les données Catalog se perdent au restart.
  • CORS mal config : Frontend/backend sur ports différents → erreurs 401 ; vérifiez app-config.cors.
  • Plugins non recompilés : Après ajouts TS, relancez yarn tsc && yarn build.
  • Templates sans validation : Inputs libres causent erreurs Terraform ; ajoutez $$js regex.

Pour aller plus loin

Approfondissez avec les docs Backstage. Intégrez Crossplane pour true self-service IaC. Découvrez nos formations Learni sur Platform Engineering pour masterclasses Kubernetes + Backstage en enterprise.