Multi-Cloud IaC 2026 : Crossplane vs concurrents

Présentation de Crossplane et de ses Fonctionnalités

Qu'est-ce que Crossplane ?

Crossplane est un projet open-source qui expose des ressources cloud sous forme de CRD Kubernetes. Il permet de provisionner et d'orchestrer des services cloud (bases de données, réseaux, caches) depuis un cluster Kubernetes, en conservant un modèle déclaratif et en s'intégrant naturellement aux workflows GitOps.

Crossplane fournit un control loop qui veille à l'état désiré des ressources : les compositions (XRD + Composition) permettent de définir des abstractions métiers réutilisables pour standardiser des stacks cloud dans l'entreprise.

• Intégration avec Kubernetes
• Provisionnement de ressources
• Plans de contrôle déclaratifs
• Gestion simplifiée via GitOps

Pour une perspective "entreprise", Upbound (la société fondatrice) propose des offres commerciales et du support pour faciliter l'adoption en production. Upbound fournit également une registry de packages et un écosystème permettant de partager des compositions et des abstractions métier au sein d'une organisation.

Exemple : définition d'une instance MySQL avec une référence de ProviderConfig (authentification) :

# providerConfigRef : référence au ProviderConfig (credentials, région, profile).
# Créez un ProviderConfig (ex: aws-provider) qui contient les informations d'authentification nécessaires.
apiVersion: database.crossplane.io/v1alpha1
kind: MySQLInstance
metadata:
  name: example-mysql
spec:
  providerConfigRef:
    name: aws-provider
  classRef:
    name: mysql-class
  writeConnectionSecretToRef:
    name: mysql-secret
    namespace: crossplane-system

Le champ providerConfigRef est crucial : sans ProviderConfig correctement configuré, Crossplane ne pourra pas authentifier et créer des ressources chez le fournisseur.

Architecture Crossplane

Vue d'overview de la position de Crossplane dans l'architecture : le contrôleur Crossplane s'exécute dans le cluster Kubernetes et appelle les providers pour provisionner des ressources externes (AWS, Azure, GCP).

Ce schéma illustre le flux : les manifestes GitOps sont appliqués dans Kubernetes, Crossplane traduit ces desiderata en appels vers les providers qui provisionnent les ressources externes.

Analyse des Concurrents de Crossplane

Comparaison avec d'autres solutions

Terraform, Pulumi et Ansible sont des alternatives répandues. Terraform se distingue par sa gestion d'état et son large écosystème de providers. Pulumi apporte une approche programmative (langages courants) et Ansible vise plutôt la configuration et l'orchestration.

• Terraform : simplicité et gestion d'état
• Pulumi : approche programmative
• Crossplane : intégration Kubernetes
• Ansible : orchestration et configuration

Exemple d'exécution Terraform :

terraform apply -auto-approve

Exemple Pulumi (TypeScript) : création d'un bucket S3 simple — utile pour comparer l'approche programmative de Pulumi avec le modèle déclaratif de Crossplane.

import * as pulumi from "@pulumi/pulumi"
import * as aws from "@pulumi/aws"

// Crée un bucket S3 privé
const bucket = new aws.s3.Bucket("my-bucket", {
  acl: "private",
});

export const bucketName = bucket.id;

Exemple Terraform concret (bucket S3 + backend d'état)

Exemple minimal pour illustrer l'approche HCL et la gestion d'état centralisée (recommandé en multi-cloud / équipe). Adaptez les noms (bucket, key, region) et sécurisez les credentials via IAM roles et MFA quand approprié.

terraform {
  required_version = ">= 1.0.0"
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 4.0"
    }
  }
  backend "s3" {
    bucket         = "my-terraform-state-bucket"
    key            = "envs/prod/terraform.tfstate"
    region         = "eu-west-1"
    dynamodb_table = "terraform-locks"
  }
}

provider "aws" {
  region = "eu-west-1"
}

resource "aws_s3_bucket" "app_bucket" {
  bucket = "my-app-bucket-example-unique-12345"
  acl     = "private"

  tags = {
    Environment = "prod"
    ManagedBy    = "terraform"
  }
}

Bonnes pratiques associées :

• Utiliser un backend d'état centralisé (S3) + verrouillage (DynamoDB) pour éviter les collisions.
• Protéger les credentials via IAM roles (instance profiles / OIDC) plutôt que de stocker des clés statiques.
• Versionner les modules et exécuter des plans dans des pipelines CI (pré-validation).

Avantages et Inconvénients de chaque Solution

Crossplane

Avantages principaux : intégration étroite avec Kubernetes, audibilité via YAML et bonnes pratiques GitOps, et possibilité de créer des abstractions métiers réutilisables (Compositions).

Inconvénients : nécessite une familiarité Kubernetes — la phase initiale peut être plus longue pour des équipes non-Kubernetes. La compatibilité entre versions (Crossplane / Kubernetes / providers) exige une gestion active des versions et des tests automatisés.

• Avantages : Intégration Kubernetes, gestion des versions simplifiée, audibilité.
• Inconvénients : Courbe d'apprentissage pour les non-initiés, gestion proactive des compatibilités.

Alternatives à Crossplane

Terraform offre une large adoption et une gestion d'état centralisée. Pulumi permet d'écrire l'infrastructure en TypeScript/Python/Go, ce qui séduit les équipes développeurs mais introduit des dépendances applicatives supplémentaires.

• Terraform : Adoption large, gestion multi-cloud, mais syntaxe HCL spécifique.
• Pulumi : Utilisation de langages modernes, mais complexité liée aux dépendances et aux modèles applicatifs.

Études de Cas et Retours d'Expérience

Cas d'utilisation de Crossplane

Dans une plateforme SaaS, l'équipe a centralisé le provisioning via Crossplane : un seul manifest GitOps suffisait pour provisionner RDS sur AWS et une base managée sur Azure. Cela a réduit les efforts manuels et facilité le versioning des configurations. L'équipe a mis en place des tests d'intégration pour valider les changements de versions Kubernetes / Crossplane avant le roll-out en production.

• Cas d'étude : Gestion d'infrastructure multicloud pour une plateforme SaaS.
• Bénéfice : réduction du temps de déploiement et meilleure traçabilité via GitOps.

Expérience avec Terraform

Terraform a permis à une autre organisation de standardiser ses déploiements sur plusieurs environnements (prod / staging / dev). La communauté et les modules réutilisables ont accéléré l'adoption, bien qu'il ait fallu parfois recourir à des ressources spécifiques non couvertes par les providers officiels.

• Cas d'étude : Automatisation de la gestion des infrastructures avec Terraform.
• Bénéfice : Standardisation des déploiements et réduction des erreurs humaines.