# VirtualBox

Une machine virtuelle, ou VM, est un ordinateur simulé par un logiciel : il a son processeur, sa mémoire, son disque et son système, mais tout cela est emprunté à la machine réelle. [VirtualBox](https://www.virtualbox.org) est un logiciel libre qui en crée.

## Le problème

Les cours [SSH](/terminal/ssh), [brew, apt, npm](/terminal/gestionnaires-de-paquets) et [serveur](/reseau/serveur) demandent une machine Linux à administrer. Louer un serveur coûte de l'argent et l'expose à Internet dès la première minute. S'entraîner sur son propre système, c'est risquer de le casser.

Une machine virtuelle donne un serveur Linux jetable, sur son poste : si on le casse, on revient en arrière ou on en recrée un.

## La notion

### Hôte, invité, hyperviseur

<Mermaid
  chart={`flowchart TB
    subgraph hote [Machine hôte, votre ordinateur]
      os[Système hôte<br/>macOS, Windows ou Linux]
      vb[VirtualBox<br/>l'hyperviseur]
      subgraph vm1 [Machine virtuelle 1]
        g1[Ubuntu Server<br/>son propre noyau]
      end
      subgraph vm2 [Machine virtuelle 2]
        g2[Debian<br/>son propre noyau]
      end
      os --> vb
      vb --> vm1
      vb --> vm2
    end`}
/>

| Mot | Sens |
| --- | --- |
| Hôte | La machine réelle |
| Invité | Le système installé dans la machine virtuelle |
| Hyperviseur | Le logiciel qui fait tourner les machines virtuelles |
| Image ISO | Le fichier d'installation d'un système, l'équivalent d'un DVD |
| Instantané | Une photo de l'état de la machine, à laquelle on peut revenir |

La machine virtuelle est isolée de l'hôte. Ce qu'on y installe ou y détruit n'affecte pas le système réel.

### Ce que ça coûte

La mémoire et le disque donnés à la machine virtuelle sont pris à l'hôte tant qu'elle tourne. Un serveur Linux sans interface graphique se contente de peu.

| Ressource | Valeur raisonnable pour ce cours |
| --- | --- |
| Mémoire | 2 Go |
| Processeurs | 2 |
| Disque | 20 Go, occupés au fur et à mesure |

## Installer VirtualBox

| Système | Commande ou méthode |
| --- | --- |
| macOS | `brew install --cask virtualbox` |
| Ubuntu, Debian | `sudo apt install virtualbox` |
| Windows | Installeur à télécharger sur virtualbox.org |

:::warning{title="Processeur de l'hôte et image du système"}

L'invité doit avoir la même architecture de processeur que l'hôte. Sur un Mac à puce Apple, il faut une version récente de VirtualBox et une image **ARM64** du système. Sur un PC ou un Mac Intel, une image **AMD64**. La page de téléchargement de VirtualBox indique les hôtes pris en charge par la version en cours : à vérifier avant le cours.

:::

## Créer un serveur Ubuntu

<Stepper>

1. **Télécharger l'image.** Sur ubuntu.com, la version **Server** en LTS, dans l'architecture de son processeur. La version Server n'a pas d'interface graphique : c'est voulu, un serveur s'administre au terminal.

1. **Créer la machine.** Dans VirtualBox, bouton Nouvelle. Lui donner un nom, choisir l'image ISO, puis régler la mémoire, les processeurs et le disque avec les valeurs du tableau ci-dessus.

1. **Installer le système.** Démarrer la machine et suivre l'installeur. Deux points d'attention : noter le nom d'utilisateur et le mot de passe choisis, et cocher l'installation du **serveur OpenSSH** quand elle est proposée.

1. **Redémarrer et se connecter** dans la fenêtre de la machine, avec le compte créé.

1. **Mettre à jour.**

   ```bash
   sudo apt update
   sudo apt upgrade
   ```

1. **Prendre un instantané**, nommé par exemple « installation propre ». C'est le point de retour pour toute la suite.

</Stepper>

## Le réseau : joindre la machine depuis l'hôte

La fenêtre de VirtualBox est peu pratique : pas de copier-coller, petite police. On veut s'y connecter en SSH depuis son terminal habituel. Cela dépend du mode réseau de la machine.

| Mode | La VM accède à Internet | L'hôte peut joindre la VM | Usage |
| --- | --- | --- | --- |
| NAT, par défaut | Oui | Seulement par redirection de port | Le plus simple, marche partout |
| Accès par pont | Oui | Oui, la VM a sa propre adresse sur le réseau local | Quand d'autres machines doivent la joindre |
| Réseau privé hôte | Non | Oui | Un réseau fermé entre l'hôte et ses VM |

On garde le mode NAT et on ajoute une **redirection de port** : dans les réglages de la machine, partie Réseau, puis Redirection de ports.

| Nom | Protocole | Port hôte | Port invité |
| --- | --- | --- | --- |
| ssh | TCP | 2222 | 22 |
| api | TCP | 8000 | 8000 |

<Mermaid
  chart={`flowchart LR
    subgraph hote [Hôte]
      term[Terminal<br/>ssh -p 2222 alice@127.0.0.1]
      p2222((port 2222))
    end
    subgraph vm [Machine virtuelle]
      p22((port 22))
      sshd[Serveur SSH]
    end
    term --> p2222
    p2222 -- redirection VirtualBox --> p22
    p22 --> sshd`}
/>

Une connexion vers le port 2222 de l'hôte est transmise au port 22 de la machine virtuelle.

```bash
ssh -p 2222 alice@127.0.0.1
```

On remplace `alice` par le compte créé à l'installation. La suite est dans le cours [SSH](/terminal/ssh) : clés, fichier de configuration, copie de fichiers.

## Les instantanés

Un instantané enregistre l'état complet de la machine. On en prend un avant toute manipulation risquée.

<Mermaid
  chart={`flowchart LR
    a[Installation propre] --> b[Python installé]
    b --> c[API déployée]
    c --> d[Essai raté]
    d -. restaurer .-> c`}
/>

C'est ce qui rend la machine virtuelle idéale pour apprendre : on peut casser volontairement, observer, puis revenir.

## Piloter VirtualBox au terminal

Tout ce que fait l'interface se fait aussi avec `VBoxManage`.

| Commande | Effet |
| --- | --- |
| `VBoxManage list vms` | Les machines existantes |
| `VBoxManage list runningvms` | Celles qui tournent |
| `VBoxManage startvm "serveur-jeu" --type headless` | Démarre sans ouvrir de fenêtre |
| `VBoxManage controlvm "serveur-jeu" acpipowerbutton` | Demande un arrêt propre |
| `VBoxManage snapshot "serveur-jeu" take "avant-essai"` | Prend un instantané |

Le mode `headless` correspond à l'usage réel d'un serveur : pas d'écran, tout passe par SSH.

## Machine virtuelle ou conteneur

Les deux isolent un programme de l'hôte. Ils ne répondent pas au même besoin.

| | Machine virtuelle | Conteneur |
| --- | --- | --- |
| Ce qui est isolé | Un ordinateur entier, avec son système | Un programme et ses dépendances |
| Noyau | Le sien | Celui de l'hôte |
| Démarrage | Dizaines de secondes | Moins d'une seconde |
| Taille | Plusieurs Go | Quelques dizaines ou centaines de Mo |
| Bon usage | Apprendre un système, tester une installation complète | Empaqueter et livrer une application |

La suite est dans le cours [Docker](/virtualisation/docker).

## Dans le projet

La machine virtuelle sert de terrain d'essai pour mettre l'[API des scores](/reseau/api) sur un « vrai » serveur, sans rien louer :

<Mermaid
  chart={`flowchart LR
    jeu[Le jeu<br/>sur l'hôte] -- "http://localhost:8000" --> redir((redirection<br/>8000 vers 8000))
    redir --> api[API des scores<br/>dans la VM]`}
/>

1. Installer Python dans la VM avec `apt`.
2. Y copier le dossier `server/` avec `scp`.
3. Lancer l'API avec `--host 0.0.0.0`, sinon elle n'écoute que pour la VM elle-même.
4. La joindre depuis le jeu, resté sur l'hôte.

## À retenir

- Une machine virtuelle est un ordinateur complet, simulé et isolé.
- NAT avec redirection de port suffit pour s'y connecter depuis l'hôte.
- Un instantané avant chaque manipulation risquée.
- Version Server, sans fenêtre, pilotée par SSH : comme un vrai serveur.

## Exercices

1. Créer la machine virtuelle Ubuntu Server et prendre l'instantané « installation propre ».
2. Mettre en place la redirection du port 2222 et se connecter en SSH depuis l'hôte.
3. Dans la VM, installer `python3-venv` et `git` avec `apt`, puis vérifier leurs versions.
4. Copier `server/` dans la VM, lancer l'API, et l'appeler avec `curl` depuis l'hôte. Recommencer sans `--host 0.0.0.0` et expliquer la différence.
5. Supprimer volontairement un dossier système dans la VM, constater les dégâts, restaurer l'instantané.
6. Arrêter la machine, puis la redémarrer en mode `headless` et s'y reconnecter.
