Installation des Guest Add-ons pour gestion de l'accélération graphique, du copier-coller entre Windows et la VM
[https://doc.ubuntu-fr.org/virtualbox\_additions\_invite](https://doc.ubuntu-fr.org/virtualbox_additions_invite)
- A priori la nouvelle façon d'installer les add-on c'est simplement installer
[](https://innovation.iha.unistra.fr/uploads/images/gallery/2025-04/SxDimage.png)
- Démarrage d'une session graphique Xorg qui est plus stable que Wayland sous VirtualBox
[](https://innovation.iha.unistra.fr/uploads/images/gallery/2025-04/I6Fimage.png)
- Désactiver l'accélération graphique qui n'est pas bien supportée sous Ubuntu 24.04 avec VirtualBox 7.1.7
[https://www.virtualbox.org/ticket/21955](https://www.virtualbox.org/ticket/21955)
[https://forums.virtualbox.org/viewtopic.php?t=111676](https://forums.virtualbox.org/viewtopic.php?t=111676)
Même passer au kernel 6.3 qui semblait non problématique n'a pas réglé le soucis
[](https://innovation.iha.unistra.fr/uploads/images/gallery/2025-04/Wviimage.png)
Astuce en cas de soucis suite à màj VirtualBox : [https://forums.virtualbox.org/viewtopic.php?t=12692](https://forums.virtualbox.org/viewtopic.php?t=12692)
- Supprimer les Extensions Pack
- Désinstaller
- Réinstaller
# Sources
- [Installation de MoveIt2 Humble sur Ubuntu 22.04](https://moveit.picknik.ai/humble/doc/tutorials/getting_started/getting_started.html)
- [Tutoriels débutant](https://docs.ros.org/en/rolling/Tutorials/Beginner-CLI-Tools.html)
-----
Auteur: Gauthier Hentz, sur le [wiki de l'innovation de l'IUT de Haguenau](https://innovation.iha.unistra.fr/books/robotique-open-source)
[ Attribution-NonCommercial-PartageMemeConditions 4.0 International (CC BY-NC-SA 4.0) ](https://creativecommons.org/licenses/by-nc-sa/4.0/deed.fr)
# Tutoriels de base
Pour comprendre les concepts de ROS2 par la pratique, il existe des tutoriels pour débutant. Ils reposent sur la simulation d'un robot mobile à deux roues principales développé par les développeurs de ROS en 2010 : [Turtlebot](https://fr.wikipedia.org/wiki/TurtleBot). Le [TurtleBot 3 est vendue par Robotis](https://emanual.robotis.com/docs/en/platform/turtlebot3/overview/) et peut être [couplé à un bras manipulateur 5 axes OpenMANIPULATOR-X](https://emanual.robotis.com/docs/en/platform/turtlebot3/manipulation/#manipulation). Il est possible de [simuler des applications de manipulation mobile avec Gazebo](https://emanual.robotis.com/docs/en/platform/turtlebot3/manipulation/#simulation).
Pour réaliser les tutoriels de base, il nous faut un environnement de développement, deux options :
- Une machine virtuelle (VM) [VirtualBox](https://innovation.iha.unistra.fr/books/robotique-open-source/page/installation-pc-ros2#bkmrk-ubuntu-via-virtualbo), ou disponible au téléchargement ici
- Le plus simple et rapide pour démarrer
- Si on n'a pas de Hardware ou qu'on ne souhaite travailler qu'en simulation
- Une installation simple ou dual-boot sur un PC
- Il faut alors installer de zéro
- Indispensable si on veut travailler avec du Hardware
Supposons que vous avez [installé et testé votre environnement comme celui de la VM](https://innovation.iha.unistra.fr/books/robotique-open-source/page/installation-pc-ros2#bkmrk-installation-de-ros2).
Connexion à la VM
- nom : ubuntu22ros2
- utilisateur : `etudiant`
- mdp : département de l'IUT
Nous pouvons directement passer aux tutoriels sur les outils ROS 2 en ligne de commande :
- [Configuring environment](https://docs.ros.org/en/humble/Tutorials/Beginner-CLI-Tools/Configuring-ROS2-Environment.html)
- [Using `turtlesim`, `ros2`, and `rqt`](https://docs.ros.org/en/humble/Tutorials/Beginner-CLI-Tools/Introducing-Turtlesim/Introducing-Turtlesim.html)
- [Understanding nodes](https://docs.ros.org/en/humble/Tutorials/Beginner-CLI-Tools/Understanding-ROS2-Nodes/Understanding-ROS2-Nodes.html)
- [Understanding topics](https://docs.ros.org/en/humble/Tutorials/Beginner-CLI-Tools/Understanding-ROS2-Topics/Understanding-ROS2-Topics.html)
- [Understanding services](https://docs.ros.org/en/humble/Tutorials/Beginner-CLI-Tools/Understanding-ROS2-Services/Understanding-ROS2-Services.html)
- [Understanding parameters](https://docs.ros.org/en/humble/Tutorials/Beginner-CLI-Tools/Understanding-ROS2-Parameters/Understanding-ROS2-Parameters.html)
- [Using `colcon` to build packages](https://docs.ros.org/en/humble/Tutorials/Beginner-Client-Libraries/Colcon-Tutorial.html)
- [Creating a workspace](https://docs.ros.org/en/humble/Tutorials/Beginner-Client-Libraries/Creating-A-Workspace/Creating-A-Workspace.html)
- [Creating a package](https://docs.ros.org/en/humble/Tutorials/Beginner-Client-Libraries/Creating-Your-First-ROS2-Package.html)
- [Writing a simple publisher and subscriber (C++)](https://docs.ros.org/en/humble/Tutorials/Beginner-Client-Libraries/Writing-A-Simple-Cpp-Publisher-And-Subscriber.html) --> Correction
- [Writing a simple publisher and subscriber (Python)](https://docs.ros.org/en/humble/Tutorials/Beginner-Client-Libraries/Writing-A-Simple-Py-Publisher-And-Subscriber.html)
- [Writing a simple service and client (C++)](https://docs.ros.org/en/humble/Tutorials/Beginner-Client-Libraries/Writing-A-Simple-Cpp-Service-And-Client.html)
- [Writing a simple service and client (Python)](https://docs.ros.org/en/humble/Tutorials/Beginner-Client-Libraries/Writing-A-Simple-Py-Service-And-Client.html)
- [Creating custom msg and srv files](https://docs.ros.org/en/humble/Tutorials/Beginner-Client-Libraries/Custom-ROS2-Interfaces.html)
1. The gear icon on the top right of the screen brings up a menu which allows the user to log out, shut down the computer, access system settings, etc…
2. The bar on the left side shows running and “favorite” applications, connected thumb drives, etc.
3. The top icon is used to access all applications and files. We will look at this in more detail later.
4. The next icons are either applications which are currently running or have been “pinned” (again, more on pinning later)
5. Any removable drives, like thumb drives, are found after the application icons.
6. If the launcher bar gets “too full”, clicking and dragging up/down allows you to see the applications that are hidden.
7. To reorganize the icons on the launcher, click and hold the icon until it “pops out”, then move it to the desired location.
1. The close, minimize, and maximize buttons typically found on the right-hand side of the window title bar are found on the left-hand side.
2. The menu for windows are found on the menu bar at the top of the screen, much in the same way Macs do. The menus, however, only show up when you hover the mouse over the menu bar.
3. Notice that there are menu highlights of the folder icon. The dots on the left show how many windows of this application are open. Clicking on these icons when the applications are open does one of two things:
- If there is only one window open, this window gets focus.
- If more than one are open, clicking a second time causes all of the windows to show up in the foreground, so that you can choose which window to go to (see below):
1. Right-click on the text editor launch icon, and select “Lock to Launcher”.
2. Close the gedit window. The launcher icon should remain after the window closes.
3. Click on the gedit launcher icon. You should see a new gedit window appear.
1. Pour ouvrir le Terminal, recherchez le programme "terminator" ou cliquez sur l'icône:
[](https://innovation.iha.unistra.fr/uploads/images/gallery/2023-09/63008829.png)
2. Create a second terminal window, either by:
- Right-clicking on the terminal and selecting the “Open Terminal” or
- Selecting “Open Terminal” from the “File” menu
3. Create a second terminal within the same window by pressing “Ctrl+Shift+T” while the terminal window is selected.
4. Close the 2nd terminal tab, either by:
- clicking the small ‘x’ in the terminal tab (not the main terminal window)
- typing `exit` and hitting enter.
5. The window will have a single line, which looks like this:
`ros-industrial@ros-i-humble-vm:~$`
6. This is called the prompt, where you enter commands. The prompt, by default, provides three pieces of information:
1. *ros-industrial* is the login name of the user you are running as.
2. *ros-i-humble-vm* is the host name of the computer.
3. ~ is the directory in which the terminal is currently in. (More on this later).
7. Close the terminal window by typing `exit` or clicking on the red ‘x’ in the window’s titlebar.
### Navigating Directories and Listing Files
#### Prepare your environment
1. Open your home folder in the file browser.
2. Double-click on the `ex0.3` folder we created in the previous step.
- *We’ll use this to illustrate various file operations in the terminal.*
3. Right click in the main file-browser window and select “Open in Terminal” to create a terminal window at that location.
4. In the terminal window, type the following command to create some sample files that we can study later:
- `cp -a ~/industrial_training/exercises/0.3/. .`
1. Enter `ls` into the terminal.
- You should see `test.txt`, and `new` listed. (If you don’t see ‘new’, go back and complete the [previous exercise](https://industrial-training-master.readthedocs.io/en/humble/_source/prerequisites/Exploring-the-Linux-File-System.html)).
- Directories, like `new`, are colored in blue.
- The file `sample_job` is in green; this indicates it has its “execute” bit set, which means it can be executed as a command.
2. Type `ls *.txt`. Only the file `test.txt` will be displayed.
3. Enter `ls -l` into the terminal.
- Adding the `-l` option shows one entry per line, with additional information about each entry in the directory.
- The first 10 characters indicate the file type and permissions
- The first character is `d` if the entry is a directory.
- The next 9 characters are the permissions bits for the file
- The third and fourth fields are the owning user and group, respectively.
- The second-to-last field is the time the file was last modified.
- If the file is a symbolic link, the link’s target file is listed after the link’s file name.
4. Enter `ls -a` in the terminal.
- You will now see one additional file, which is hidden.
5. Enter `ls -a -l` (or `ls -al`) in the command.
- You’ll now see that the file `hidden_link.txt` points to `.hidden_text_file.txt`.
1. Enter `pwd` into the terminal.
- This will show you the full path of the directory you are working in.
2. Enter `cd new` into the terminal.
- The prompt should change to `ros-industrial@ros-i-humble-vm:~/ex0.3/new$`.
- Typing `pwd` will show you now in the directory `/home/ros-industrial/ex0.3/new`.
3. Enter `cd ..` into the terminal. \* In the [previous exercise](https://industrial-training-master.readthedocs.io/en/humble/_source/prerequisites/Exploring-the-Linux-File-System.html), we noted that `..` is the parent folder. \* The prompt should therefore indicate that the current working directory is `/home/ros-industrial/ex0.3`.
4. Enter `cd /bin`, followed by `ls`.
- This folder contains a list of the most basic Linux commands.
*Note that `pwd` and `ls` are both in this folder.*
5. Enter `cd ~/ex0.3` to return to our working directory.
- Linux uses the `~` character as a shorthand representation for your home directory.
- It’s a convenient way to reference files and paths in command-line commands.
- You’ll be typing it a lot in this class… remember it!
1. Type `mv test.txt test2.txt`, followed by `ls`.
- You will notice that the file has been renamed to `test2.txt`.
*This step shows how `mv` can rename files.*
2. Type `mv test2.txt new`, then `ls`.
- The file will no longer be present in the folder.
3. Type `cd new`, then `ls`.
- You will see `test2.txt` in the folder.
*These steps show how `mv` can move files.*
4. Type `mv test2.txt ../test.txt`, then `ls`.
- `test2.txt` will no longer be there.
5. Type `cd ..`, then `ls`.
- You will notice that `test.txt` is present again.
*This shows how `mv` can move and rename files in one step.*
1. Type `cp test.txt new/test2.txt`, then `ls new`.
- You will see `test2.txt` is now in the `new` folder.
2. Type `cp test.txt "test copy.txt"`, then `ls -l`.
- You will see that `test.txt` has been copied to `test copy.txt`.
*Note that the quotation marks are necessary when spaces or other special characters are included in the file name.*
1. Type `rm "test copy.txt"`, then `ls -l`.
- You will notice that `test copy.txt` is no longer there.
1. Type `mkdir new2`, then `ls`.
- You will see there is a new folder `new2`.
1. Type `touch ~/Templates/"Untitled Document"`.
- This will create a new Document named **“Untitled Document”**
1. Type `gedit test.txt`.
- You will notice that a new text editor window will open, and `test.txt` will be loaded.
- The terminal will not come back with a prompt until the window is closed.
2. There are two ways around this limitation. Try both…
3. **Starting the program and immediately returning a prompt:**
1. Type `gedit test.txt &`.
- The `&` character tells the terminal to run this command in “the background”, meaning the prompt will return immediately.
2. Close the window, then type `ls`.
- In addition to showing the files, the terminal will notify you that `gedit` has finished.
4. **Moving an already running program into the background:**
1. Type `gedit test.txt`.
- The window should open, and the terminal should not have a prompt waiting.
2. In the terminal window, press Ctrl+Z.
- The terminal will indicate that `gedit` has stopped, and a prompt will appear.
3. Try to use the `gedit` window.
- Because it is paused, the window will not run.
4. Type `bg` in the terminal.
- The `gedit` window can now run.
5. Close the `gedit` window, and type `ls` in the terminal window.
- As before, the terminal window will indicate that `gedit` is finished.
1. In a terminal, type `ls -a /root`.
- The terminal will indicate that you cannot read the folder `/root`.
- Many times you will need to run a command that cannot be done as an ordinary user, and must be done as the “super user”
2. To run the previous command as root, add `sudo` to the beginning of the command.
- In this instance, type `sudo ls -a /root` instead.
- The terminal will request your password (in this case, `rosindustrial`) in order to proceed.
- Once you enter the password, you should see the contents of the `/root` directory.
1. Type `./sample_job`.
- The program will start running.
2. Press Control+C.
- The program should exit.
3. Type `./sample_job sigterm`.
- The program will start running.
4. Press Control+C.
- This time the program will not die.
1. Open a new terminal window.
2. Type `ps ax`.
3. Scroll up until you find `python ./sample_job sigterm`.
- This is the job that is running in the first window.
- The first field in the table is the ID of the process (use `man ps` to learn more about the other fields).
4. Type `ps ax | grep sample`.
- You will notice that only a few lines are returned.
- This is useful if you want to find a particular process
- *Note: this is an advanced technique called “piping”, where the output of one program is passed into the input of the next. This is beyond the scope of this class, but is useful to learn if you intend to use the terminal extensively.*
5. Type `kill `, where `` is the job number you found with the `ps ax`.
6. In the first window, type `./sample_job sigterm sigkill`.
- The program will start running.
7. In the second window, type `ps ax | grep sample` to get the id of the process.
8. Type `kill `.
- This time, the process will not die.
9. Type `kill -SIGKILL `.
- This time the process will exit.
1. In a terminal, type `top`.
- A table will be shown, updated once per second, showing all of the processes on the system, as well as the overall CPU and memory usage.
2. Press the Shift+P key.
- This will sort processes by CPU utilization.
*This can be used to determine which processes are using too much CPU time.*
3. Press the Shift+M key.
- This will sort processes by memory utilization
*This can be used to determine which processes are using too much memory.*
4. Press q or Ctrl+C to exit the program.
Ajouter votre user au groupe docker, ATTENTION ça lui donne les droits admin
`sudo usermod -aG docker $USER`
- Installer git
`sudo apt install git`
#### Développement local sur Windows avec X11 forwarding
- Vérifier les prérequis à WSL2 de votre Windows
- Installer Docker Desktop
- Vérifier que Docker est configuré et fonctionne avec WSL2
- Installer une distribution Linux via WSL2, par exemple Ubuntu 24 depuis le Microsoft Store
- Lancer un Terminal Ubuntu sur WSL2 (taper `ubuntu` depuis le menu démarrer)
- Installer git
`sudo apt install git`
#### Développement sur serveur distant
- Installer une distribution Linux Server, par exemple Yunohost 12
- [Installer Docker en mode rootless](https://docs.docker.com/engine/security/rootless/)
- Créer un utilisateur YunoHost, lui donner un accès ssh et les droits appropriés (ne pas l'ajouter au groupe admin YunoHost)
- NE PAS ajouter votre user au groupe docker, car ça lui donnerait des droits admin
`sudo usermod -aG docker $USER`
- Lancer les commandes `docker` avec `sudo`
### Avec PWA
Ici, on suppose qu'on ne fait pas tourner d'algorithmes qui ont besoin de GPU, type Machine Learning, dans le conteneur.
Une première approche est de séparer la partie calcul CPU de la partie graphique GPU. On fait tourner les calculs dans le conteneur. On fait tourner les applications graphiques dans le navigateur Web de l'hôte via une PWA, par exemple via `gzweb` pour gazebo. Il nous faut alors un navigateur qui supporte l'accélération graphique des applications Web, seuls Chrome et dérivés supportent le WebGL :
- Installer Chrome sur Windows ou [Chromium sur Linux, de préférence depuis le PPA](https://doc.ubuntu-fr.org/chromium-browser#version_stable)
- Vérifier que WebGL est activé en vérifiant que le cube tourne sur [https://get.webgl.org/](https://get.webgl.org/)
L'énorme avantage est que l'environnement de développement Docker n'a pas besoin d'accélération graphique. Pas besoin de perdre du temps à essayer de passer la carte graphique au conteneur. Un serveur sans accélération graphique suffit.
[https://discourse.ros.org/t/mini-workshop-developing-and-teaching-ros-from-a-web-browser-using-dev-containers-and-pwas/31533](https://discourse.ros.org/t/mini-workshop-developing-and-teaching-ros-from-a-web-browser-using-dev-containers-and-pwas/31533)
[https://github.com/rplayground/sandbox](https://github.com/rplayground/sandbox)
```bash
source /opt/ros/$ROS_DISTRO/setup.bash
source /usr/share/gazebo/setup.sh
GAZEBO_MODEL_PATH=$GAZEBO_MODEL_PATH:$(find /opt/ros/$ROS_DISTRO/share \
-mindepth 1 -maxdepth 2 -type d -name "models" | paste -s -d: -)
ros2 launch ./launch/security_demo_launch.py \
use_rviz:=False headless:=True
```
#### Pour un développement local
- Installer Visual Studio Code, [sur Linux depuis Snap ou le PPA Microsoft](https://doc.ubuntu-fr.org/visual_studio_code#installation_vscode) Noter que Codium sur Linux ne supporte par l'extension Dev Container nécessaire
- Désactiver la collecte des données : `Settings > Telemetry > Telemetry Level > off`
- Installer Docker avec le support de l'accélération graphique, cf. ci-dessus
- Installer l'extension `Dev Container`. Noter que les extensions nécessaires au développement de ROS seront installées dans le VSCode-Server du container
- Sur Windows : Lancer un Terminal Ubuntu sur WSL2 (taper ubuntu depuis le menu démarrer)
- Sur Linux : Lancer un Terminal
- Cloner le dépôt du Dev Container
`git clone https://github.com/rplayground/sandbox`
- Se placer dans le dossier
`cd ~/sandbox`
- Ouvrir le dossier dans Visual Studio Code
`code .`
- Lancer `Dev Container: Reopen in Container`
#### Pour un développement distant sur un serveur/PC
- Installer le pack d'extensions `Remote Development`
- Se connecter à la machine de développement distante depuis Visual Studio Code
- Ouvrir la Command Palette `Ctrl+Shift+P`
- Lancer `Remote-SSH: Connect to host...`
- Configurer la connexion ssh par mot-de-passe ou clé si ce n'a pas encore été fait
- Cloner le dépôt [https://github.com/rplayground/sandbox](https://github.com/rplayground/sandbox)
- Ouvrir le dossier sandbox
- Lancer `Dev Container: Reopen in Container`
#### Tester l'installation
- Le dépôt [https://github.com/rplayground/sandbox?tab=readme-ov-file#demo](https://github.com/rplayground/sandbox?tab=readme-ov-file#demo) fournit un environnement préconfiguré avec
- Les paquets Nav2
- Les paquets turtlebot3\_simulations
- Le serveur Gazebo et le client web gzweb
- Des utilitaires pour le démarrage des interfaces graphiques dans le navigateur
- Ouvrir un nouveau Terminal dans VisualStudio Code
- Configurer le Bash et lancer la démo de sécurité :
```
source /opt/ros/$ROS_DISTRO/setup.bash
source /usr/share/gazebo/setup.sh
GAZEBO_MODEL_PATH=$GAZEBO_MODEL_PATH:$(find /opt/ros/$ROS_DISTRO/share \
-mindepth 1 -maxdepth 2 -type d -name "models" | paste -s -d: -)
ros2 launch ./launch/security_demo_launch.py \
use_rviz:=False headless:=True
```
- Depuis la palette de commandes `F1` , taper `Tasks: Run Task` et sélectionner `Start Visualizations`
- Depuis le panneau des Ports, cliquer `Open in Browser` pour le port `8080` et ouvrir le lien dans Chrome/Chromium
Il est possible de lancer d'autres environnements de simulation, par ex. turtlebot3\_simulations :
- On choisi le modèle de turtlebot3 et on lance gazebo en mode headless ```bash
export ROS_DOMAIN_ID=30 #TURTLEBOT3
export LDS_MODEL=LDS-01
export TURTLEBOT3_MODEL=burger
ros2 launch turtlebot3_gazebo turtlebot3_world.launch.py \
use_rviz:=False headless:=True
```
#### Comprendre les spécificités du container sandbox
- On remarque qu'on est connecté en `root` et que la sandbox est installée dans un workspace d'overlay
`root@iha-portrob-1:/opt/overlay_ws/src/sandbox#`
- Le fichier de configuration du bash `cat /root/.bashrc` n'a pas été modifié pour sourcer les exécutables ros
- La distribution ROS installée est
`echo $ROS_DISTRO `
`humble`
- A chaque réinitialisation du container et ouverture de nouveau Terminal il faut donc lancer :
```
source /opt/ros/$ROS_DISTRO/setup.bash
source /usr/share/gazebo/setup.sh
GAZEBO_MODEL_PATH=$GAZEBO_MODEL_PATH:$(find /opt/ros/$ROS_DISTRO/share \
-mindepth 1 -maxdepth 2 -type d -name "models" | paste -s -d: -)
```
- Que nous dit `devcontainer.json`
```
{
"name": "Sandbox",
"image": "ghcr.io/rplayground/sandbox:main",
// "build": {
// "dockerfile": "../Dockerfile",
// "context": "..",
// "target": "visualizer",
// "cacheFrom": "ghcr.io/rplayground/sandbox:main"
// },
"runArgs": [
// "--cap-add=SYS_PTRACE", // enable debugging, e.g. gdb
// "--ipc=host", // shared memory transport with host, e.g. rviz GUIs
// "--network=host", // network access to host interfaces, e.g. eth0
// "--pid=host", // DDS discovery with host, without --network=host
// "--privileged", // device access to host peripherals, e.g. USB
// "--security-opt=seccomp=unconfined", // enable debugging, e.g. gdb
],
"workspaceFolder": "/opt/overlay_ws/src/sandbox",
"workspaceMount": "source=${localWorkspaceFolder},target=${containerWorkspaceFolder},type=bind",
"onCreateCommand": ".devcontainer/on-create-command.sh",
"updateContentCommand": ".devcontainer/update-content-command.sh",
"postCreateCommand": ".devcontainer/post-create-command.sh",
"customizations": {
"codespaces": {
"openFiles": [
"README.md"
]
},
"vscode": {
"settings": {},
"extensions": [
"eamodio.gitlens",
"GitHub.copilot",
"ms-iot.vscode-ros",
"streetsidesoftware.code-spell-checker"
]
}
}
}
```
- Que nous dit `Dockerfile`
### Installation de Docker avec accélération graphique
Ici, on peut faire tourner dans le conteneur des algorithmes qui ont besoin de GPU, type Machine Learning.
#### AMD/Intel sous Linux
#### NVidia Sous Linux
- [Installer le Driver propriétaire NVidia ](https://doc.ubuntu-fr.org/nvidia#via_les_depots_ubuntu)(si les driver proprio n'ont pas été autorisés à l'installation d'Ubuntu)
- `sudo apt install curl`
- [Installer le Nvidia Container Toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html#with-apt-ubuntu-debian)
```
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
&& curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list && \
sudo apt-get update && sudo apt-get install nvidia-container-toolkit
```
- Redémarrer le PC
- Lancer docker avec l'argument `--gpus=all` pour tester qu'il a bien accès au GPU
`docker run --rm -it --gpus=all nvcr.io/nvidia/k8s/cuda-sample:nbody nbody -gpu -benchmark`
- Le résultat suivant indique que la carte graphique dédiée `Nvidia Quadro P620` est bien exploitée pour les calculs :
```
> Windowed mode
> Simulation data stored in video memory
> Single precision floating point simulation
> 1 Devices used for simulation
GPU Device 0: "Pascal" with compute capability 6.1
> Compute 6.1 CUDA device: [Quadro P620]
4096 bodies, total time for 10 iterations: 4.417 ms
= 37.987 billion interactions per second
= 759.750 single-precision GFLOP/s at 20 flops per interaction
```
- Si ça ne s'affiche pas : [https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html#configuring-docker](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html#configuring-docker)
#### NVidia Sous Linux Public Server (rootless docker)
[https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html#rootless-mode](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html#rootless-mode)
#### NVidia Sous Windows
[https://innovation.iha.unistra.fr/books/robotique-open-source/page/installation-pc-ros2#bkmrk-acc%C3%A9l%C3%A9ration-gpu-pou](https://innovation.iha.unistra.fr/books/robotique-open-source/page/installation-pc-ros2#bkmrk-acc%C3%A9l%C3%A9ration-gpu-pou)
#### Lancement Dev Container avec accélération graphique
- Ajouter dans `.devcontainer/devcontainer.json`
```
{
"name": "Sandbox",
"hostRequirements": {
"gpu": "optional" // switch on CPU if no (NVidia?) GPU available
},
"runArgs": [
"--gpus=all" // enable NVidia GPU with NVidia driver
// "--device=/dev/dri" // enable Intel/AMD GPU
}
```
### Avec X11 Forwarding
On peut aussi afficher les fenêtres graphiques des applications qui tournent dans le Container directement sur l'hôte, par ex. `gazebo-client`
Pour cela il faut :
- Installer dans le conteneur le gestionnaire de fenêtres x11-apps (partie serveur)
- Avoir accès à un gestionnaire de fenêtres X11 sur l'hôte (partie client)
- Configurer correctement l'hôte et le Dev Container pour que le conteneur ait accès au client X11
- Cela peut poser des problèmes de sécurité car le conteneur risque d'avoir accès à tout ce qu'il se passe sur l'écran de l'hôte
On ne peut plus se contenter d'une distribution Linux Serveur type YunoHost pour le développement distant
Les calculs graphiques se font alors dans le container ??
### Avec VNC
### Ressources
[https://articulatedrobotics.xyz/tutorials/docker/dev-containers/](https://articulatedrobotics.xyz/tutorials/docker/dev-containers/)
Nav2, container, PWA [https://discourse.ros.org/t/repeatable-reproducible-and-now-accessible-ros-development-via-dev-containers/31398](https://discourse.ros.org/t/repeatable-reproducible-and-now-accessible-ros-development-via-dev-containers/31398) [https://github.com/ros-navigation/docs.nav2.org/blob/master/development\_guides/devcontainer\_docs/devcontainer\_guide.md](https://github.com/ros-navigation/docs.nav2.org/blob/master/development_guides/devcontainer_docs/devcontainer_guide.md)