VS Code pour SRE/DevOps sur macOS avec GitLab

VS Code Pro sur macOS

Configuration optimale pour SRE, DevOps et Infrastructure as Code

Transformez VS Code en IDE puissant pour gérer Kubernetes, Terraform, Docker et GitLab. Avec les bonnes extensions, settings et intégrations, vous développerez et déploierez plus vite.

VS Code est l’éditeur par défaut des ingénieurs SRE et DevOps en 2026. Contrairement aux IDEs lourds, il est léger, extensible et tourne partout. Ce guide vous montre comment le configurer pour être productif sur Kubernetes, Terraform, Docker et les microservices, avec une intégration GitLab fluide et des workflows d’automatisation.

Prérequis : Installer les outils CLI (Terraform, kubectl, etc.)

VS Code a besoin que les outils CLI soient installés localement pour que les extensions fonctionnent. Voici comment les installer correctement via Homebrew.

Installation complète des outils DevOps/SRE

Avant de configurer VS Code, installez d’abord tous les outils CLI nécessaires :

brew tap hashicorp/tap

brew install git kubernetes-cli helm checkov docker awscli aws-vault hashicorp/tap/terraform kubectx k9s lazydocker jq yq

Installation optionnelle : TFLint (linter Terraform)

TFLint n’est pas dans Homebrew. Installez-le via Go (si vous avez Go installé) :

go install github.com/terraform-linters/tflint@latest

Ou téléchargez directement depuis GitHub releases.

Vérifiez que tout est installé correctement :

terraform –version
Terraform v1.x.x

kubectl version –client
Client Version: v1.x.x

helm version
version.BuildInfo{Version:”v3.x.x”}

docker –version
Docker version 25.x.x

aws –version
aws-cli/2.x.x

                Important : Les extensions VS Code (Terraform, Kubernetes, Docker) s’appuient sur ces outils CLI. Sans eux, les extensions afficheront des erreurs ou ne fonctionneront pas correctement. Ces tools doivent être dans votre PATH (which terraform doit marcher).
            

Installation et configuration initiale

VS Code est gratuit et open-source. Installation simple via Homebrew ou directement.

Installer VS Code

brew install –cask visual-studio-code

Ou téléchargez directement : code.visualstudio.com

Lancer VS Code depuis le terminal

Pour ouvrir VS Code depuis le terminal partout, installez la commande code :

Ouvrez VS Code
Appuyez sur Cmd + Shift + P
Tapez install code command
Cliquez le résultat

Maintenant, vous pouvez :

code .
# Ouvre le dossier courant dans VS Code

code FILE.tf
# Ouvre un fichier spécifique

Extensions essentielles pour SRE et DevOps

VS Code vaut surtout par ses extensions. Voici les 20+ indispensables pour DevOps.

Installation rapide des extensions

Installez-les une par une via Cmd + Shift + X (Extensions Panel) ou via la ligne de commande :

code –install-extension ms-kubernetes-tools.vscode-kubernetes-tools

code –install-extension hashicorp.terraform

code –install-extension ms-azuretools.vscode-docker

Les extensions incontournables par catégorie

Kubernetes & Containerization

Kubernetes	ms-kubernetes-tools.vscode-kubernetes-tools	Gestion complète : deploy, logs, debug, manifests YAML
Docker	ms-azuretools.vscode-docker	Build, run, debug conteneurs. Exploration d’images
Dev Containers	ms-vscode-remote.remote-containers	Développer à l’intérieur de conteneurs (DevOps workflow)

Infrastructure as Code

Terraform	hashicorp.terraform	Syntax highlighting, validation, auto-completion
Terraform Plan Viewer	DeepByteAI.terraform-plan	Visualisation graphique des plans Terraform
CloudFormation	aws-scripting-guy.cform	Support AWS CloudFormation (si applicable)

Cloud & AWS

AWS Toolkit	AmazonWebServices.aws-toolkit-vscode	Lambda, S3, CloudFormation, Explorer cloud
AWS CLI Toolkit	Lex.aws-cli-helper	Auto-complétion pour AWS CLI commands

Git & GitLab

GitLab Workflow	GitLab.gitlab-workflow	Integration GitLab : MR, issues, pipelines dans VS Code
Git Graph	mhutchie.git-graph	Visualisation graphique du workflow Git
Gitlens	eamodio.gitlens	Blame, history, authorship inline dans le code

Syntaxe, Linting & Formatage

YAML	redhat.vscode-yaml	Validation YAML (Kubernetes manifests, Helm)
JSON	ZainChen.json	Validation JSON avec schéma
Python	ms-python.python	Support Python avec Pylint, Pytest
HashiCorp HCL	hashicorp.hcl	HCL syntax highlighting (Terraform, Nomad, etc.)
Bash IDE	mads-hartmann.bash-ide-vscode	Linting et debugging pour scripts Shell

Sécurité & Scanning

Checkov	Bridgecrewio.checkov	Scan IaC pour les vulnerabilités de sécurité
GitGuardian	GitGuardian.gitguardian	Détection de secrets en temps réel (API keys, tokens)

Productivité & Debugging

REST Client	humao.rest-client	Tester les APIs sans Postman (fichiers .http)
Thunder Client	rangav.vscode-thunder-client	Alternative légère Postman
Peacock	johnpapa.vscode-peacock	Colorer vos workspaces pour passer rapidement entre prod/staging/dev
Better Comments	aaron-bond.better-comments	Colorer les commentaires pour de meilleures notes

Settings VS Code optimisés pour SRE

Les settings par défaut conviennent à la plupart. Voici les ajustements SRE essentiels.

Ouvrir settings.json

Appuyez sur Cmd + Shift + P, tapez Preferences: Open Settings (JSON).

{
  // Format & Linting
  “editor.formatOnSave”: true,
  “editor.defaultFormatter”: “ms-python.python”,
  “python.linting.enabled”: true,
  “python.linting.pylintEnabled”: true,

  // Terraform
  “[hcl]”: {
    “editor.defaultFormatter”: “hashicorp.terraform”,
    “editor.formatOnSave”: true
  },

  // YAML pour Kubernetes
  “[yaml]”: {
    “editor.defaultFormatter”: “esbenp.prettier-vscode”,
    “editor.formatOnSave”: true,
    “editor.tabSize”: 2
  },

  // Git & GitLab
  “git.autofetch”: true,
  “git.confirmSync”: false,
  “gitlab.gitlabUrl”: “https://gitlab.com”,

  // UI & Appearance
  “workbench.colorTheme”: “Dracula”,
  “workbench.iconTheme”: “vscode-icons”,
  “editor.fontSize”: 13,
  “editor.fontFamily”: “‘Monaco’, ‘Menlo’, ‘Ubuntu Mono’, monospace”,

  // Workspace Peacock (colorer par environment)
  “peacock.favs”: [
    {
      “name”: “Production”,
      “color”: “#d73a49”
    },
    {
      “name”: “Staging”,
      “color”: “#f97316”
    },
    {
      “name”: “Development”,
      “color”: “#2dd4bf”
    }
  ],

  // Kubernetes contexts colorisation
  “vscode-kubernetes-tools.disable-linting”: false,
  “vscode-kubernetes-tools.kubectl-path”: “/opt/homebrew/bin/kubectl”,

  // Search & File exclusions
  “search.exclude”: {
    “**/.git”: true,
    “**/node_modules”: true,
    “**/terraform/.terraform”: true,
    “**/.terraform”: true
  },

// Git commit message template
“git.defaultCloneDirectory”: “~/projects”
}

Intégration GitLab complète

L’extension GitLab Workflow rend GitLab fluide dans VS Code : MR, issues, pipelines, approvals.

Configuration initiale GitLab

Installez l’extension GitLab Workflow (GitLab.gitlab-workflow)
Appuyez sur Cmd + Shift + P, tapez GitLab: Add token
Visitez GitLab Personal Access Tokens
Créez un token avec les scopes : api, read_api, read_repository, write_repository
Collez le token dans VS Code

                Scope recommandé : api, read_repository, write_repository, read_user. Ne partagez jamais votre token.
            

Cloner un repository GitLab

code –folder-uri “https://gitlab.com/YOUR_GROUP/YOUR_REPO.git”
# Ouvre le repo dans VS Code

Ou utiliser la commande VS Code :

Cmd + Shift + P / Git: Clone
Collez l’URL du repo GitLab
Choisissez le dossier destination

Workflow typique : Créer et merger une MR

Créer une branche feature

git checkout -b feature/fix-kubernetes-yaml
# Vous pouvez aussi cliquer sur la branche en bas à gauche

Faire les changements et commit

Modifiez vos fichiers Terraform, manifests YAML, etc.

Dans la Section Source Control (Cmd + Shift + G) :

Cliquez + pour stage les fichiers (ou Stage All)
Tapez votre message de commit
Cliquez Commit ou appuyez sur Cmd + Enter

Push et créer une MR via la palette de commandes

Cmd + Shift + P

GitLab: Create Merge Request

VS Code vous demandera le titre, la description, et créera la MR directement.

Approuver et merger depuis VS Code

Dans le sidebar GitLab (si activé), vous voyez :

Vos MR ouvertes
Approvals requis
Pipelines CI/CD
Un click pour approuver ou merger

Commandes GitLab utiles

Appuyez sur Cmd + Shift + P et tapez GitLab: pour voir toutes les commandes :

GitLab: Open Current File on GitLab – Ouvrir le fichier sur le web
GitLab: Open Current Merge Request – Ouvrir la MR en cours
GitLab: Show Issues – Lister les issues du projet
GitLab: Show Pipeline – Voir les pipelines CI/CD
GitLab: Open Project Page – Aller au projet sur le web

Configuration Git et Commit best practices

Configurez Git pour que vos commits soient clairs et tracés correctement.

Configuration Git sur macOS

git config –global user.name “Seif”

git config –global user.email “seif@tls.contact”

git config –global core.editor “code”

Template de commit message

Créez un fichier pour standardiser les messages de commit :

cat > ~/.gitmessage << 'EOF'
# type(scope): subject
#
# type: feat, fix, refactor, perf, docs, style, test, chore
# scope: kubernetes, terraform, docker, ci-cd, infra
# subject: courte description (50 char max)
#
# Corps optionnel
EOF

git config –global commit.template ~/.gitmessage

Exemples de commits SRE

git commit -m “feat(kubernetes): add HPA for API deployment”

git commit -m “fix(terraform): correct VPC CIDR block for prod-eu1”

git commit -m “docs(infra): update Kubernetes runbook for pod crashes”

git commit -m “perf(docker): reduce base image size from 200MB to 85MB”

Workflows avancés : Debugging, Testing, Deployment

Au-delà de l’édition basique, VS Code supporte des workflows complets DevOps.

Debug Python en local

Si vous avez des scripts Python pour l’infrastructure :

Installez l’extension Python (ms-python.python)
Créez un fichier .vscode/launch.json :

{
  “version”: “0.2.0”,
  “configurations”: [
    {
      “name”: “Python: Current File”,
      “type”: “python”,
      “request”: “launch”,
      “program”: “${file}”,
      “console”: “integratedTerminal”
    }
  ] }

Puis appuyez sur F5 pour debugger.

Tester des APIs avec REST Client

Créez un fichier api-test.http :

### Get pods from Kubernetes API
GET https://kubernetes.default.svc/api/v1/namespaces/default/pods
Authorization: Bearer ${K8S_TOKEN}

### Create a resource via Terraform API
POST https://app.terraform.io/api/v2/organizations/MY_ORG/workspaces
Authorization: Bearer ${TF_API_TOKEN}
Content-Type: application/vnd.api+json

{
  “data”: {
    “type”: “workspaces”,
    “attributes”: {
      “name”: “my-workspace”
    }
  }
}

Installez REST Client et cliquez Send Request au-dessus de chaque bloc.

Validate Terraform avant de push

Créez une task de build :

Cmd + Shift + B (Run Build Task)
Choisissez Terraform: Validate (si vous avez l’extension)
Les erreurs s’affichent dans le terminal intégré

Développer dans des conteneurs (Dev Containers)

Si vous avez Dev Containers installé :

Créez un dossier .devcontainer à la racine
Créez un fichier devcontainer.json :

{
  “name”: “Terraform Dev”,
  “image”: “mcr.microsoft.com/devcontainers/go:latest”,
  “customizations”: {
    “vscode”: {
      “extensions”: [
        “hashicorp.terraform”,
        “ms-kubernetes-tools.vscode-kubernetes-tools”,
        “GitLab.gitlab-workflow”
      ]     }
  }
}

Ensuite, Cmd + Shift + P / Dev Containers: Reopen in Container. VS Code développe à l’intérieur du conteneur avec les extensions pré-installées.

Raccourcis et tips de productivité

Voici les raccourcis macOS/VS Code qui vous feront gagner du temps.

Cmd + P	Ouvrir un fichier rapidement (tapez le nom)
Cmd + F	Chercher dans le fichier courant
Cmd + Shift + F	Chercher dans tous les fichiers du project
Cmd + H	Replace dans le fichier courant
Cmd + Shift + H	Replace dans tous les fichiers
Cmd + Shift + G	Ouvrir Source Control (Git panel)
Cmd + Shift + D	Ouvrir Debug panel
Cmd + Shift + X	Ouvrir Extensions
Cmd + Shift + P	Palette de commandes (vos superpouvoir)
Cmd + `	Ouvrir/Fermer le terminal intégré
Cmd + K + 0	Plier tout (collapse all code blocks)
Cmd + K + J	Déplier tout
Alt + Click	Multi-curseur (éditer plusieurs lignes)
Cmd + D	Select next (éditer multiples occurrences du mot sélectionné)

Themes et appearance optimisés

Un bon theme rend la journée plus agréable et réduit la fatigue oculaire.

Themes recommandés pour SRE

Dracula Official

Identifier : dracula-theme.theme-dracula

Le theme le plus populaire dans la communauté tech. Sombre, lisible, polychrome.

One Dark Pro

Identifier : zhuangtongfa.material-theme

Parfait pour de longues sessions. Couleurs froides, sans fatigue oculaire.

Gruvbox Dark Medium

Identifier : jdinhlife.gruvbox

Retro et charmant. Excellentes contrastes, idéal pour les terminaux de prod.

Icons theme

Icons pour différencier les fichiers rapidement :

vscode-icons (vscode-icons-team.vscode-icons) : Icons colorées et détaillées
Material Icon Theme (PKief.material-icon-theme) : Design Google Material

Font recommandée pour VS Code

Utilisez la même police MesloLGS NF qu’iTerm2 :

“editor.fontFamily”: “‘MesloLGS NF’, Monaco, ‘Courier New’, monospace”,
“editor.fontSize”: 13,
“editor.fontLigatures”: true

Vous êtes prêt pour VS Code Pro

Vous avez maintenant un éditeur entièrement configuré pour :

Kubernetes (manifests YAML, deployments, debugging)
Terraform (validation, plan visualization, formatting)
Docker (build, run, debug images et containers)
GitLab (MR, issues, pipelines, approvals, ci/cd)
AWS (Lambda, S3, CloudFormation)
Python, Shell, Go et autres langages
Tests et debugging locaux rapides

Prochaines étapes :

Explorez les Workspaces VS Code (fichier .code-workspace) pour ouvrir plusieurs repos à la fois
Configurez les snippets personnalisés pour vos patterns Terraform/Kubernetes courants
Utilisez la tâche de build pour valider automatiquement vos IaC avant commit
Installez les extensions language-specific pour vos langages (Go, Python, Node, etc.)

Vous travaillerez maintenant 3 fois plus vite et avec beaucoup moins d’erreurs. VS Code est votre compagnon de todos les jours pour la gestion d’infrastructure.