Y a-t-il des avantages à exécuter mon environnement de développement dans un conteneur Docker?

Je développe principalement en utilisant Visual Studio sur Windows. Le problème est qu'après un certain temps, Windows s'enlise et je dois réinstaller Windows. De même, le passage à de nouvelles machines est un problème.

La réinstallation de Windows est pénible car mon environnement de développement a beaucoup de dépendances (telles que des fichiers de configuration MSBuild supplémentaires, des extensions VS, npm, Java, etc.). Je n'imagine pas que je suis seul à avoir un système complexe, et sa mise en place prendrait probablement un jour minimum.

Je n'ai pas vraiment utilisé Docker, mais en théorie, il me semble que je pourrais configurer mon environnement de développement dans un conteneur Windows et ensuite l'envoyer (par exemple, copier sur mon ordinateur portable, installer une nouvelle installation Windows) et cela devrait être indolore .

Ce que je décris est-il possible? Y a-t-il des inconvénients, tels que les performances, la fiabilité? Autres pièges?

Ce n'est pas un problème rare, mais Docker n'est pas vraiment le bon outil pour le résoudre. Les conteneurs en général (y compris Docker) sont destinés à fournir un runtime d'application pour un seul processus , tel qu'un serveur Web, et non pour un scénario multi-processus tel qu'un environnement de développement. Cela peut être fait, mais ce n'est pas une solution très élégante.

Une meilleure approche (et plus courante) consiste à créer des machines virtuelles via un hyperviseur traditionnel tel que VirtualBox ou Hyper-V (puisque vous êtes sous Windows). Un workflow typique est:

• Recherchez ou créez une image de machine virtuelle de base en fonction de votre version de système d'exploitation préférée. Cela peut être fait directement avec l'ISO de l'installateur, ou quelqu'un sur votre lieu de travail peut déjà en avoir un.
• Une fois l'image de base créée, ajoutez tous les outils et paramètres de développement dont vous avez besoin. Prenez un instantané ou enregistrez-le en tant qu'image distincte.
• Vous pouvez maintenant exécuter cette image, RDP ou à distance, et travailler jusqu'à ce que vous arriviez à un point où vous vous «enlisez», puis enregistrez simplement les fichiers dont vous avez besoin (validation du contrôle de source, etc.), puis soufflez loin de l'image et recommencez à partir de l'un des deux instantanés / images que vous avez créés. Cela peut être fait en quelques secondes, contre jusqu'à un jour à l'ancienne.
• À tout moment le long de la ligne, créez des instantanés supplémentaires lorsque vous rencontrez des situations que vous voudrez peut-être restaurer pour reproduire un problème, etc.

Vagrant est également un outil fantastique pour faire une grande partie de ce qui précède de manière plus structurée.

Un avantage secondaire de tout cela est que vous disposez désormais d' environnements standardisés qui peuvent être partagés avec toute votre équipe, ce qui évite à tout le monde les efforts. Ceci est particulièrement utile pour intégrer rapidement de nouvelles personnes.

Revenons à votre question initiale, Docker n'est pas vraiment destiné à cela, mais si vous aviez un environnement de développement suffisamment petit (par exemple PHP sur Linux), vous pourriez le faire dans un conteneur, et l'avantage serait une image beaucoup plus petite (potentiellement moins de 100 Mo contre plusieurs Go pour une machine virtuelle Windows avec disque virtuel).

pas dans un conteneur docker mais oui dans n conteneurs dockers.

Alors que vous pouviez - théoriquement - assembler tout votre environnement de développement dans un seul conteneur, docker n'était pas censé le faire.

Au lieu de cela, vous devez déployer chaque service dans des conteneurs séparés, en utilisant docker compose , en gérant l'ensemble de votre infrastructure dans un seul fichier, où chaque service aura son propre fichier journal, espace utilisateur, réseau, etc.

Permettez-moi de vous donner un exemple, ceci est un brouillon de mon docker-compose.yml

version: '2'
services:

  myproxy:
    build: myproxy
    container_name: ppproxy
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - /var/run/docker.sock:/tmp/docker.sock:ro
    networks:
      default:
        aliases:
          - www.domain1.it
          - www.domain2.it
          - www.domain4.it

  mydb1:
    build: mydb
    environment:
      DB_USER: sdffdssdf
      DB_PASSWORD:  fdsfsdsdf
      DB_NAME: dbanme1
      DB_ENCODING: UTF-8    
      VIRTUAL_HOST: myhost1.net.lan
      VIRTUAL_PORT: 5432

  mydb2:
    build: mydb
    environment:
      DB_USER: ssdfsdfs
      DB_PASSWORD:  sffdssd
      DB_NAME: dbanme2
      DB_ENCODING: UTF-8    
      VIRTUAL_HOST: myhost2.net.lan
      VIRTUAL_PORT: 5432

  www:
    image: myimages/oldservice:v1.1
    container_name: www
    command: /bin/bash /root/launch
    environment:
        VIRTUAL_HOST: www.domain1.it
        VIRTUAL_PORT: 80
    ports:
      - 80
    depends_on:
      - mydb1
      - mydb1
      - myws

  myws:
    build: myjettycontainer
    environment:
        HTTPS_METHOD: noredirect
        VIRTUAL_HOST: www.domain2.it
        VIRTUAL_PORT: 8080
    ports:
      - 8080
    depends_on:
      - mydb1
      - mydb2
      - myproxy
      - mypostfix

  mypostfix:
    image: catatnight/postfix
    container_name: mailer
    environment:
      maildomain: domain1.it
      smtp_user: mymail:sfsfdfds
    ports:
      - 25

Il existe un proxy nginx (myproxy), deux bases de données PostgreSQL similaires (mydb1 et 2), un ancien serveur d'applications Web Java (www), un conteneur de jetée Java qui fournit un service Web de repos et enfin un conteneur de suffixe SMTP très simple.

Tout démarre - généralement :) - avec docker-compose up, soit sur ma machine de développement, soit en production; les fichiers journaux sont regroupés en un seul fichier facile à lire et il est possible de répliquer localement presque toutes les fonctionnalités avec la garantie que, si cela fonctionne sur mon ordinateur portable, cela fonctionnera.

J'utilise des VM VirtualBox pour ce genre de chose.

La portabilité d'avoir votre environnement de développement dans un conteneur est pratique, mais ce qui est vraiment sympa, c'est que je peux prendre un instantané de la chose avant toute tentative de mise à niveau, et si je le gâche, ce n'est pas un problème de se replier et de recommencer.

Je trouve également utile de le faire parce que je travaille fréquemment avec plusieurs versions de choses comme Qt, et je n'ai pas envie de comprendre comment faire cohabiter les deux versions - au lieu de cela, je les mets simplement sur différentes machines virtuelles et Je n'ai pas à me soucier des interactions car j'ai installé quelque chose de manière incorrecte.