Visual Studio Code

Présentation

Visual Studio Code, généralement abrégé en VS Code, est un éditeur de code développé par Microsoft. Il est disponible gratuitement sur Windows, macOS et Linux, ainsi que dans une version allégée utilisable depuis un navigateur.

L’outil cherche à conserver la rapidité et la simplicité d’un éditeur de texte tout en proposant une grande partie des fonctions attendues dans un environnement de développement intégré. Il réunit notamment la coloration syntaxique, la complétion intelligente, la navigation dans le code, le débogage, les tests, le contrôle de version, le terminal et la gestion de projets.

Contrairement à un IDE traditionnel livré avec un ensemble fixe d’outils pour un langage précis, Visual Studio Code repose largement sur un système d’extensions. L’utilisateur peut construire un environnement adapté à Python, JavaScript, TypeScript, Rust, C++, Java, PHP, Go, .NET, aux technologies web, aux notebooks ou à de nombreux autres usages.

Cette modularité permet d’utiliser le même éditeur pour des projets très différents. Une installation minimale peut servir à modifier rapidement quelques fichiers, tandis qu’une configuration enrichie peut devenir un environnement complet pour développer, tester, documenter, conteneuriser et déployer une application.

Visual Studio Code est construit à partir du projet Code - OSS, dont le code source est publié par Microsoft sous licence MIT. La version officielle téléchargée depuis le site de Visual Studio Code ajoute cependant des éléments propres à Microsoft, notamment la marque, l’accès au Visual Studio Marketplace, certaines recommandations d’extensions et quelques intégrations sous licence propriétaire.

Cette distinction explique pourquoi Visual Studio Code est parfois décrit comme open source et parfois comme propriétaire. Son socle principal est ouvert, mais la distribution officielle Microsoft ne correspond pas exactement à une compilation neutre du dépôt Code - OSS.

Des distributions comme VSCodium recompilent ce socle ouvert en retirant les éléments de marque et de télémétrie propres à Microsoft. Elles proposent une expérience proche, mais peuvent rencontrer des différences concernant le Marketplace ou certaines extensions réservées à la famille de produits Visual Studio.

Visual Studio Code occupe également une place centrale dans l’écosystème du développement assisté par intelligence artificielle. GitHub Copilot y propose des suggestions en ligne, un chat, des modifications ciblées, des agents capables d’intervenir sur plusieurs fichiers et des connexions à des outils externes.

Ces fonctions d’IA ne modifient pas le modèle économique de base de VS Code : l’éditeur reste gratuit. GitHub Copilot constitue toutefois un service distinct, avec une formule gratuite limitée et différentes offres payantes.

Fonctionnalités

• Édition de code multiplateforme : utilisation sur Windows, macOS et Linux avec une interface et des raccourcis largement cohérents entre les systèmes.

• Version Web : accès à une édition légère de VS Code depuis un navigateur grâce à vscode.dev, sans installation locale.

• Explorateur de fichiers : navigation dans l’arborescence d’un projet, création de fichiers et dossiers, déplacements, renommages et opérations courantes.

• Espaces de travail : ouverture d’un dossier complet ou création d’un workspace réunissant plusieurs dossiers dans une même fenêtre.

• Édition en onglets : ouverture simultanée de nombreux fichiers, groupes d’éditeurs, fractionnement horizontal ou vertical et réorganisation de l’espace de travail.

• Coloration syntaxique : reconnaissance et mise en forme du code selon le langage utilisé.

• IntelliSense : complétion contextuelle, informations sur les paramètres, documentation intégrée, suggestions de symboles et aide à la saisie.

• Navigation dans le code : accès aux définitions, références, implémentations, symboles, appels et structures d’un projet.

• Renommage de symboles : modification cohérente d’une fonction, variable, classe ou méthode dans les fichiers concernés lorsque le langage le permet.

• Refactorisation : extraction de méthodes, organisation des imports, déplacement de code et autres transformations fournies par les extensions de langage.

• Diagnostics en temps réel : affichage des erreurs, avertissements et problèmes détectés par les compilateurs, linters ou serveurs de langage.

• Actions rapides : suggestions de corrections, imports automatiques, transformations de code et résolution de certains diagnostics.

• Snippets : insertion rapide de structures de code réutilisables avec champs de saisie et variables.

• Multi-curseurs : édition simultanée de plusieurs positions ou occurrences dans un document.

• Recherche globale : recherche et remplacement dans un fichier, un dossier ou l’ensemble d’un espace de travail.

• Expressions régulières : filtrage avancé et transformations complexes grâce aux recherches utilisant des motifs.

• Palette de commandes : accès rapide à la plupart des fonctions de l’éditeur sans parcourir les menus.

• Raccourcis personnalisables : modification complète des combinaisons de touches et import de keymaps inspirées d’autres éditeurs.

• Terminal intégré : exécution de commandes, scripts, outils de compilation, gestionnaires de paquets et serveurs sans quitter l’éditeur.

• Plusieurs terminaux : création d’onglets, division de panneaux et utilisation simultanée de différents shells.

• Intégration du shell : reconnaissance des commandes, liens vers les fichiers, statut d’exécution, navigation entre les commandes et détection de certaines erreurs.

• Tâches automatisées : configuration de commandes pour compiler, tester, lancer un serveur, générer des fichiers ou exécuter d’autres opérations répétitives.

• Débogueur intégré : points d’arrêt, inspection des variables, pile d’appels, exécution pas à pas et console de débogage.

• Configurations de lancement : définition de plusieurs scénarios de démarrage et de débogage dans les fichiers du projet.

• Débogage JavaScript et TypeScript : prise en charge intégrée des applications Node.js et des applications web exécutées dans Chrome ou Edge.

• Adaptateurs de débogage : ajout de la prise en charge d’autres langages et environnements au moyen d’extensions.

• Gestion des tests : découverte, lancement, filtrage et suivi des tests depuis une interface dédiée.

• Couverture de code : affichage des résultats de couverture lorsque le framework et l’extension utilisés le permettent.

• Git intégré : détection automatique des dépôts, suivi des fichiers modifiés, staging, commits, branches, synchronisation et consultation des différences.

• Éditeur de différences : comparaison côte à côte ou en ligne des versions d’un fichier.

• Résolution des conflits : outils intégrés et éditeur de fusion à trois voies pour traiter les conflits Git.

• Historique graphique : visualisation des branches, commits, relations entre versions et modifications apportées aux fichiers.

• Git worktrees et stashes : gestion de plusieurs branches de travail et sauvegarde temporaire de modifications.

• Intégration GitHub : clonage et publication de dépôts, authentification et accès à certaines fonctions GitHub.

• Pull requests et issues : création, consultation et révision grâce à l’extension officielle GitHub Pull Requests and Issues.

• Autres systèmes de versionnement : ajout de Subversion, Mercurial, Azure DevOps ou d’autres fournisseurs par extension.

• Visual Studio Marketplace : catalogue d’extensions ajoutant des langages, débogueurs, thèmes, linters, outils cloud et intégrations diverses.

• Installation automatique des mises à jour d’extensions : maintien des extensions à jour selon les réglages de l’utilisateur.

• Recommandations d’extensions : suggestions adaptées au type de projet, aux fichiers ouverts ou à une configuration partagée par l’équipe.

• Extensions propres au projet : déclaration d’une liste d’extensions recommandées dans le dossier de configuration du workspace.

• API d’extension : possibilité de développer ses propres commandes, vues, langages, débogueurs, éditeurs spécialisés et intégrations.

• Thèmes visuels : modification des couleurs de l’interface, de la syntaxe, des icônes et de l’apparence générale.

• Polices et ligatures : personnalisation de la typographie utilisée dans le code et le terminal.

• Disposition personnalisable : déplacement des panneaux, barres latérales, vues, terminaux et éditeurs.

• Mode Zen : réduction des éléments d’interface afin de concentrer l’écran sur le code.

• Profiles : création de configurations séparées regroupant extensions, réglages, raccourcis, thèmes et disposition.

• Partage de profils : exportation d’un profil dans un fichier ou un GitHub Gist afin de le réutiliser ou de le transmettre à une équipe.

• Settings Sync : synchronisation des paramètres, raccourcis, extensions, snippets et profils entre plusieurs appareils.

• Paramètres utilisateur et projet : séparation entre les préférences globales et les réglages spécifiques à un workspace.

• Configuration au format JSON : accès direct aux paramètres et automatisations pour les utilisateurs avancés.

• Fichiers Markdown : coloration, prévisualisation, navigation dans les titres et prise en charge des liens et images.

• Notebooks Jupyter : ouverture, édition et exécution de notebooks grâce aux extensions Python et Jupyter.

• Éditeurs personnalisés : prise en charge de vues spécialisées pour certains fichiers, graphiques, données ou interfaces.

• Développement distant par SSH : ouverture d’un dossier situé sur une machine distante tout en conservant une interface locale.

• Visual Studio Code Server : installation d’un composant sur la machine distante afin d’exécuter les extensions et outils au plus près du projet.

• Remote Tunnels : connexion à une autre machine au moyen d’un tunnel sécurisé sans devoir configurer directement un serveur SSH.

• Windows Subsystem for Linux : développement dans une distribution Linux installée avec WSL depuis l’interface Windows de VS Code.

• Dev Containers : ouverture d’un projet dans un conteneur disposant de ses propres dépendances, outils et paramètres.

• Configuration devcontainer.json : description reproductible d’un environnement de développement conteneurisé.

• Redirection de ports : accès depuis la machine locale à un serveur ou service exécuté dans un environnement distant.

• GitHub Codespaces : connexion à des environnements de développement hébergés depuis la version desktop ou Web.

• Version navigateur pour GitHub : consultation rapide d’un dépôt avec github.dev depuis la page d’un projet GitHub.

• Gestion de la confiance : mode Workspace Trust destiné à limiter l’exécution automatique de code dans les projets non approuvés.

• Accessibilité : navigation au clavier, prise en charge des lecteurs d’écran, zoom, contraste élevé et autres réglages adaptés.

• Localisation : traduction de l’interface dans plusieurs langues au moyen de packs linguistiques.

• Mises à jour fréquentes : évolution régulière de l’éditeur, des API, du support des plateformes et des fonctions de développement.

• Version Insiders : édition de prévisualisation permettant de tester plus tôt les nouvelles fonctionnalités.

• Suggestions GitHub Copilot : propositions de lignes ou blocs de code directement dans l’éditeur.

• Chat Copilot : interface conversationnelle pour poser des questions sur le code, demander une explication ou préparer une modification.

• Chat en ligne : instruction ciblée directement dans un fichier ou une sélection.

• Mode agent : délégation de tâches impliquant l’exploration du projet, la modification de plusieurs fichiers et l’utilisation d’outils.

• Actions intelligentes : génération de messages de commit, correction de diagnostics et autres opérations assistées par IA.

• Sélection de modèles d’IA : accès à plusieurs modèles selon le forfait GitHub Copilot, les politiques du compte et la disponibilité du service.

• Instructions personnalisées : ajout de règles propres au projet afin d’orienter les réponses et modifications de l’assistant.

• Intégration MCP : connexion des agents à des serveurs compatibles avec le Model Context Protocol.

Cas d’usage

Développer une application web

Visual Studio Code propose une bonne prise en charge native de HTML, CSS, JavaScript, TypeScript et JSON. IntelliSense, le débogueur pour navigateurs, le terminal et Git permettent de couvrir une grande partie du cycle de développement web.

Des extensions ajoutent ensuite les outils spécifiques à React, Vue, Angular, Svelte, Astro, Django, Laravel, Node.js ou d’autres frameworks.

L’éditeur peut lancer un serveur local dans le terminal, détecter les erreurs, formater le code et ouvrir une session de débogage dans le navigateur.

Programmer en Python

L’extension Python ajoute la sélection des interpréteurs, l’exécution de scripts, le débogage, les environnements virtuels, les tests et l’intégration avec différents outils d’analyse.

L’extension Pylance complète cet environnement avec des informations de type, une navigation améliorée et des diagnostics plus précis.

VS Code peut ainsi servir aussi bien pour apprendre Python que pour développer une application, une API, un script d’automatisation ou un projet scientifique.

Travailler avec des notebooks et des données

Les extensions Jupyter permettent d’ouvrir des notebooks, d’exécuter les cellules, d’afficher leurs résultats et d’explorer certaines variables.

Cette intégration réunit code classique, notebooks, terminal, Git et documentation dans le même espace de travail.

Elle peut convenir à l’analyse de données, au machine learning, à la recherche, à l’enseignement et au prototypage.

Construire un environnement pour un langage spécifique

L’utilisateur peut transformer VS Code en environnement Rust, Go, Java, C++, C#, PHP, Ruby ou autre en installant les extensions adaptées.

Ces extensions peuvent fournir un serveur de langage, un débogueur, des outils de compilation, un formateur, un linter et une intégration avec le système de tests.

La qualité de l’expérience dépend donc autant de l’extension choisie que de l’éditeur lui-même.

Gérer un projet Git

L’interface de contrôle de version permet de visualiser les fichiers modifiés, examiner les différences, sélectionner les changements à valider et créer un commit.

Elle facilite également la création de branches, la synchronisation avec un dépôt distant et la résolution de conflits.

Les développeurs habitués au terminal peuvent continuer à utiliser les commandes Git classiques dans le terminal intégré tout en bénéficiant des visualisations de VS Code.

Réviser une pull request

Avec l’extension GitHub correspondante, une pull request peut être ouverte, parcourue et commentée depuis l’éditeur.

Il devient possible de consulter les différences dans le contexte du projet, naviguer vers les définitions et exécuter localement la branche proposée.

Cette approche peut être plus confortable que la seule interface web pour examiner une modification complexe.

Développer sur un serveur distant

Remote - SSH permet de conserver VS Code sur son ordinateur tout en travaillant directement avec les fichiers et outils d’un serveur.

Les commandes, compilations, débogueurs et extensions nécessaires au projet sont exécutés sur la machine distante. Le poste local sert principalement d’interface.

Ce fonctionnement est utile pour les serveurs Linux, les machines disposant de GPU, les environnements cloud et les projets trop lourds pour l’ordinateur personnel.

Travailler avec WSL

Sur Windows, l’intégration WSL permet de développer dans un environnement Linux tout en utilisant l’interface graphique de VS Code.

Les fichiers, terminaux, dépendances et outils restent dans la distribution Linux. Cette séparation évite une partie des problèmes de compatibilité entre Windows et les outils pensés pour Unix.

Reproduire un environnement avec Dev Containers

Un fichier devcontainer.json peut décrire l’image, les outils, les extensions et les commandes nécessaires au projet.

Lorsqu’un collaborateur ouvre le dépôt, VS Code peut créer ou réutiliser un conteneur correspondant à cette configuration.

Cette méthode réduit les différences d’environnement entre membres d’une équipe et facilite l’arrivée de nouveaux contributeurs.

Modifier rapidement un dépôt depuis le navigateur

La version Web permet d’ouvrir un dépôt ou des fichiers sans installer l’application desktop.

Elle est adaptée à la lecture, aux corrections légères, à la rédaction de documentation et aux modifications ne nécessitant pas un environnement local complet.

Ses capacités restent plus limitées que celles de la version desktop lorsqu’un projet exige un terminal local, des processus natifs ou certaines extensions.

Rédiger de la documentation technique

Visual Studio Code convient également aux fichiers Markdown, YAML, JSON, XML et autres formats de documentation.

La prévisualisation Markdown, la recherche globale, la vérification orthographique par extension et Git facilitent la rédaction de documentation versionnée avec le code.

Il peut ainsi être utilisé pour des manuels, notes techniques, sites statiques et bases de connaissances.

Apprendre la programmation

L’interface reste plus légère qu’un grand IDE tout en donnant accès aux outils importants : terminal, débogueur, Git et extensions.

Un débutant peut commencer avec une configuration minimale, puis découvrir progressivement les fonctions avancées.

Le nombre de réglages et d’extensions peut toutefois devenir déroutant sans une sélection claire des outils nécessaires.

Développer une extension

L’API de Visual Studio Code permet de créer de nouvelles commandes, vues, éditeurs, thèmes, langages, diagnostics et intégrations.

Une extension peut ensuite être distribuée sous forme de paquet ou publiée sur un registre compatible.

Cette architecture explique en grande partie la diversité de l’écosystème VS Code.

Programmer avec une assistance IA

GitHub Copilot peut expliquer une portion de code, suggérer une implémentation, générer des tests, rechercher une erreur ou modifier plusieurs fichiers.

Le mode agent permet de confier une tâche plus large à l’assistant, qui peut explorer le workspace et utiliser certains outils autorisés.

Ces fonctions peuvent accélérer certaines opérations répétitives, mais les modifications doivent être relues, testées et comprises avant leur intégration.

Construire un environnement personnalisé pour une équipe

Les paramètres du workspace, les recommandations d’extensions, les tâches, les configurations de débogage et les Dev Containers peuvent être enregistrés dans le dépôt.

L’équipe partage ainsi une partie de son environnement sans imposer exactement les mêmes préférences personnelles à chaque membre.

Les Profiles permettent en parallèle de conserver plusieurs configurations adaptées à différents projets.

Avis PANACHES

Visual Studio Code est devenu une référence du développement moderne parce qu’il réussit à se placer entre l’éditeur léger et l’IDE complet. Il peut rester simple pour modifier quelques fichiers, mais aussi accueillir un environnement très élaboré autour d’un projet professionnel.

Sa principale force réside dans son extensibilité. Le même logiciel peut être adapté à presque tous les langages, frameworks et workflows courants. Cette souplesse évite de changer entièrement d’environnement lorsqu’un projet combine plusieurs technologies.

L’interface est également assez cohérente. L’explorateur, la palette de commandes, le terminal, Git, le débogueur et les extensions sont réunis autour du même espace de travail. Une fois les raccourcis assimilés, la plupart des opérations restent accessibles sans multiplier les fenêtres.

L’intégration Git est particulièrement réussie pour les tâches quotidiennes. Elle rend les modifications visibles, facilite les commits et aide à comprendre les différences entre versions. Le terminal reste disponible pour les commandes plus avancées, ce qui évite d’enfermer l’utilisateur dans une interface graphique.

Le développement distant constitue un autre avantage majeur. SSH, WSL, Dev Containers, Tunnels et Codespaces permettent de dissocier l’interface locale de l’environnement qui exécute réellement le projet. Cette architecture convient aussi bien aux serveurs qu’aux conteneurs, aux machines virtuelles et aux infrastructures cloud.

Les Profiles et les paramètres par workspace apportent une bonne réponse à la diversité des projets. Un développeur peut conserver une configuration minimale pour l’écriture, une autre pour Python, une autre pour le Web et une autre pour un environnement distant.

L’intégration croissante de l’intelligence artificielle transforme également VS Code en interface de travail avec des agents de développement. Copilot ne se limite plus à compléter une ligne : il peut participer à l’analyse, à la modification et à la révision de plusieurs fichiers.

Cette évolution peut améliorer la productivité, mais elle rend aussi plus floue la frontière entre l’éditeur gratuit et les services commerciaux qui lui sont associés. VS Code reste gratuit, tandis que l’utilisation intensive de Copilot, de Codespaces ou d’autres services peut nécessiter un abonnement.

L’écosystème d’extensions constitue à la fois une force et une faiblesse. Les milliers d’extensions disponibles permettent de répondre à presque tous les besoins, mais leur qualité, leur maintenance, leurs performances et leur politique de confidentialité varient fortement.

Une installation chargée de nombreuses extensions peut devenir plus lente, consommer davantage de mémoire ou produire des conflits. Il est souvent préférable de conserver un ensemble limité d’extensions réellement utiles et d’utiliser les Profiles pour séparer les contextes.

La distinction entre Visual Studio Code et Code - OSS mérite également d’être clairement expliquée. La majeure partie du code est accessible sous licence MIT, mais la distribution officielle inclut des personnalisations Microsoft et utilise une licence de produit distincte.

Pour les personnes souhaitant éviter la télémétrie Microsoft ou disposer d’une distribution plus strictement open source, VSCodium constitue une alternative logique. Cette solution peut néanmoins perdre l’accès direct à certaines extensions ou intégrations du Marketplace Microsoft.

AlternativeTo met également en avant Sublime Text pour sa rapidité, Zed pour son approche moderne et collaborative, ainsi que des éditeurs comme Vim, Neovim ou Kate pour les utilisateurs recherchant un environnement différent ou plus léger.

Pour PANACHES, Visual Studio Code représente une référence importante pour le module Editor Code. Son système de commandes, ses panneaux, sa palette, son terminal, ses différences Git, ses extensions, ses espaces de travail et son développement distant constituent autant de points de comparaison utiles.

L’objectif de PANACHES ne serait pas nécessairement de reproduire l’intégralité de VS Code, mais d’identifier les fonctions indispensables à un éditeur intégré dans un workspace créatif : navigation claire, coloration, terminal, Git, recherche, aperçu des différences, diagnostics et assistance IA contextualisée.

Visual Studio Code mérite donc une place centrale dans l’annuaire PANACHES. Il reste l’un des environnements les plus polyvalents pour apprendre, programmer, documenter, tester et gérer des projets sans devoir adopter immédiatement un IDE spécialisé plus lourd.

Points d’attention

• Distinguer Visual Studio Code et Code - OSS : le dépôt open source sous licence MIT n’est pas exactement identique à la distribution officielle de Microsoft.

• Ne pas présenter la distribution officielle comme entièrement open source : elle contient des personnalisations, actifs de marque et intégrations soumis à d’autres conditions.

• Examiner la licence Microsoft : les droits associés au logiciel distribué doivent être distingués de ceux du code source Code - OSS.

• Vérifier les licences des extensions : chaque extension peut utiliser sa propre licence, y compris lorsqu’elle est publiée par Microsoft.

• Contrôler la provenance d’une extension : privilégier les éditeurs identifiés, les projets maintenus et les extensions disposant d’une documentation claire.

• Examiner les autorisations et le comportement des extensions : une extension peut lire les fichiers du workspace, exécuter du code ou communiquer avec un service externe.

• Ne pas installer trop d’extensions : leur accumulation peut ralentir le démarrage, augmenter la consommation de mémoire et créer des conflits.

• Désactiver les extensions inutiles par workspace : certaines ne sont nécessaires que pour un langage ou un type de projet précis.

• Utiliser les Profiles : ils permettent de séparer les configurations et de limiter le nombre d’extensions actives simultanément.

• Vérifier la télémétrie : Visual Studio Code collecte certaines données d’utilisation et de diagnostic selon les réglages et politiques appliqués.

• Configurer le niveau de télémétrie : les paramètres permettent de réduire une partie des transmissions, mais les extensions peuvent disposer de leurs propres mécanismes.

• Examiner séparément la confidentialité de Copilot : les prompts, extraits de code et contextes envoyés au service suivent les règles du compte GitHub et du forfait utilisé.

• Désactiver l’utilisation des données pour l’entraînement lorsque nécessaire : les utilisateurs individuels de Copilot doivent contrôler les options associées à leur compte.

• Ne pas transmettre de secrets à un assistant IA : clés, mots de passe, données personnelles et code confidentiel doivent être protégés.

• Relire les modifications produites par l’IA : une suggestion plausible peut contenir une erreur, introduire une vulnérabilité ou ignorer une contrainte du projet.

• Exécuter les tests après les modifications agentiques : un agent peut intervenir sur plusieurs fichiers et produire des conséquences difficiles à repérer visuellement.

• Contrôler les commandes proposées par les agents : le terminal et les outils MCP peuvent exécuter des actions ayant un effet sur les fichiers ou l’environnement.

• Utiliser Workspace Trust avec les projets inconnus : un dépôt peut contenir des tâches, extensions recommandées ou configurations capables d’exécuter du code.

• Examiner les fichiers de configuration avant exécution : tasks.json, launch.json, settings.json et devcontainer.json peuvent déclencher ou configurer des opérations sensibles.

• Sécuriser les terminaux intégrés : ils disposent des mêmes droits que le compte utilisateur et peuvent modifier ou supprimer des fichiers.

• Vérifier les dépendances externes : VS Code ne fournit pas automatiquement tous les compilateurs, interpréteurs, SDK et outils nécessaires aux langages.

• Installer Git séparément : l’interface Git de VS Code utilise l’installation Git présente sur la machine.

• Maintenir les runtimes à jour : Python, Node.js, Java, .NET, Rust et les autres environnements doivent être gérés indépendamment de l’éditeur.

• Tester la version Web avant de l’adopter : vscode.dev est pratique pour les modifications légères, mais reste limité pour les processus natifs, les terminaux locaux et certaines extensions.

• Vérifier la compatibilité Web des extensions : seules les extensions conçues pour l’environnement navigateur peuvent fonctionner entièrement dans vscode.dev.

• Distinguer vscode.dev et Codespaces : le premier est un éditeur Web léger, tandis que le second peut fournir une machine de développement distante facturée séparément.

• Surveiller les coûts des services externes : Copilot, Codespaces, machines cloud et API utilisées par les extensions peuvent avoir leur propre facturation.

• Protéger les connexions SSH : utiliser des clés correctement sécurisées, vérifier l’hôte distant et limiter les droits du compte utilisé.

• Comprendre l’installation de VS Code Server : le développement distant installe et exécute des composants sur la machine distante.

• Vérifier les licences du développement distant : certaines extensions Remote Development et certains composants serveur utilisent une licence propriétaire.

• Contrôler les ports redirigés : un service de développement ne doit pas être exposé publiquement sans authentification ni nécessité.

• Protéger les Dev Containers : une image ou un fichier de configuration provenant d’un dépôt inconnu peut exécuter des commandes pendant sa création.

• Utiliser des images de conteneurs fiables : vérifier leur provenance, leurs mises à jour et les vulnérabilités connues.

• Contrôler Settings Sync : les réglages, profils et extensions synchronisés sont associés au compte utilisé.

• Éviter de stocker des secrets dans les paramètres synchronisés : utiliser des variables d’environnement ou des gestionnaires de secrets adaptés.

• Sauvegarder les configurations importantes : les fichiers du workspace doivent être versionnés lorsque leur partage avec l’équipe est nécessaire.

• Vérifier les mises à jour : une nouvelle version peut modifier une API, un comportement, une extension ou la compatibilité avec un ancien système.

• Distinguer Stable et Insiders : la version Insiders donne accès plus tôt aux nouveautés, mais peut être moins adaptée à un environnement critique.

• Surveiller les performances sur les grands dépôts : l’indexation, les serveurs de langage et les extensions peuvent consommer beaucoup de processeur et de mémoire.

• Exclure les dossiers inutiles : les dépendances générées, caches et répertoires volumineux peuvent être retirés de la recherche et de la surveillance des fichiers.

• Choisir un outil adapté au projet : VS Code est polyvalent, mais un IDE spécialisé peut parfois fournir une analyse plus profonde pour Java, .NET, C++ ou d’autres écosystèmes.

• Comparer avec VSCodium lorsque l’ouverture est prioritaire : cette distribution réduit les composants Microsoft, mais peut présenter des différences de Marketplace et d’extensions.

• Prévoir une configuration reproductible : documenter les extensions, dépendances, tâches et versions nécessaires afin que le projet ne dépende pas uniquement de la machine d’un développeur. :::