Infisical : gérer vos secrets en toute sécurité

Infisical est une plateforme open source de gestion centralisée des secrets. Elle permet de stocker, distribuer et injecter vos secrets (mots de passe, clés API, tokens) dans vos applications sans jamais les exposer dans le code.

Ce guide vous apprend à comprendre les concepts d’Infisical, déployer votre propre instance et utiliser la CLI pour gérer vos secrets de façon sécurisée et automatisée.

Ce que vous allez apprendre

• Comprendre les concepts : pourquoi centraliser les secrets, comment fonctionne Infisical
• Déployer Infisical en self-hosted avec Docker Compose
• Utiliser la CLI pour créer, lire, modifier et supprimer des secrets
• Injecter les secrets dans vos applications au runtime
• Automatiser le setup pour les pipelines CI/CD

Prérequis

• Docker et Docker Compose v2+
• 4 Go de RAM disponibles
• Connaissances de base en ligne de commande

Fondamentaux de la gestion des secrets Comprendre pourquoi et comment protéger vos secrets

Docker fondamentaux Maîtriser les bases de Docker

Concepts fondamentaux

Avant de manipuler Infisical, il est essentiel de comprendre pourquoi on centralise les secrets et comment Infisical résout ce problème.

Pourquoi centraliser les secrets

Un secret est toute information sensible donnant accès à un système : mot de passe, clé API, token, certificat. Le problème classique :

Mauvaise pratique	Risque
Secret dans le code	Exposé dans l’historique Git, accessible à tous
Secret dans .env committé	Visible par toute l’équipe
Secret copié par Slack	Aucune traçabilité, impossible à révoquer
Même secret dev/prod	Compromission dev = compromission prod

Glissez pour voir

La solution : un coffre-fort centralisé qui stocke les secrets chiffrés et les distribue uniquement aux applications autorisées, au moment où elles en ont besoin.

Comment fonctionne Infisical

Infisical repose sur trois composants principaux :

Composant	Rôle
Serveur Infisical	Stocke les secrets chiffrés, gère les accès
PostgreSQL	Base de données persistante
Redis	Cache et sessions
CLI / SDK	Clients pour récupérer et injecter les secrets

Glissez pour voir

Organisation des secrets

Infisical organise les secrets selon cette hiérarchie :

Organisation
└── Projet (ex: mon-application)
    ├── Environnement: dev
    │   └── Secrets: DATABASE_URL, API_KEY, ...
    ├── Environnement: staging
    │   └── Secrets: DATABASE_URL, API_KEY, ...
    └── Environnement: prod
        └── Secrets: DATABASE_URL, API_KEY, ...

Pourquoi cette structure ?

• Organisation : regroupe tous vos projets
• Projet : une application ou un service
• Environnement : dev, staging, prod avec des secrets différents
• Secret : une paire clé/valeur (ex: DATABASE_URL=postgres://...)

Machine Identity : l’authentification M2M

Comment une application s’authentifie-t-elle pour récupérer ses secrets ? Avec une Machine Identity.

Analogie : c’est comme une carte d’accès électronique. Votre application présente sa carte (token), Infisical vérifie qu’elle a le droit d’accéder à tel environnement de tel projet et lui donne les secrets correspondants.

Fonctionnalités Open Source vs Enterprise

Infisical propose deux éditions : une version Community (open source, MIT) et une version Enterprise avec des fonctionnalités avancées pour les grandes organisations. Pour la plupart des projets, la version open source couvre les besoins essentiels.

Ce qui est inclus en Open Source

La version gratuite offre un ensemble complet pour gérer vos secrets en self-hosted :

Fonctionnalité	Description
Stockage illimité	Nombre de secrets, projets et environnements illimité
Chiffrement E2E	Chiffrement AES-256-GCM côté client
CLI et SDKs	Node.js, Python, Go, Java, .NET, Ruby
Machine Identities	Authentification M2M avec tokens
Injection runtime	infisical run pour injecter les secrets au démarrage
Versioning des secrets	Historique des modifications avec rollback
Intégrations natives	Docker, Kubernetes, GitHub Actions, GitLab CI, etc.
Interface web	Tableau de bord complet pour gérer vos projets
RBAC de base	Rôles Admin, Member, Viewer par projet
Secret sharing	Partage temporaire de secrets via lien sécurisé
Import/Export	Formats dotenv, JSON, YAML
Webhooks	Notifications sur changement de secrets

Glissez pour voir

Suffisant pour 90% des cas

Pour une équipe qui débute avec la gestion centralisée des secrets, la version open source couvre tous les besoins : stockage sécurisé, injection runtime, intégration CI/CD et contrôle d’accès de base.

Ce qui nécessite une licence Enterprise

Les fonctionnalités suivantes sont réservées à l’édition payante :

Fonctionnalité	Cas d’usage
Dynamic Secrets	Credentials éphémères pour PostgreSQL, MySQL, AWS, etc.
Secret Rotation automatique	Changement périodique des mots de passe
Audit Logs avancés	Journaux détaillés avec export SIEM
SSO/SAML	Authentification via Okta, Azure AD, Google Workspace
SCIM Provisioning	Synchronisation automatique des utilisateurs
IP Allowlisting	Restriction d’accès par adresse IP
PKI & Certificats	Gestion du cycle de vie des certificats TLS
Secret Approval Workflows	Validation multi-niveaux avant modification
Points-in-Time Recovery	Restauration complète à un instant T
Support prioritaire	SLA garanti, accès aux ingénieurs Infisical

Glissez pour voir

Comment choisir ?

Posez-vous ces questions pour déterminer quelle édition vous convient :

Choisissez Open Source si :

• Vous débutez avec la gestion centralisée des secrets
• Votre équipe a moins de 50 développeurs
• Vous n’avez pas besoin de SSO entreprise
• Vos credentials sont statiques (pas besoin de rotation automatique)

Envisagez Enterprise si :

• Vous devez intégrer un IdP existant (Okta, Azure AD)
• La conformité exige des audit logs exportables
• Vous gérez des bases de données avec credentials dynamiques
• Vous avez besoin de workflows d’approbation pour les secrets sensibles

Cloud vs Self-hosted

Infisical propose aussi une offre Cloud (SaaS) avec un tier gratuit généreux. Si vous ne voulez pas gérer l’infrastructure, c’est une alternative au self-hosted. Les fonctionnalités Enterprise sont disponibles sur les deux modes de déploiement.

Installation avec Docker Compose

Version utilisée

Ce guide utilise Infisical v0.158 (mars 2026). L’architecture PostgreSQL remplace l’ancienne architecture MongoDB.

1. Créer le répertoire du projet

   mkdir -p infisical-lab && cd infisical-lab

2. Créer le fichier d’environnement

   .env

   # Clé de chiffrement des secrets (OBLIGATOIRE)
   # Générer avec : openssl rand -hex 16
   ENCRYPTION_KEY=a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6
   
   # Secret pour les tokens JWT
   # Générer avec : openssl rand -base64 32
   AUTH_SECRET=votre-secret-jwt-complexe-32-caracteres
   
   # URL de l'instance
   SITE_URL=http://localhost:8080
   
   # Connexion PostgreSQL
   DB_CONNECTION_URI=postgres://infisical:infisical_password@postgres:5432/infisical?sslmode=disable
   
   # Connexion Redis
   REDIS_URL=redis://redis:6379

   Pourquoi ces variables ?

   Variable	Rôle
   ENCRYPTION_KEY	Chiffre les secrets stockés en base
   AUTH_SECRET	Signe les tokens d’authentification
   SITE_URL	URL pour les redirections et liens
   DB_CONNECTION_URI	Connexion à PostgreSQL
   REDIS_URL	Connexion à Redis (cache, sessions)

   Glissez pour voir

3. Créer le fichier Docker Compose

   docker-compose.yml

   services:
     postgres:
       image: postgres:16-alpine
       restart: unless-stopped
       environment:
         POSTGRES_USER: infisical
         POSTGRES_PASSWORD: infisical_password
         POSTGRES_DB: infisical
       volumes:
         - postgres_data:/var/lib/postgresql/data
       healthcheck:
         test: ["CMD-SHELL", "pg_isready -U infisical -d infisical"]
         interval: 10s
         timeout: 5s
         retries: 5
   
     redis:
       image: redis:7-alpine
       restart: unless-stopped
       command: redis-server --appendonly yes
       volumes:
         - redis_data:/data
       healthcheck:
         test: ["CMD", "redis-cli", "ping"]
         interval: 10s
         timeout: 5s
         retries: 5
   
     infisical:
       image: infisical/infisical:latest
       restart: unless-stopped
       depends_on:
         postgres:
           condition: service_healthy
         redis:
           condition: service_healthy
       env_file:
         - .env
       ports:
         - "8080:8080"
       healthcheck:
         test: ["CMD", "wget", "-q", "--spider", "http://localhost:8080/api/status"]
         interval: 30s
         timeout: 10s
         retries: 3
         start_period: 60s
   
   volumes:
     postgres_data:
     redis_data:

4. Démarrer les services

   docker compose up -d

   Attendre environ 60 secondes que tous les services démarrent.

5. Vérifier le statut

   docker compose ps

   Résultat attendu :

   NAME                 STATUS                   PORTS
   infisical-postgres   Up (healthy)             5432/tcp
   infisical-redis      Up (healthy)             6379/tcp
   infisical-server     Up (healthy)             0.0.0.0:8080->8080/tcp

Installation de la CLI

La CLI Infisical permet de gérer vos secrets en ligne de commande, sans passer par l’interface web.

Linux (Debian/Ubuntu)

curl -1sLf 'https://dl.cloudsmith.io/public/infisical/infisical-cli/setup.deb.sh' | sudo -E bash
sudo apt update && sudo apt install -y infisical

Linux (RHEL/Fedora)

curl -1sLf 'https://dl.cloudsmith.io/public/infisical/infisical-cli/setup.rpm.sh' | sudo -E bash
sudo dnf install -y infisical

macOS

brew install infisical/get-cli/infisical

Vérification :

infisical --version
# infisical version 0.43.x

Initialisation automatisée (bootstrap)

Deux méthodes d'initialisation

Vous pouvez initialiser Infisical de deux façons :

• Interface web : ouvrir http://localhost:8080 et créer un compte
• CLI bootstrap : automatiser le setup sans interface graphique

La méthode CLI est recommandée pour les pipelines CI/CD et l’infrastructure as code.

Bootstrap via CLI

La commande infisical bootstrap initialise une instance vierge en créant :

• Un compte administrateur
• Une organisation
• Une Machine Identity avec un token d’accès

infisical bootstrap \
  --domain http://localhost:8080 \
  --email admin@example.com \
  --password 'VotreMotDePasse123!' \
  --organization "Mon Organisation"

Résultat :

{
  "message": "Successfully bootstrapped instance",
  "identity": {
    "id": "xxx-xxx-xxx",
    "name": "Instance Admin Identity",
    "credentials": {
      "token": "eyJhbGciOiJIUz..."
    }
  },
  "organization": {
    "id": "yyy-yyy-yyy",
    "name": "Mon Organisation"
  },
  "user": {
    "email": "admin@example.com",
    "superAdmin": true
  }
}

Important : conservez le token de façon sécurisée. C’est votre accès administrateur à l’instance.

Capturer le token dans une variable

Pour l’automatisation, extrayez le token :

INFISICAL_TOKEN=$(infisical bootstrap \
  --domain http://localhost:8080 \
  --email admin@example.com \
  --password 'VotreMotDePasse123!' \
  --organization "Mon Organisation" \
  | jq -r '.identity.credentials.token')

echo "Token capturé : ${INFISICAL_TOKEN:0:20}..."

Sécurité du token

Le token bootstrap a les privilèges administrateur maximum. Traitez-le comme un mot de passe root :

• Ne le commitez jamais dans Git
• Stockez-le dans un gestionnaire de secrets
• Utilisez des tokens à permissions limitées pour les applications

Gérer les secrets avec la CLI

Une fois le bootstrap effectué, utilisez la CLI pour gérer vos secrets.

Variables d’environnement requises

Configurez la CLI pour qu’elle se connecte à votre instance :

# URL de votre instance
export INFISICAL_API_URL="http://localhost:8080/api"

# Token d'authentification (obtenu via bootstrap ou Machine Identity)
export INFISICAL_TOKEN="eyJhbGciOiJIUz..."

Créer un projet

Un projet regroupe les secrets d’une application. Pour créer un projet via l’API :

# Récupérer l'ID de l'organisation
ORG_ID=$(curl -s http://localhost:8080/api/v1/organizations \
  -H "Authorization: Bearer $INFISICAL_TOKEN" | jq -r '.[0].id')

# Créer le projet
PROJECT=$(curl -s -X POST http://localhost:8080/api/v2/workspace \
  -H "Authorization: Bearer $INFISICAL_TOKEN" \
  -H "Content-Type: application/json" \
  -d "{\"projectName\": \"mon-application\", \"organizationId\": \"$ORG_ID\"}")

PROJECT_ID=$(echo $PROJECT | jq -r '.project.id')
echo "Projet créé : $PROJECT_ID"

Le projet est créé avec trois environnements par défaut : dev, staging, prod.

Créer des secrets

infisical secrets set DATABASE_URL="postgres://user:pass@db:5432/myapp" \
  --token "$INFISICAL_TOKEN" \
  --projectId "$PROJECT_ID" \
  --env dev \
  --domain http://localhost:8080

Résultat :

┌──────────────┬────────────────────────────────────────┬────────────────┐
│ SECRET NAME  │ SECRET VALUE                           │ STATUS         │
├──────────────┼────────────────────────────────────────┼────────────────┤
│ DATABASE_URL │ postgres://user:pass@db:5432/myapp     │ SECRET CREATED │
└──────────────┴────────────────────────────────────────┴────────────────┘

Créer plusieurs secrets en une commande :

infisical secrets set \
  API_KEY="sk-live-abc123" \
  REDIS_URL="redis://cache:6379/0" \
  JWT_SECRET="super-secret-key" \
  --token "$INFISICAL_TOKEN" \
  --projectId "$PROJECT_ID" \
  --env dev \
  --domain http://localhost:8080

Lister les secrets

infisical secrets \
  --token "$INFISICAL_TOKEN" \
  --projectId "$PROJECT_ID" \
  --env dev \
  --domain http://localhost:8080

Résultat :

┌──────────────┬────────────────────────────────────────┬─────────────┐
│ SECRET NAME  │ SECRET VALUE                           │ SECRET TYPE │
├──────────────┼────────────────────────────────────────┼─────────────┤
│ API_KEY      │ sk-live-abc123                         │ shared      │
│ DATABASE_URL │ postgres://user:pass@db:5432/myapp     │ shared      │
│ JWT_SECRET   │ super-secret-key                       │ shared      │
│ REDIS_URL    │ redis://cache:6379/0                   │ shared      │
└──────────────┴────────────────────────────────────────┴─────────────┘

Récupérer un secret spécifique

infisical secrets get DATABASE_URL \
  --token "$INFISICAL_TOKEN" \
  --projectId "$PROJECT_ID" \
  --env dev \
  --domain http://localhost:8080

Exporter les secrets

Format dotenv (pour fichiers .env) :

infisical secrets \
  --token "$INFISICAL_TOKEN" \
  --projectId "$PROJECT_ID" \
  --env dev \
  --domain http://localhost:8080 \
  --output dotenv > .env

Contenu généré :

API_KEY=sk-live-abc123
DATABASE_URL=postgres://user:pass@db:5432/myapp
JWT_SECRET=super-secret-key
REDIS_URL=redis://cache:6379/0

Format JSON :

infisical secrets \
  --token "$INFISICAL_TOKEN" \
  --projectId "$PROJECT_ID" \
  --env dev \
  --domain http://localhost:8080 \
  --output json

Modifier un secret

Utilisez set pour modifier un secret existant :

infisical secrets set DATABASE_URL="postgres://newuser:newpass@db:5432/myapp" \
  --token "$INFISICAL_TOKEN" \
  --projectId "$PROJECT_ID" \
  --env dev \
  --domain http://localhost:8080

Injecter les secrets dans une application

La fonctionnalité la plus puissante d’Infisical : l’injection runtime. Au lieu de copier les secrets dans des fichiers, la CLI les injecte directement dans les variables d’environnement de votre processus.

Commande infisical run

infisical run \
  --token "$INFISICAL_TOKEN" \
  --projectId "$PROJECT_ID" \
  --env dev \
  --domain http://localhost:8080 \
  -- npm start

Que se passe-t-il ?

1. La CLI récupère les secrets depuis Infisical
2. Elle les injecte comme variables d’environnement
3. Elle lance votre commande (npm start)
4. L’application accède aux secrets via process.env.DATABASE_URL

Exemples concrets

Application Node.js :

infisical run \
  --token "$INFISICAL_TOKEN" \
  --projectId "$PROJECT_ID" \
  --env dev \
  --domain http://localhost:8080 \
  -- node server.js

Application Python :

infisical run \
  --token "$INFISICAL_TOKEN" \
  --projectId "$PROJECT_ID" \
  --env dev \
  --domain http://localhost:8080 \
  -- python app.py

Script shell :

infisical run \
  --token "$INFISICAL_TOKEN" \
  --projectId "$PROJECT_ID" \
  --env dev \
  --domain http://localhost:8080 \
  -- sh -c 'echo "DATABASE_URL=$DATABASE_URL"'

Résultat :

2026-03-16 INF Injecting 4 Infisical secrets into your application process
DATABASE_URL=postgres://user:pass@db:5432/myapp

Mode watch (développement)

En développement, relancez automatiquement l’application quand les secrets changent :

infisical run --watch \
  --token "$INFISICAL_TOKEN" \
  --projectId "$PROJECT_ID" \
  --env dev \
  --domain http://localhost:8080 \
  -- npm run dev

Usage développement uniquement

Le mode --watch est conçu pour le développement local. N’utilisez pas cette option en production : les applications ne doivent pas redémarrer automatiquement sur des changements de configuration distants.

Intégration CI/CD

GitHub Actions

name: Deploy
on: [push]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Install Infisical CLI
        run: |
          curl -1sLf 'https://dl.cloudsmith.io/public/infisical/infisical-cli/setup.deb.sh' | sudo -E bash
          sudo apt install -y infisical

      - name: Run with secrets
        env:
          INFISICAL_TOKEN: ${{ secrets.INFISICAL_TOKEN }}
        run: |
          infisical run \
            --token "$INFISICAL_TOKEN" \
            --projectId "${{ vars.PROJECT_ID }}" \
            --env production \
            --domain "${{ vars.INFISICAL_URL }}" \
            -- ./deploy.sh

GitLab CI

deploy:
  stage: deploy
  image: ubuntu:22.04
  before_script:
    - apt update && apt install -y curl
    - curl -1sLf 'https://dl.cloudsmith.io/public/infisical/infisical-cli/setup.deb.sh' | bash
    - apt install -y infisical
  script:
    - infisical run
        --token "$INFISICAL_TOKEN"
        --projectId "$PROJECT_ID"
        --env production
        --domain "$INFISICAL_URL"
        -- ./deploy.sh
  variables:
    INFISICAL_TOKEN: $INFISICAL_TOKEN

Dépannage

Problème	Cause probable	Solution
Connection refused	Serveur non démarré	docker compose ps et vérifier les logs
401 Unauthorized	Token invalide ou expiré	Vérifier $INFISICAL_TOKEN
404 Not Found	Mauvais projectId ou env	Vérifier les IDs dans l’URL
Secret not found	Secret n’existe pas dans cet env	Vérifier --env
Bootstrap échoue	Instance déjà initialisée	Utiliser --ignore-if-bootstrapped

Glissez pour voir

Commandes de diagnostic

# Vérifier le statut du serveur
curl -s http://localhost:8080/api/status | jq

# Vérifier les logs
docker compose logs infisical

# Tester la connectivité
infisical secrets \
  --token "$INFISICAL_TOKEN" \
  --projectId "$PROJECT_ID" \
  --env dev \
  --domain http://localhost:8080

Fonctionnalités avancées

Les fonctionnalités ci-dessous nécessitent une licence Enterprise. Consultez la section Open Source vs Enterprise pour comprendre quand ces options deviennent pertinentes.

Dynamic Secrets

Les Dynamic Secrets génèrent des credentials éphémères à la demande. Au lieu d’un mot de passe PostgreSQL statique, Infisical crée un utilisateur temporaire avec une durée de vie limitée.

Avantages :

• Chaque application a ses propres credentials
• Les credentials expirent automatiquement
• Rotation automatique sans intervention

Secret Rotation

La rotation automatique change périodiquement les secrets pour les services qui ne supportent pas les dynamic secrets.

PKI (Public Key Infrastructure)

Infisical peut gérer vos certificats TLS : génération, renouvellement, distribution aux applications.

À retenir

1. Centraliser — stockez tous vos secrets dans Infisical, jamais dans le code
2. Séparer — utilisez des environnements différents (dev/staging/prod)
3. Automatiser — utilisez infisical run pour injecter les secrets au runtime
4. Sécuriser — protégez le token bootstrap comme un mot de passe root
5. Auditer — l’interface web trace qui accède à quoi

Prochaines étapes

HashiCorp Vault Alternative plus mature pour les grandes organisations

Mozilla SOPS Chiffrer les fichiers de configuration

Gitleaks Détecter les secrets exposés dans vos dépôts

Ressources

• Documentation officielle : infisical.com/docs
• GitHub : github.com/Infisical/infisical
• CLI Reference : infisical.com/docs/cli/overview

×

📖 Voir la documentation →