Accueil À propos Expérience Formations Certification Projets Compétences Ressources Contact
DevOps · Projet d'examen · Bac+4 · LaCapsule

NocoDB — Plateforme Cloud auto-déployée

Alternative open-source à Airtable déployée en conditions de production chez Linode : 4 VMs sécurisées, cluster Docker Swarm, supervision Prometheus/Grafana et pipeline GitLab CI/CD de bout en bout.

Terraform Ansible Docker Compose Docker Swarm GitLab CI/CD Prometheus Grafana Linode

01 Contexte

Un besoin de plateforme no-code, déployée comme un produit de production.

NocoDB est une alternative open-source à Airtable qui transforme n'importe quelle base de données en interface de type tableur (grid, kanban, galerie, formulaire…). Ce projet d'examen consiste à la déployer en conditions réelles de production chez le cloud provider Linode.

Le travail est découpé en deux dépôts complémentaires qui illustrent la séparation classique applicatif / infrastructure :

Projet mené en équipe de 2 (Vincent Dupeyron Villata, Olivier Tanneux), dans le cadre du Bac+4 DevOps LaCapsule — finalisé le 15 juillet 2026.

02 Enjeux business

Le projet a une dimension stratégique importante pour QuickData :

EnjeuDescription
Autonomie des équipesRéduire la dépendance aux développeurs pour la gestion quotidienne des données
StandardisationCentraliser la donnée autour d'un outil unique, connecté aux outils existants (BI, ML, reporting)
Souveraineté des donnéesSolution open source auto-hébergée garantissant confidentialité et contrôle total
Disponibilité et sécuritéInterface performante, hautement disponible, avec un modèle de permissions granulaire

03 Objectifs clés

Industrialiser le déploiement et garantir un niveau de production.

04 Stack technique

Une chaîne d'outils 100 % Infrastructure as Code et GitOps-friendly.

Infrastructure as Code

Terraform (providers Linode + OVH) pour le provisioning, Ansible (12 rôles) pour la configuration des VMs.

Conteneurs & Orchestration

Docker + Docker Swarm, image NocoDB personnalisée buildée depuis les sources GitHub.

CI/CD & Qualité

GitLab CI (pipelines chaînés), SonarCloud, GitLab Container Registry, stratégie de tags par SHA et par branche.

Supervision

Prometheus (v3.12), Grafana (v13), node_exporter, dashboards provisioning, alertes Slack.

Réseau & Sécurité

VPC privé 10.0.1.0/24, WireGuard VPN, Fail2ban, Squid, firewalls inbound DROP, Traefik + Let's Encrypt.

Tests & Données

Locust (tests de charge), PostgreSQL 16, Linode Object Storage (S3) pour les backups et artefacts.

05 Architecture

4 VMs Linode interconnectées via un VPC privé, derrière un bastion unique.

Schéma d'architecture NocoDB
Schéma micro de l'infrastructure : bastion, VPC privé, cluster Swarm et supervision.
RôleIP VPCIP publiqueType LinodeFonction
Bastion10.0.1.10Ouig6-nanode-1SSH, proxy, NAT, VPN, DNS
Supervision10.0.1.20Nong6-standard-1Prometheus + Grafana + PostgreSQL
Manager10.0.1.30Ouig6-nanode-1Orchestrateur Swarm + Traefik HTTPS
Worker110.0.1.31Nong6-standard-1Bases PostgreSQL + application NocoDB
Les VMs VPC-only (supervision, worker1) n'ont pas d'accès Internet direct : elles passent par le proxy Squid du bastion (10.0.1.10:3128) et par le NAT gateway.

Tout accès SSH passe obligatoirement par le bastion (principe du ProxyJump) : le port SSH standard (22) est fermé depuis l'extérieur et seul le bastion répond sur le port 1404. Les firewalls sont en inbound DROP par défaut et n'ouvrent que le strict nécessaire — SSH (1404) et WireGuard (51820) sur le bastion, HTTPS (443) sur le manager — le reste ne circulant qu'au sein du VPC privé 10.0.1.0/24.

Le VPC est provisionné en Terraform, avec un sous-réseau unique 10.0.1.0/24 dont les adresses sont attribuées manuellement pour la cohérence de l'architecture :

# terraform/vpc.tf — réseau privé isolé par environnement (dev/prod)
resource "linode_vpc" "vpc1" {
  label       = "${var.env}-vpc-${var.client}"
  region      = var.region
  description = "Réseau privé isolé pour les VMs internes"
}

resource "linode_vpc_subnet" "subnet1" {
  vpc_id = linode_vpc.vpc1.id
  label  = "${var.env}-subnet-${var.client}"
  ipv4   = "10.0.1.0/24"   # .10 bastion · .20 supervision · .30 manager · .31 worker1
}

06 CI/CD & Déploiement

Deux pipelines GitLab chaînés : l'image d'abord, l'infrastructure ensuite.

Pipeline applicatif (nocodb-appli) — 4 stages

Pipeline applicatif nocodb-appli
Pipeline applicatif (nocodb-appli) : 4 stages — prepare, analyze, build-and-push, trigger-deploy.
StageJobsRôle
prepareclone + patchesClonage du dépôt et application des patches
analyzeSonarCloudAnalyse qualité du code (merge requests + branche dev)
build-and-pushDocker build + push imageConstruction et publication de l'image Docker
trigger-deploytrigger API (nocodb-infra)Déclenchement du pipeline infrastructure

Pipeline infrastructure (nocodb-infra) — 20 jobs, 7 stages

Pipeline infrastructure nocodb-infra
Vue du pipeline d'infrastructure (nocodb-infra) : 20 jobs, 7 stages séquentiels.
StageJobsRôle
checkcheck_nocodb_imageVérifie la présence de l'image NocoDB custom
infrastructureterraformingTerraform apply + inventaire Ansible + artefacts S3
deploymentbastion → base → docker → swarm → nocodb → backupConfiguration séquentielle des VMs via Ansible
supervisionsupervision_tools → metrics_setup → metrics_collector → alert_rulesStack Prometheus/Grafana + alerting
nocodb_clientimport_* (manuels)Création des projets clients NocoDB
load-testinglocustTest de charge 100 utilisateurs, rapport HTML
toolsdestroy_nocodb / delete_bucket / tf-destroyDestruction contrôlée (manuel)

Le flux complet : push sur dev/main → build image → trigger infra → provisioning Terraform → configuration Ansible → application accessible en HTTPS via Traefik.

Quelques choix de conception notables : une vérification préalable (check_nocodb_image) s'assure que l'image attendue existe dans le registry avant tout provisionnement (les VMs Linode étant facturées à l'usage) ; les chaînes Ansible deployment et supervision s'exécutent en parallèle pour réduire la durée totale du pipeline ; et les actions sensibles ou coûteuses (tests de charge, destruction, imports clients) restent manuelles.

Fichiers sources

L'intégralité du pipeline est versionnée dans le dépôt : consultez le .gitlab-ci.yml (20 jobs, 7 stages) et le playbook Ansible principal qui orchestre les 12 rôles via ses tags.

Structure du dépôt nocodb-infra

Le code d'infrastructure est organisé autour de trois blocs — Terraform (provisioning), Ansible (configuration, 12 rôles) et GitLab CI (orchestration) :

nocodb-infra/
├── .gitlab-ci.yml            # pipeline (20 jobs, 7 stages)
├── .ci/                      # helpers du runner (ansible, terraform)
├── terraform/                # provisioning Linode
│   ├── providers.tf          #   linode + ovh + backend HTTP
│   ├── vpc.tf                #   VPC 10.0.1.0/24
│   ├── vm-bastion.tf         #   bastion + firewall DROP
│   ├── vm-nocodb-manager.tf  #   manager Swarm
│   ├── vm-nocodb-worker1.tf  #   worker Swarm
│   └── vm-supervision.tf     #   VM supervision (VPC-only)
├── ansible/
│   ├── site.yml              # playbook principal (12 rôles, tags ↔ jobs CI)
│   ├── group_vars/           # variables par groupe (all, supervision)
│   └── roles/
│       ├── bastion/          # fail2ban · squid · wireguard · NAT
│       ├── base/             # proxy + dépendances + scripts stress-test
│       ├── docker_install/   # Docker Engine
│       ├── swarm_init/       # init Swarm (manager)
│       ├── swarm_join/       # join des workers
│       ├── gitlab_login/     # pull des images depuis le registry
│       ├── nocodb/           # stack applicative NocoDB
│       ├── backup/           # pg_dump → S3 (systemd timer)
│       ├── supervision_tools/# docker-compose PG/Prometheus/Grafana
│       ├── metrics_setup/    # node_exporter (toutes les VMs)
│       ├── metrics_collector/# prometheus.yml (génération dynamique)
│       ├── grafana_alert_rules/# contact-points + alert rules
│       └── nocodb_clients/   # import des données clients
└── locust/                   # tests de charge (100 utilisateurs)

Lien jobs GitLab CI ↔ rôles Ansible

Chaque job du pipeline cible un tag du playbook site.yml, garantissant une correspondance stricte entre l'orchestration CI et la configuration :

# ansible/site.yml — extrait
- name: Déploiement de la stack supervision (Prometheus + Grafana + Postgres)
  hosts: supervision
  become: true
  tags: [monitoring, supervision, supervision_tools]
  roles: [supervision_tools]

- name: Installation des agents collector sur toutes les machines
  hosts: all
  become: true
  tags: [monitoring, supervision, metrics_setup]
  roles: [metrics_setup]

07 Supervision & Alerting

Une stack de monitoring déployée en 4 étapes sur la VM supervision.

La stack est déployée via docker-compose (3 services interconnectés), avec des healthchecks et des volumes persistants :

# ansible/roles/supervision_tools/templates/docker-compose.yml.j2
services:
  postgres:
    image: postgres:{{ graf_postgres_image_version }}
    volumes: [pgsql-data:/var/lib/postgresql/data]
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U {{ graf_postgres_user }} -d {{ graf_postgres_db }}"]
    restart: unless-stopped

  prometheus:
    image: prom/prometheus:{{ prometheus_image_version }}
    volumes:
      - "{{ prometheus_config_path }}/{{ prometheus_config_file }}:/etc/prometheus/prometheus.yml"
      - "{{ prometheus_data_path }}:/prometheus"
    restart: unless-stopped

  grafana:
    image: grafana/grafana:{{ grafana_image_version }}
    environment:
      GF_DATABASE_TYPE: postgres
      GF_DATABASE_HOST: postgres:5432
    depends_on:
      postgres:   { condition: service_healthy }
      prometheus: { condition: service_healthy }
    restart: unless-stopped

Dashboards Grafana provisionnés automatiquement

Les dashboards sont déployés via le provisioning automatique de Grafana (hot-reload, sans intervention manuelle), ce qui garantit un rendu identique sur chaque environnement (dev / prod) et une mise en place reproductible dès le deploy.

Le provider de dashboards est déclaré en YAML (template Jinja2) : chaque dossier du dépôt est mappé vers un dossier Grafana dédié, avec un rechargement toutes les 30 secondes :

# ansible/roles/supervision_tools/templates/grafana/provisioning/dashboards/dashboards.yml.j2
apiVersion: 1

providers:
  - name: "MCO-Perf"
    type: file
    updateIntervalSeconds: 30
    allowUiUpdates: true
    options:
      path: /etc/grafana/provisioning/dashboards/mco-perf
    folder: "MCO & Perf"

  - name: "MCO-Container"
    type: file
    updateIntervalSeconds: 30
    allowUiUpdates: true
    options:
      path: /etc/grafana/provisioning/dashboards/mco-container
    folder: "MCO & Container"

  - name: "Template-Base"
    type: file
    updateIntervalSeconds: 30
    allowUiUpdates: true
    options:
      path: /etc/grafana/provisioning/dashboards/template-base
    folder: "Template-Base"

Les dashboards au format JSON sont versionnés dans le dépôt puis déployés par Ansible en préservant l'arborescence :

ansible/roles/metrics_collector/files/grafana/provisioning/dashboards/
├── mco-container/
│   └── mco-container.json               # Dashboard « Docker Swarm – NocoDB »
├── mco-perf/
│   └── mco-perf-node-metrics.json       # Dashboard « MCO & Perf – Node Metrics »
└── template-base/
    ├── 1860-node_exporter_full.json     # Dashboard communautaire « Node Exporter Full »
    └── 21476_rev2.json                  # Dashboard communautaire « Node Exporter Server »
Liste des dashboards Grafana NocoDB
Vue d'ensemble des dashboards provisionnés, organisés en dossiers : « MCO & Perf », « Docker Swarm – NocoDB ».

Les dashboards sont répartis en deux dossiers : « MCO & Perf » (métriques système de chaque VM) et « Docker Swarm – NocoDB » (état des containers applicatifs). À côté du dashboard personnalisé MCO & Perf – Node Metrics, deux dashboards communautaires de référence (Node Exporter Full, Node Exporter Server) complètent la vue.

Pour entrer dans le détail, le dashboard personnalisé « MCO & Perf – Node Metrics » agrège les métriques système remontées par chaque node_exporter et les restitue en panneaux CPU, RAM, disque, réseau et disponibilité :

Dashboard Grafana MCO & Perf – Node Metrics
Dashboard « MCO & Perf – Node Metrics » : CPU, RAM, disque, réseau et disponibilité de chaque VM de l'infrastructure.

La configuration Prometheus est générée dynamiquement par Ansible : une boucle Jinja ajoute automatiquement chaque VM du groupe all comme cible node_exporter, sans édition manuelle.

# ansible/roles/metrics_collector/templates/prometheus.yml.j2
scrape_configs:
  - job_name: "node_exporter"
    static_configs:
{% for host in groups['all'] %}
      - targets:
          - "{{ hostvars[host]['ansible_private_ip'] }}:{{ node_exporter_port }}"
        labels:
          hostname: "{{ host }}"
{% endfor %}

Fichiers sources — rôles de la stack supervision

Chaque étape de la stack correspond à un rôle Ansible dédié dont voici le tasks/main.yml : déploiement des services (supervision_tools), installation des agents node_exporter (metrics_setup) et collecte des métriques (metrics_collector).

Alerting

Deux niveaux de sévérité (warning / critical) avec une persistance de 5 minutes, afin de filtrer les pics ponctuels et de n'alerter que sur des anomalies durables. Le SMTP OVH étant bloqué par Linode, les alertes sont notifiées via un webhook Slack relié au channel de l'équipe, avec un webhook sélectionné automatiquement selon l'environnement (prod / preprod).

Règles d'alerte Grafana NocoDB
Règles d'alerte Grafana organisées en rule groups (CPU, DISK, RAM, UP/DOWN) dans le dossier « MCO & Perf ».

Fichiers sources

La règle UP/DOWN (lignes « Hosts DOWN » et « Node DOWN » du tableau ci-dessous) est générée dynamiquement par Ansible : une boucle Jinja crée une alerte « Node DOWN » par VM à partir de ce template.

Seuils d'alerte

MétriqueSeuil warningSeuil critiqueCondition
CPU Busy> 85 %> 95 %5 min
RAM Usage> 85 %> 95 %5 min
Disque /> 85 %> 95 %5 min
Hosts DOWN—injoignable1 min
Node DOWN—injoignable2 min

Les seuils à 85 % / 95 % laissent une marge suffisante pour agir avant la bascule en critique, et la persistance de 5 minutes filtre les pics ponctuels (batch, montée de charge courte) pour n'alerter que sur des anomalies durables. Les règles UP/DOWN n'ont pas de seuil intermédiaire — un hôte est up ou down — avec une persistance réduite car l'indisponibilité totale doit être remontée rapidement. La règle Node DOWN (nœuds Swarm) n'est pas encore activée : elle est prévue pour une prochaine itération.

Notification Slack

Chaque métrique est organisée en rule group dédié (MCO & Perf – CPU / DISK / RAM / UP-DOWN), provisionné et évalué sur un intervalle d'une minute. La chaîne a été validée de bout en bout à l'aide de scripts de stress test déployés sur chaque VM (stress-test-cpu.sh, stress-test-ram.sh) : ils montent artificiellement le CPU/RAM pour déclencher les alertes Warning/Critical et vérifier la notification Slack puis la résolution automatique.

Le routage des notifications est lui aussi provisionné en YAML, avec une politique dédiée par sévérité :

# ansible/roles/grafana_alert_rules/templates/notification-policies.yml.j2
policies:
  - receiver: "{{ grafana_alert_contact_point_name }}"   # webhook Slack
    group_by: [alertname, nodename, severity]
    routes:
      - matchers: [severity = warning]
        group_interval: 5m
        repeat_interval: 4h
      - matchers: [severity = critical]
        group_interval: 1m
        repeat_interval: 1h
Notification Slack d'alerte NocoDB
Notification Slack reçue lors du déclenchement d'une alerte Grafana, envoyée par le webhook configuré par environnement.

Fichiers sources — rôle grafana_alert_rules

Le rôle Ansible grafana_alert_rules provisionne l'ensemble de l'alerting : contact point Slack, politiques de notification et règles d'alerte JSON (CPU, RAM, disque). Voici les fichiers tels qu'ils sont versionnés dans le dépôt.

Provisioning & notification
Règles d'alerte (seuils CPU / RAM / Disque)

08 Backups

Sauvegardes quotidiennes automatisées vers Linode Object Storage.

Fichiers sources

Le rôle Ansible backup orchestre l'ensemble : installation de s3cmd, déploiement des scripts backup.sh / restore.sh, puis planification automatique via le timer systemd (3 exécutions par jour).

09 Tests de charge

Validation de la tenue en charge avec Locust, intégré au pipeline.

MétriqueCible
Succès≥ 99 %
P50 (médiane)≤ 500 ms
P95≤ 1000 ms
P99≤ 2000 ms

Fichiers sources

Le scénario de test de charge est défini dans locustfile.py : chaque tâche cible une route avec un poids et une validation catch_response pour faire remonter les erreurs 5xx et les lenteurs dans les métriques.

10 Sécurité

Une posture de production : moindre exposition, accès strictement maîtrisés.

Fichiers sources — rôle bastion

Toute la posture de sécurité est codifiée dans le rôle Ansible bastion : Fail2ban, WireGuard, NAT iptables, proxy Squid et routage, chacun dans un fichier de tâches dédié, orchestrés par le tasks/main.yml.

11 Retours d'expérience

Ce que ce projet m'a appris.