Pulumi : l'Infrastructure as Code en vrai langage de programmation

Depuis quelques années, l'Infrastructure as Code (IaC) sert de standard pour gérer cloud et infrastructure en production. Terraform a longtemps dominé, mais Pulumi bouleverse le jeu avec une approche radicale : utiliser de vrais langages de programmation au lieu d'un DSL maison.

Fini les contorsions HCL, les boucles laborieuses, les tests qui demandent des outils externes. Avec Pulumi, tu écris en TypeScript, Python, Go, C#, ou Java, juste du code normal. État stocké dans le cloud, S3, Azure Blob ou en local. Plus de 100 providers supportés. Stack concept intégré pour gérer dev, staging, prod.

1. Pourquoi un vrai langage ?
2. Premiers pas
3. Exemple concret : VPC + VM
4. Stacks et environnements
5. Pulumi vs Terraform
6. Perspectives
7. Conclusion

Les limites de HCL

HCL, c'est un DSL dédié inventé par HashiCorp. Ça marche, mais ça reste limité. Les boucles, les conditions, les fonctions récursives, tout devient laborieux. Tu dois apprendre une syntaxe spéciale, te passer de debugging, faire des compromis.

Avec Pulumi, tu utilises le langage que tu maîtrises déjà. TypeScript ? Zod, des types, de l'autocomplete. Python ? Décorateurs, asyncio, tests unitaires avec pytest. Go ? Compilé, rapide, typage fort.

Tester sans friction

Avec Terraform, tester une infra, c'est lourd : tu crées des états de test, tu valides des fichiers JSON générés. Pulumi s'intègre nativement avec les frameworks de test de ton langage.

En TypeScript :

import * as pulumi from '@pulumi/pulumi';
import * as aws from '@pulumi/aws';
import { describe, it, expect } from '@jest/globals';

describe('Infrastructure', () => {
	it('should create VPC with correct CIDR', () => {
		const vpc = new aws.ec2.Vpc('test-vpc', { cidrBlock: '10.0.0.0/16' });
		expect(vpc.cidrBlock).toBeDefined();
	});
});

IDE support natif

Pulumi exécute du vrai code. Ton IDE ? Il comprend tout. Autocomplete, go-to-definition, refactoring, comme sur un projet normal. Plus de "la syntaxe HCL ne supporte pas ça".

Installation

npm install -g @pulumi/pulumi
pulumi --version

Créer un stack

pulumi new aws-typescript
cd pulumi-demo

Pulumi génère :

• Pulumi.yaml - metadata du projet
• Pulumi.dev.yaml - config pour le stack "dev"
• index.ts - ton code d'infrastructure

Configuration et secrets

# Ajouter une config
pulumi config set aws:region eu-west-1
pulumi config set dbPassword secret123 --secret

# Lire en code
const config = new pulumi.Config();
const region = config.require('aws:region');
const dbPassword = config.requireSecret('dbPassword');

Imaginons que tu veux une VPC AWS, un subnet, une instance EC2. En Pulumi TypeScript :

import * as pulumi from '@pulumi/pulumi';
import * as aws from '@pulumi/aws';

// Configuration
const config = new pulumi.Config();
const vmType = config.get('vmType') || 't3.micro';

// VPC
const vpc = new aws.ec2.Vpc('app-vpc', {
	cidrBlock: '10.0.0.0/16',
	enableDnsHostnames: true,
});

// Subnet
const subnet = new aws.ec2.Subnet('app-subnet', {
	vpcId: vpc.id,
	cidrBlock: '10.0.1.0/24',
	availabilityZone: 'eu-west-1a',
});

// Security Group
const securityGroup = new aws.ec2.SecurityGroup('app-sg', {
	vpcId: vpc.id,
	ingress: [
		{
			protocol: 'tcp',
			fromPort: 80,
			toPort: 80,
			cidrBlocks: ['0.0.0.0/0'],
		},
		{
			protocol: 'tcp',
			fromPort: 443,
			toPort: 443,
			cidrBlocks: ['0.0.0.0/0'],
		},
	],
	egress: [
		{
			protocol: '-1',
			fromPort: 0,
			toPort: 0,
			cidrBlocks: ['0.0.0.0/0'],
		},
	],
});

// AMI
const ami = aws.ec2.getAmi(
	{
		filters: [{ name: 'name', values: ['amzn2-ami-hvm-*'] }],
		owners: ['137112412989'],
		mostRecent: true,
	},
	{ async: true }
);

// Instance EC2
const instance = new aws.ec2.Instance('app-server', {
	ami: ami.then((a: any) => a.id),
	instanceType: vmType,
	subnetId: subnet.id,
	vpcSecurityGroupIds: [securityGroup.id],
	tags: { Name: 'app-server' },
});

export const publicIp = instance.publicIp;
export const vpcId = vpc.id;

Déployer :

pulumi up
# Pulumi preview les changements, tu confirmes

Détruire :

pulumi destroy

Aucune friction. Du code lisible, maintenable, réutilisable.

Une stack = un déploiement isolé. Same code, config différente. Parfait pour dev/staging/prod.

# Créer stacks
pulumi stack init dev
pulumi stack init staging
pulumi stack init prod

# Switcher
pulumi stack select dev
pulumi config set vmType t3.micro
pulumi up

pulumi stack select prod
pulumi config set vmType t3.xlarge
pulumi up

État séparé par stack. Secrets isolés. Déploiements indépendants.

Verdict : Pulumi pour les équipes dev qui veulent vraiment coder. Terraform pour les équipes ops qui préfèrent la séparation infra/code.

En fin 2025, Pulumi lance Pulumi AI : convertis du texte en IaC. "Create me a VPC with 3 subnets" → code généré. OpenAI integration. Encore bêta, mais révolutionnaire.

L'Automation API embarque Pulumi directement dans ton app (SaaS, CLI custom). Idéal pour ouvrir du self-service infra à tes clients.

• Blog Terraform : IaC comparée
• Terraform + Ansible pour orchestrer le cloud
• Kubernetes : introduction et déploiement

• pulumi.com
• GitHub Pulumi
• Pulumi Documentation
• Automation API

Pulumi change le jeu. Plus de DSL, plus de friction, juste du vrai code pour infra moderne. Stack, config, secrets, providers : tout est là. État où tu veux. Tests natifs. IDE support complet.

Tu maîtrises déjà TypeScript ou Python ? Tu viens d'avoir un super-pouvoir pour IaC.