source debian standard.

"> source debian standard.

" />

Création d'une image Debian stable (ou testing ou oldstable) pour Raspberry Pi arm64 pour le codage et la gestion des bus d'interfaces physiques sur les bus GPIO, SPI, i2C.

Par : @Gérard Vidal dans [ RaspberriesPi ]
Le : mer. 18 mars 2026 révisé le : lun. 23 mars 2026
Tags : #RaspberryPi-64bit, #codage, #air-quality, #trixie,
Linkedin Mail

Résumé :

Construire une image debian trixie (stable) ou debian forky (testing) standard pour une Raspberry Pi avec un processeur arm64 (Pi3 4 5). les images sont construites pour êtres directement utilisables dans un univers scolaire (collège) pour gérer les données météorologiques d'une station de mesure, apprendre ou enseigner le codage avec les outils SNAP!BYOB (analogue à scratch) et jupyter pour aborder python et javascript. L'image est construite à partir de la source debian standard.

Motivations

Le but de cet article est de décrire la procédure technique permettant d'enrichir un système d'exploitation Debian "orthodoxe" (analogue à celui qui est installé sur un ordinateur ordinaire) et qui fonctionne sur une Raspberry Pi ARM-64. La motivation principale est de disposer d'une distribution standard augmentée de tous les logiciels nécessaires pour piloter le GPIO de la RaspberryPi, apprendre à coder en python ou C++ à l'aide d'une interface web jupyterou jupyterlab.

La seconde motivation est de proposer une explication de TOUT ce qui est fait pour enrichir le système à partir de l'image de base en évitant les commandes parfois perçues comme "magiques".

  • Remerciements

Éric le Jan et Charles-Henri Eyraud.

  • Téléchargement

source debian standard pour raspberryPi ARM64

Table des matières

Lors du développement du projet "Météo et Climat tremplin pour l'enseignement des sciences et dès que l'utilisation d'objets connectés (RaspberryPi, Odroïd, Intel edison, Intel joule) a été entérinée, des images ont été construites au coup par coup pour soutenir les fonctions attribuées à chacun des objets connectés. Cet article présente l'enrichissement de l'image standard debian pour raspberryPi ARM-64 afin de la rendre aisément opérationnelle avec les adaptations particulières pour le projet "Tremplin des Sciences".

La procédure décrite ci-dessous a été réalisée à partir d'une machine linux Debian, si on ne dispose pas d'un tel ordinateur il est possible de réaliser ce travail à partir d'une distribution "live" sur une clef USB qui s'installe sur tout ordinateur sans toucher au système d'exploitation et aux données existantes. Pour conserver l'état du système ainsi créé on peut utiliser une distribution "persistante" voir Créer et utiliser une clef USB GNU/linux bootable persistante pour configurer une raspberry Pi.

L'utilisateur privilégié initial s'appelle ens-ife dans les fichiers de configuration et on fournit une clef ssh pour éviter l'utilisation de mots de passe (un mot de passe de secours est toutefois prévu dans la configuration). L'utilisateur privilégié ens-ife est réservé aux responsables du projet, un autre utilisateur privilégié localadmest créé pour fournir à un tiers responsable local de l'image les droits d'administration.

1. Téléchargement de l'image et création de la micro-SD

L'équipe cloud.debian.org fournit des images debian pour un grand nombre de plateformes, y compris les raspberriesPi basées sur un processeur ARM-64. Plusieurs versions sont disponibles on choisira ici trixie.

Le téléchargement de l'image du jour : debian-13-generic-arm64-daily-20260318-2420.tar.xz fournir la dernière image créée.

L'image est décompressée tar xvfJ debian-13-raspi-arm64-daily.tar.xz et fournit une image brute disk.raw qui peut être directement transférée sur la carte SD. Dans l'exemple ci-dessous la carte SD est sur /dev/sdh.

sudo dd if=disk.raw of=/dev/sde bs=16M
sudo fdisk /dev/sde

1.1 Modification de la taille de la partition

L'image dispose d'une table de partitions GPT hybride on utilise fdisk pour modifier la taille de la partition principale

sudo fdisk /dev/sde
  • taper e
  • partition 1
  • taper la taille choisie ici 24G pour ménager un espace libre au cas ou l'image serait copiée sur une carte plus petite que celle utilisée actuellement pour la construire
  • taper w
  • puis sudo resize2fs /dev/sde1
# Trace de l'exécution :

Commande (m pour l'aide) : e
Numéro de partition (1,15, 15 par défaut) : 1
Nouvelle <taille>{K,M,G,T,P} en octets ou <taille>S en secteurs (29,2G par défaut): 24G
La partition 1 a été redimensionnée.
Commande (m pour l'aide) : w
Le périphérique contient un secteur d’amorçage hybride — écriture de GPT seulement.
La table de partitions a été altérée.
Appel d'ioctl() pour relire la table de partitions.
Synchronisation des disques.

sudo resize2fs /dev/sde1
resize2fs 1.47.4 (6-Mar-2025)
Resizing the filesystem on /dev/sde1 to 6291456 (4k) blocks.
The filesystem on /dev/sde1 is now 6291456 (4k) blocks long.

1.2 Modification de l'adresse filaire

Par défaut cette image installe l'ancienne version de nommage des interfaces réseau (eth0 pour le filaire). Pour une modification immédiate il suffit de modifier la ligne de commande du fichier /boot/firmware/cmdline.txt et lui donner la valeur ci-dessous. Toutefois pour que cette valeur n'est pas prise par défaut et il faut refaire la modification après un update-upgrade.

console=tty0 console=ttyS1,115200 root=PARTUUID=c236ba2e-d90d-47bb-ad8a-428f466557c9 rw fsck.repair=yes cma=64M rootwait

L'option net.ifnames=0 a été supprimée.

2. Premier démarrage

Insérer la SD dans la raspberryPi connectée au réseau filaire, à un écran et un clavier. Au démarrage la raspberryPi demande de choisir la "timezone" taper 465 pour Europe/Paris, puis choisir un mot de passe. Attention par défaut le clavier est anglais (QWERTY), par précaution utiliser des lettres identiques entre clavier français et anglais pour le mot de passe.

Il est alors possible de se connecter en tant qu'administrateur

2.1 Premières configurations

Vérifier que tous les paquets sont à jour puis installer les paquets permettant de passer en clavier français et dans la locale française.

apt update
apt install locales keyboard-configuration console-setup
dpkg-reconfigure locales

Choisir le nom de la raspberry, pour le projet ce sera rpitremplin

sudo jed /etc/hostname
# add rpitremplin
sudo jed /etc/hosts
cat /etc/hosts
127.0.0.1       rpitremplin
::1             rpitremplin ip6-localhost ip6-loopback
ff02::1         ip6-allnodes
ff02::2         ip6-allrouters

La raspberry est maintenant en français avec un clavier français, on peut entâmer la configuration de base.

2.2 configuration de base

Ajout de l'utilisateur d'administration du projet et promotion des droits puis installation du serveur et du client ssh.

adduser ens-ife
adduser ens-ife sudo
apt install openssh-server openssh-client

Il est maintenant possible de se connecter depuis une autre machine en ssh pour travailler confortablement sur la raspberryPi. Le clavier et l'écran ne sont plus nécessaires.

3. Configuration de l'environnement de la RaspberryPi Tremplin Dev

3.1 Mode de classement des images

Le nom des images de raspberries crées pour le projet Tremplin est formé en juxtaposant les éléments suivants séparés par des tirets "-" et un "_" avant la date :

  • modèle : rpi3, rpi3P (3 BPlus), rpi4 ou rpi5
  • projet de rattachement : "Tremplin"
  • fonction :
    • dev pour la raspberry orientée codage et développement
    • met pour la raspberry orientée pilotage de station météorologique
  • distribution de debian utilisée trixie ou trixie64 au 01-01-26
  • date : AAAA-MM-JJ
  • extension type de fichier : conf img ou bmap
  • (éventuellement extension indiquant la compression xz)

Ainsi l'mage du 16 mai 2026 pour une RaspberryPi3 en trixie 64 bits pour le codage et le développement a pour nom : rpi3-dev-trixie64_26-05-16 avec les extensions bmap, img et conf.

3.2 AJustements courants pour faciliter l'usage

les modifications suivantes sont facultatives et doivent être adaptées au choix de l'administrateur * Modification du .bashrc * Modification du .bashrc de root * Ajout du dossier .ssh et des clefs de sécurité * Ajout de l'éditeur jed pour ceux qui n'aiment pas nano * Ajout de contrib et non-free à la distribution 

sudo jed /etc/apt/sources.list.d/debian.sources
sudo apt update
# Components: main contrib non-free non-free-firmware
sudo apt update

3.3 Configuration du réseau (ligne de commande)

Ce chapitre est réalisé en ligne de commande, avant d'activer l'interface graphique, par souci d'efficacité et d'économie de temps (ces manipulations sont aussi possibles ultérieurement depuis l'interface graphique). La configuration du réseau est une chose délicate car il existe beaucoup de solutions différentes dont les éléments constitutifs sont incompatibles si on tente de panacher deux solutions.

Nous avons choisi ici une voie minimaliste qui se configure et fonctionne en ligne de commande. Cela permet d'avoir un démarrage du réseau au boot que la connection soit filaire ou par wifi ; par conséquent il sera possible d'ajouter la RaspberryPi ainsi configurée dans un environnement existant proposant du DHCP sans qu'il soit nécessaire de connecter un clavier, une souris et un écran. On utilise : * systemd-networkd * wpa_supplicant * wpagui (pour l'interface graphique)

La construction de base de l'image proposée ci-dessous utilise des nomss d'interfaces génériques : enx* et wlan0.

3.3.1 Connexion à l'interface filaire par défaut

Au premier démarrage la raspberry prend automatiquement le réseau filaire en utilisant netplan. Les informations sont fournies par la commande :

sudo systemctl status systemd-networkd
# On récupère les informations :
# Loaded: loaded (/usr/lib/systemd/system/systemd-networkd.service; enabled; preset: enabled)
# Configuring with /run/systemd/network/10-netplan-all-en.network
sudo cat /run/systemd/network/10-netplan-all-en.network
[Match]
Name=en*

[Network]
DHCP=yes
LinkLocalAddressing=ipv6

[DHCP]
RouteMetric=100
UseMTU=true
UseDomains=true

3.3.2 Reconfiguration de l'interface filaire via netplan

On configure netplan :

cd /etc/netplan
sudo cp 90-default.yaml 50-enxwired.yaml
sudo mv 90-default.yaml 90-default.stdyaml
sudo jed 50-enxwired.yaml
network:
    version: 2
    renderer: networkd
    ethernets:
        all-enx:
            match:
                name: enx*
            dhcp4: true
            dhcp4-overrides:
                use-domains: true
            dhcp6: true
            dhcp6-overrides:
                use-domains: true

sudo netplan generate 
sudo netplan try
sudo netplan apply
#sudo netplan --debug apply

3.3.3 Configuration de l'interface WIFI

Attention la RaspberryPi3 ne prend pas le wifi 5 GHz.Ajout des paquets nécessaires et configuration de wpasupplicant

sudo apt install rfkill wpasupplicant
sudo rfkill
ID TYPE      DEVICE      SOFT      HARD
 0 bluetooth hci0   unblocked unblocked
 1 wlan      phy0   unblocked unblocked

sudo su 
wpa_passphrase votre-ssid votre-mot-de-passe >> /etc/wpa_supplicant/wpa_supplicant.conf
# enlever le mot de passe en clair du fichier `/etc/wpa_supplicant/wpa_supplicant.conf`

Ajouter un fichier de configuration dans /etc/netplan

cd /etc/netplan
sudo cat 60-wlan0wireless.yaml
network:
    version: 2
    renderer: networkd
    wifis:
        wlan0:
            accept-ra: true
            access-points:
                "################":
                    password: "$$$$$$$$$$$$$$$$$"
            dhcp4: true
            dhcp6: true

Sudo chmod 600 60-wlan0wireless.yaml 
sudo netplan generate 
sudo netplan try
sudo netplan apply
#sudo netplan --debug apply

3.3.4 Création d'un point d'accès

Le but de cette opération est de fournir un point d'accès à la raspberryPi sans connection filaire ni Wifi local. L'objectif est de disposer d'un accès direct à la rasberryPI lors du premier démarrage pour pouvoir terminer la configuration sans avoir besoin d'un écran ou d'un clavier.

Quelques documentations : * sur iw * sur un AP sous debian

La création du point d'accès requiert plusieurs logiciels chacun pour une fonction distincte du processus de création du point d'accès (AP). * iw crée l'interface virtuelle à côté de l'interface de connection Wifi * hostapd lance le daemon de service wifi * udhcpd lance le daemon dhcp fournissant l'IP

Création d'une interface virtuelle

Il est possible d'utiliser l'interface wlan0 comme point d'accès mais cela supprime toute possibilité de se connecter à un réseau wifi local via cette interface. Si on souhaite conserver cette possibilité il faut créer une interface virtuelle avec iw :

sudo apt install iw
sudo iw phy phy0 interface add vwlan1 type __ap 

# Le résultat est une interface wlan1 partageant la ressource physique wifi, voir ci-dessous (cela va obligatoirement baisser les performances).
ens-ife[~] rpitremplin-€ : ip a
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host noprefixroute 
       valid_lft forever preferred_lft forever
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP group default qlen 1000
    link/ether b8:27:eb:cf:5e:d9 brd ff:ff:ff:ff:ff:ff
    inet 192.168.10.40/24 metric 100 brd 192.168.10.255 scope global dynamic eth0
       valid_lft 86262sec preferred_lft 86262sec
    inet6 fe80::ba27:ebff:fecf:5ed9/64 scope link proto kernel_ll 
       valid_lft forever preferred_lft forever
3: wlan0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc fq_codel state DOWN group default qlen 1000
    link/ether b8:27:eb:9a:0b:8c brd ff:ff:ff:ff:ff:ff
    altname wlxb827eb9a0b8c
4: wlan1: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN group default qlen 1000
    link/ether ba:27:eb:3a:0b:8c brd ff:ff:ff:ff:ff:ff
    altname wlxba27eb3a0b8c

La nouvelle interface a été créée mais n'est pas activée. Il est possible de créer un service qui permettra de gérer plus facilement cette interface. Ajouter un fichier dans /etc/systemd/system/, par exemple cat > /etc/systemd/system/wireless-apdevice.service.

cat /etc/systemd/system/wireless-apdevice.service
[Unit]
Description=Template to create virtual wireless interface
Requires=sys-subsystem-net-devices-wlan0.device
After=sys-subsystem-net-devices-wlan0.device
[Service]
Type=oneshot
ExecStart=/usr/sbin/iw phy phy0 interface add wlan1 type __ap
[Install]
WantedBy=multi-user.target

Déclaration de l'interface dans systemd-networkd

netplan impose l'usage de NetworkManager pour créer un AP alors qu'il est possible de déclarer dans systemd-networkd un AP avec un dhcpserver On ajoute un fichier de service dans le dossier /etc/systemd/network/ :

cat /etc/systemd/network/50-wlanserver.network
[Match]
Name=wlan1

[Network]
DHCPServer=yes
Address=192.168.11.2/24
[DHCPServer]
ServerAddress=192.168.11.1/24

[DHCPServer]
PoolOffset=100
PoolSize=20
DNS=9.9.9.9

Il est nécessaire que l'interface wlan1 ait été créée pour qu'elle soit prise en charge par networkd Si elle est créée après le démarrage du rservice il faut le relancer.

daemon hostapd

hostapd est un programme qui crée un AP et lance un daemon qui permettra de se connecter à ce AP.

sudo apt install hostapd

Modifications du fichier de configuration

cat /etc/hostapd/hostapd.conf
interface=wlan1                                                                                                                                                                                     
driver=nl80211                                                                                                                                                                                      
ssid=raspi-Wifi                                                                                                                                                                                     
# a = IEEE 802.11a, b = IEEE 802.11b, g = IEEE 802.11g                                                                                                                                              
hw_mode=g
channel=5
wmm_enabled=0
# Allow connections from all MAC addresses except those in the blacklist
macaddr_acl=0
auth_algs=1
ignore_broadcast_ssid=0
wpa=2
#Set a password for your access point
wpa_passphrase=rpiTremplin2026
wpa_key_mgmt=WPA-PSK
wpa_pairwise=TKIP 
rsn_pairwise=CCMP

own_ip_addr=127.0.0.1
domain_name=terrasse2.fr

Si le daemon ne se lance pas (vérifier avec sudo systemctl status hostapd), pour débuguer on peut utiliser la commande suivante : sudo hostapd -d /etc/hostapd/hostapd.conf. Si le daemon est lancé on peut l'arrêter avec sudo systemctl stop hostapd

Par défaut un service est installé.

Configuration de udhcpd

sudo apt install udhcpd
sudo touch /var/lib/misc/udhcpd.leases
sudo jed  /etc/udhcpd.conf

Pour avoir les lignes activées seulement

sed 's:#.*$::g'  /etc/udhcpd.conf

Modifications du fichier /etc/udhcpd.conf.

sudo jed /etc/udhcpd.conf
start           192.168.11.20
end             192.168.11.254
interface       wlan1
max_leases      5

Contrôle du serveur Wifi

Plusieurs configurations sont possibles pour l'image qu'on diffuse, on peut choisir d'activer toutes les interfaces possibles (filaire, WIFI, serveur WIFI) ou seulement l'une d'entre elles ou seulement deux. Ce choix conditionne les stratégies de déploiement.

Pour connaître la combinaison choisie :

sudo systemctl status wireless-apdevice udhcpd hostapd

Pour désactiver les services :

sudo systemctl disable wireless-apdevice.service
sudo systemctl disable udhcpd.service
sudo systemctl disable hostapd.service

Pour activer les services :

sudo systemctl start wireless-apdevice.service
sudo systemctl start hostapd.service
sudo systemctl start udhcpd.service

Pour arrêter les services :

sudo systemctl start udhcpd.service
sudo systemctl start hostapd.service
sudo iw dev wlan1 del

3.3.5 détection de la RaspberryPi sur le réseau

Pour obtenir l'adresse IP de la raspberry, si le réseau n'est pas trop étendu, on peut utiliser la commande sudo nmap -sP -n ***.****.***.0/** la valeur ***.****.***.0/** représente le réseau sur lequel on se trouve, les valeurs peuvent être obtenues avec la commande ip addr ; si l'on dispose de l'adresse MAC de la Raspberry **:**:**:**:**:** on peut filtrer la commande ci-dessus avec l'adresse recherchée sudo nmap -sP -n ***.****.***.0/** | grep -e **:**:**:**:**:** -B 2

Une fois l'adresse obtenue se connecter via ssh ; ssh ens-ife@***.****.***.*** (remplacer ens-ife par le nom de l'utilisateur initial choisi dans le fichier de confiuration initiale)

Si le serveur WIFI est activé on peut se connecter directement sur le réseau de la raspberryPi.

3.4 Ajout d'une interface graphique

On ajoute un display manager (lxdm dans ce cas) et un window manager (lxqt dans cette proposition) ainsi que toutes leurs dépendances. Installer les paquets debian (il est possible d'installer' un autre display manager et un autre window manager, toujours choisir des environnements peu gourmands en ressources).

sudo apt install lxdm lxqt

3.5 Ajout d'utilisateurs et gestion des droits

Au premier démarrage un seul utilisateur a été créé ens-ife, dans notre projet cet utilisateur est l'administrateur du projet que nous demandons de conserver en l'état et nous proposons de créer :

  • un administrateur local à la machine localadm,
  • un utilisateur pour la connexion xrdp xrdpuser,
  • un administrateur de l'interface de programmation jupyterhub callisto
  • un utilisateur invité qui servira de test moon (ce login est utilisé en référence aux utilisateurs jupyter et callisto...)

Les groupes et les utilisateurs sont ajoutés avec les commande standard linux debian addgroup et adduser

for i in i2c gpio jupyterhub; do sudo addgroup $i; done
for i in localadm moon callisto xrdpuser; do sudo adduser $i; done

l'utilisateur localadm doit disposer des droits d'administration :

sudo adduser localadm sudo

Les utilisateurs ens-ife, localadm, callisto, xrdpuseret moon doivent pouvoir en outre utiliser les ressources matérielles de la raspberry on les affecte aux groupes nécessaires :

for i in localadm moon ens-ife callisto xrdpuser; do for j in i2c gpio netdev plugdev audio video; do sudo adduser $i $j; done; done

Pour améliorer la sécurité il est possible (souhaitable) de supprimer le login par mot de passe de callisto en lui procurant un login exclusif par clef ssh. Match User callisto PasswordAuthentication no. Pour plus de sécurité il est possible (souhaitable) de supprimer tout login par mot de passe et de modifier le portssh par défaut.

sudo jed /etc/ssh/sshd_config
# Lignes non commentées modifiées
Include /etc/ssh/sshd_config.d/*.conf
Port 24122
PermitRootLogin no
PubkeyAuthentication yes
PermitEmptyPasswords no
KbdInteractiveAuthentication no
UsePAM yes
X11Forwarding yes
PrintMotd no
AcceptEnv LANG LC_* COLORTERM NO_COLOR
Subsystem       sftp    /usr/lib/openssh/sftp-server

Les utilisateurrs localadm, moon, ens-ife, callisto doivent appartenir au groupe jupyterhub :

for i in localadm moon ens-ife callisto; do sudo adduser $i jupyterhub; done

3.6 Activation du serveur de terminaux à distance

Depuis le début l'ensemble du travail a pu être réalisé en ligne de commande, sans connecter clavier/écran/souris à la RaspberryPi. Pour pouvoir continuer dans cette logique tout en profitant d'une interface graphique évoluée nous allons installer un terminal serveur sur la raspi qui pourra afficher sur n'importe quel ordinateur du même réseau l'interface graphique de la raspberry.

3.6.1 Choix du terminal server

Plusieurs choix sont possibles, chaque outil a ses avantages et ses inconvénients. xrdp est censé proposer de meilleures performances et une bonne compatibilité avec le client de terminal server windows. C'est celui qui a été choisi.

3.6.2 Mise en place de xrdp

Cet outil permet d'afficher l'écran de la raspberry à distance dans une fenêtre d'un ordinateur portable ou de bureau et de ne pas avoir à connecter un clavier une souris et un écran à la raspberry pour pouvoir l'utiliser en mode graphique.

Vérifier si xrdp est installé.

sudo dpkg -l xrdp   
#si non
sudo apt install xrdp

Ajout de l'utilisateur xrdp dans le groupe ssl-cert.

sudo adduser xrdpuser ssl-cert

xrdpest installé et préconfiguré pour fonctionner comme un service géré comme les autres services par systemctl. Les 3 fichiers de configuration du service se trouvent dans /lib/systemd/system :

xrdp-sesman.service
xrdp session manager 
xrdp.service

Les fichiers de configuration de l'application sont dans /etc/xrdp, on modifie ci dessous le port et la profondeur de l'image. 

sudo cp /etc/xrdp/xrdp.ini /etc/xrdp/xrdp.ini.bak
sudo sed -i 's/3389/3390/g' /etc/xrdp/xrdp.ini
sudo sed -i 's/max_bpp=32/#max_bpp=32\nmax_bpp=128/g' /etc/xrdp/xrdp.ini
sudo sed -i 's/xserverbpp=24/#xserverbpp=24\nxserverbpp=128/g' /etc/xrdp/xrdp.ini

Démarrage du service :

systemctl status dbus
# s'il n'est pas actif 
sudo su
systemctl enable dbus
exit
sudo systemctl start dbus
# dbus activé
sudo systemctl start xrdp

Vérification du fonctionnement avec sudo systemctl status xrdp, vérification que xrdp est activé au démarrage avec sudo systemctl is-enabled xrdp.

L'affichage se fait à l'aide d'un client de serveur de terminaux remmina par exemple ou l'outil connexion de bureau à distance sur le port 3390 soit : IP.de.la.raspi:3390.

4. Installation et mise à jour de l'environnement logiciel de développement

La première étape de l'installation consiste à créer pour chaque logiciel un espace pour stocker les codes puis de les télécharger dans cet espace depuis les forges opensource ou libres. Nous allons créer une hierarchie de dossiers ayant pour racine le dossier Logiciels; on y retrouvera par exemple un dossier IoT (Internet of Things) contenant un dossier mraa et un dossier upm.

La raspberry en plus de la possibilité de développer du code comme tout autre ordinateur, elle dispose du bus GPIO proposant des interfaces I2C, SPI, UART, etc... Elles permettent de connecter des capteurs et des effecteurs ouvrant un champ d'investigation en interaction avec le monde réel.

4.1 Utilitaires et compléments de l'environnement

Les forges libres proposent de nombreux logiciels qui peuvent facilement être ajoutés à la Raspberry Pi, même s'il faut les compiler. La manipulation n'est pas compliquée et requiert des connaissances peu avancées à titre d'exemple nous installerons sur notre image les logiciels mraa et upm initiés par Intel et maintenus par eclipse sur github. Le premier donne accès à la maîtrise du bus GPIO le second propose plusieurs centaines de "drivers" pour des leds, capteurs et effecteurs du monde des "makers". C'est l'équivalent de ce que les utilisateurs des arduino appellent des librairies sauf que dans le cas de la Raspberry que nous construisons nous allons réellement construire des librairies au sens informatique du terme dont les composants pourront être appelés depuis les langages C, C++, python, Java, Node-JS... Cela permettra d'écrire des programmes simples permettant d'interagir avec des capteurs météo des leds ou tous autres composants électroniques connectables. (voir nos cahiers de programmes pour jupyter.

Quelques outils utiles pour la suite :

sudo dpkg -l htop wget gcc g++ clang make autoconf automake \
             flex bison pkg-config openssl openjdk-25-jdk \
             openjdk-25-jre openjdk-25-jre-headless python3-openssl \
             python3-cryptography python3-distutils-extra libssl-dev \
             pcre2-utils ibpcre2-dev python3-dev python3-configobj \
             libjavascriptcoregtk-6.0-dev libwebkitgtk-6.0-dev git \
             libtool graphviz doxygen libjson-c-dev libgtest-dev 

sudo apt install htop wget gcc g++ clang make autoconf automake \
                 flex bison pkg-config openssl openjdk-25-jdk \
                 openjdk-25-jre openjdk-25-jre-headless python3-openssl \
                 python3-cryptography python3-distutils-extra libssl-dev \
                 pcre2-utils libpcre2-dev python3-dev python3-configobj \
                 libjavascriptcoregtk-6.0-dev libwebkitgtk-6.0-dev git \
                 libtool graphviz doxygen libjson-c-dev libgtest-dev

L'utilisation de poetry pour créer des environnements virtuels python permet de limiter le nombre de modules python installés directement sur le système et de gérer plus facilement les versions et dépendances. Il est toutefois possible d'installer des modules partagés par tous les environnements dans le \python du système. Il est possible d'installer si besoin (tester avec dpkg)les librairies de développement suivantes qui fournissent les fichiers d'en-tête utilisés pour construire des outils python, cette liste est proposée à titre d'exemple et n'est pas exhaustive.

dpkg -l libopenblas-dev libhdf5-dev libnetcdf-dev python3-pandas python3-rpi.gpio python3-netcdf4 python3-numpy python3-six python3-wheel python3-setuptools python3-folium
sudo apt install libopenblas-dev libhdf5-dev libnetcdf-dev python3-pandas python3-rpi.gpio python3-netcdf4 python3-numpy python3-six python3-wheel python3-setuptools python3-folium

4.1.1 Ajout d'un swap sur disque

Certains modules requièrent pour se compiler avec l'option -j4 du make plus de RAM que la raspberryPi3 n'en possède physiquement, elle peut se figer. On peut tenter alors de passer avec l'option -j2 ou -j1 (qui utilise seulement 2 ou 1 des coeurs du processeur). Il est aussi possible d'ajouter un fichier de swap avec les commandes suivantes qui fournissent xxx Mo de swap, la compilation passe en -j4 mais la raspi3 swape choisissez l'option qui vous convient ! (Le swap est obligatoire si même en compilant avec un seul cœur il n'y a pas assez de mémoire)

  • pour 512 M de swap xxx = 524288
  • pour 1 Go de swap xxx = 1048576
  • pour 2 Go de swap xxx = 2097152
  • etc...
sudo su
dd if=/dev/zero of=/swapfile bs=1024 count=1048576
chown root:root /swapfile
chmod 0600 /swapfile
mkswap /swapfile
swapon /swapfile

Pour vérifier l'activité :

swapon -s
free -m

Après un redémarrage si le swap est nécessaire, on l'ajoute avec la commande sudo swapon /swapfile et il est immédiatement utilisable.

4.1.2 Compilation d'un cmake récent

Dans les versions stables de debian armhf la version de cmake peut s'avérer en retard si c'est le cas compiler depuis les sources sinon installer le paquet standard. Attention la compilation de cmake peut s'avérer extrêmement longue.

cd
mkdir -p Logiciels/Cmake
cd Logiciels/Cmake
curl -o cmake-4.3.0.tar.gz https://github.com/Kitware/CMake/releases/download/v4.3.0/cmake-4.3.0.tar.gz
# ou
wget https://github.com/Kitware/CMake/releases/download/v4.3.0/cmake-4.3.0.tar.gz
tar xvfz cmake-4.3.0.tar.gz cmake-4.3.0
cd cmake-4.3.0
./bootstrap
# installer les packages manquants s'il y en a
make -j4
# Attention l'option -j4 requiert à certain moments beaucoup de mémoire,
# il faut passer les goulots d'étranglement avec -j2 ou du swap, on peut
# revenir ensuite en -j4
sudo make install

4.1.3 Ajout de fontes

Vérifier s'il ne manque pas des fontes, si oui les installer.

sudo dpkg -l fonts-liberation gsfonts libxfont-dev libfontenc-dev \
             ttf-mscorefonts-installer xfonts-100dpi xfonts-75dpi \
             xfonts-base xfonts-scalable xfonts-utils

sudo apt install fonts-liberation gsfonts libxfont-dev libfontenc-dev \
                 ttf-mscorefonts-installer xfonts-100dpi xfonts-75dpi \
                 xfonts-base xfonts-scalable xfonts-utils

4.1.4 Installation de Node.js

Node.js évolue très rapidement avec un souci peu prononcé des développeurs pour la compatibilité ascendante, il est souhaitable de vérifier s'il n'existe pas une nouvelle version compatible depuis l'écriture de ce blog, vérifier la version à jour sur le site Node.js.

Il y a deux stratégies possibles pour utiliser nodejs nous utiliserons la stratégie par utilisateur qui est la plus souple via nvm qui permet de disposer de plusieurs versions de node en parallèle et de s'adapter aux compatibilités/incompatibilités entre node et les logiciels dépendant de lui. C'est particulièrement utile quand on utilise un user ordinaire pour lancer un service plutôt que d'utiliser root(jupyterhub lancé par _callisto) pour ce qui nous intéressera plus loin

L'outil nvm (pour lequel il n'existe pas de paquet debian) facilite le suivi de node.JS, nous installerons la version LTS (version à long terme) ou la version STABLE (dernière version stable à jour).

L'inconvénient de cette solution est que les fichiers de configuration .nvm et .npm sont installés dans le home de l'utilisateur ainsi que le dossier des modules : node_modules

Récupération et installation de nvm (stratégie par utilisateur) puis des versions de nodejs précompilées.Cette manipulation devra être répétée pour tous les utilisateurs souhaitant utiliser node.JS.

Vérifier la version à jour de nvm sur la forge github puis télécharger installer avec la commande suivante :

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.4/install.sh | bash

Si elles n'ont pas été automatiquement exécutées par le script ou si elles eont généré des messages d'erreur, exécuter les 3 commandes ci-dessous s :

export NVM_DIR="$HOME/.nvm"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"  
[ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion"

verifier la situation. 

source ~/.bashrc
nvm ls
#            N/A
#iojs -> N/A (default)
#node -> stable (-> N/A) (default)
#unstable -> N/A (default)

Lister les versions disponibles et charger les versions de nodejs désirées.

nvm ls-remote

nvm install v24.14.0
Downloading and installing node v24.14.0...
Downloading https://nodejs.org/dist/v24.14.0/node-v24.14.0-linux-arm64.tar.xz...
################################################### 100.0%
Computing checksum with sha256sum
Checksums matched!
Now using node v24.14.0 (npm v11.9.0)
Creating default alias: default -> v24.14.0 *

nvm install v25.8.1
Downloading and installing node v25.8.1...
Downloading https://nodejs.org/dist/v25.8.1/node-v25.8.1-linux-arm64.tar.xz...
################################################### 100.0%
Computing checksum with sha256sum
Checksums matched!
Now using node v25.8.1 (npm v11.11.0)

Réaliser la même opération pour le user callisto. Elle permettra d'utiliser des modules pour jupyterhub sans perturber le système global.

4.2 Compilation des logiciels de service pour les outils mraa, upm, jupyter

### 4.2.1 Récupération et construction du paquet swig

L'outil swig est complexe et évolue systématiquement après les évolutions des langages qu'il permet de traduire. nodeJS évolue rapidement et fréquemment et swig n'est pas toujours compatible avc la dernière version. De même les versions de C++ se succèdent et proposent de nouvelles fonctionnalités utilisées dans les compilations croisées. La création d'un jeu de compilations croisées est délicate et doit être menée avec précaution.

Il existe un paquet debian qui en général est en retard par rapport aux développements de swig (ai 11/03/2026 4.3.0-1 vs 4.4.1)

La méthode suivante permet de compiler la dernière version.

cd
mkdir -p Logiciels/Swig
cd Logiciels/Swig

wget https://github.com/swig/swig/archive/refs/tags/v4.4.1.tar.gz
tar xvfz v4.4.1.tar.gz

cd swig-4.4.1
npm install node-gyp
sudo apt install node-gyp 
./autogen.sh
./configure

Si les choses se passent normalement on obtient le message qui indique que nous pourrons utiliser nos librairies croisées avec les 4 langages :

The SWIG test-suite and examples are configured for the following languages:
c java javascript perl5 python

poursuivre avec :

make -j4
sudo make install

4.2.2 Récupération et construction de zwave-js

On utilisait précédemment le logiciel libopenzwave mais ce dernier a été abandonné zwave-js semble un bon candidat pour le remplacer.

sudo addgroup zwave
sudo adduser ens-ife zwave
sudo mkdir /opt/Zwave-js
/opt/
sudo chown -R root:zwave Zwave-js
sudo chmod g+rwX Zwave-js
cd Zwave-js
npm init
This utility will walk you through creating a package.json file.
It only covers the most common items, and tries to guess sensible defaults.

See `npm help init` for definitive documentation on these fields
and exactly what they do.

Use `npm install <pkg>` afterwards to install a package and
save it as a dependency in the package.json file.

Press ^C at any time to quit.
package name: (zwave) 
version: (1.0.0) 
description: test d'utilisation zwave-js
entry point: (index.js) 
test command: 
git repository: 
keywords: 
author: 
license: (ISC) 
About to write to /opt/Zwave-js/package.json:

{
  "name": "zwave",
  "version": "1.0.0",
  "description": "test d'utilisation zwave-js",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "",
  "license": "ISC"
}


Is this OK? (yes) 
npm i zwave-js

Interface graphique

sudo mkdir /opt/Zwave-js-ui
cd /opt/
sudo chown -R root:zwave Zwave-js-ui
sudo chmod g+rwX Zwave-js-ui
cd Zwave-js-ui
git clone https://github.com/zwave-js/zwave-js-ui.git
cd zwave-js-ui
npm install

npm start

4.2.3 Récupération et construction du paquet openZwave

À titre conservatoire avant que toutes les migrations aient été effectuées on compile Openzwave

cd 
mkdir -p Logiciels/OpenZwave
cd !$
git clone https://github.com/OpenZWave/open-zwave.git
cd open-zwave
make -j4
touch Doxyfile
sudo doxygen -u
sudo make install

4.2.4 Récupération et construction du paquet modbus

cd 
mkdir -p Logiciels/Modbus
cd !$
git clone https://github.com/stephane/libmodbus.git
cd libmodbus/
./autogen.sh 
./configure
make -j4
sudo make install

En cas de problème utiliser avant ./configure.

libtoolize
aclocal
autoheader
autoconf
automake --add-missing

4.2.5. Récupération et construction du paquet tinyb

TinyB est obsolète la source est accessible mais ne se compile pas.

dpkg -l libglib2.0-dev
# si manquante
sudo apt install libglib2.0-dev
cd ~/Logiciels
mkdir Tinyb
cd Tinyb
git clone https://github.com/intel-iot-devkit/tinyb.git
cd tinyb/

AJouter #include <string> dans api/tinyb/BluetoothObject.hpp si problème de compilation avec ‘std::string’

mkdir build
cd build/
cmake -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_POLICY_VERSION_MINIMUM=4.2 ..
make -j4
sudo make install

sudo apt install bluez-test-scripts bluez-tools

5. Installation et mise à jour des logiciels de développement et de programmation

5.1 Outils pour l'apprentissage de la programmation

5.1.1 Récupération et Construction de mraa et upm

Certains modules requièrent beaucoup de RAM pour se compiler avec l'option -j4 choisir l'option -j2 (qui utilise seulement 2 des coeurs du processeur) ou l'augmentation du swap (swapon /swapfile si le swap a été créé comme proposé plus faut), la compilation passe en -j4 mais la raspi3 swape choisissez l'option qui vous convient !

cd
mkdir -p Logiciels/IoT
cd !$
git clone https://github.com/eclipse-mraa/mraa.git
git clone https://github.com/eclipse-upm/upm.git

# Autres sources
git clone https://github.com/eclipse/mraa.git
git clone https://gitcode.com/eclipse-org/mraa.git
git clone https://github.com/eclipse/upm.git

5.1.1.1. MRAA

dpkg -l libjson-c-dev python3-dev
sudo apt install libjson-c-dev python3-dev
sudo apt install libnative-platform-jni

Modifications du CMakeLists.txt

Les modifications de policy sont imposées par l'évolution des logiciels depuis la création initiale de ce fichier. les option sont modifiées pour avoir les fonctions java et javascript lors des développements avec Jupyter.

cd mraa
jed CMakeLists.txt
# add
# cmake_policy(SET CMP0148 NEW)
# cmake_policy(SET CMP0177 NEW)
# check
# option (BUILDSWIGNODE "Build swig node modules." ON)
# option (BUILDSWIGJAVA "Build Java API." ON)
# option (USEPYTHON3TESTS "Force tests to run with python3" ON)

Tester la définition de JAVA_HOME sinon :

# export JAVA_HOME=/usr/lib/jvm/java-25-openjdk-arm64

(À vérifier) Tester et régler le problème de l'interface i2c si besoin fichier src/mraa.c

jed src/mraa.c
#transformer
if (mraa_file_exist("/sys/class/i2c-dev/i2c-0"))
#en
if (mraa_file_exist("/sys/class/i2c-dev/i2c-0") || mraa_file_exist("/sys/class/i2c-dev/i2c-1"))

cd Logiciels/IoT/mraa/src/
jed java/CMakeLists.txt
jed javascript/CMakeLists.txt
jed python/python3/CMakeLists.txt

Compilation

Pour la compilation la version C++23 a été utilisée via des modifications dans le CMakefiles.txt

mkdir build
cd build
cmake -DCMAKE_INSTALL_PREFIX=/usr \
      -DCMAKE_MODULE_PATH=/usr/local/share/cmake-4.3/Modules/ \
      -DNODEJS_INCLUDE_DIRS=/home/ens-ife/\
                            .nvm/versions/node/v25.8.1/include/node \
      -DSWIG_EXECUTABLE=/usr/local/bin/swig ..

make -j4

Il subsite un \warning_ et une error. Éditer build/src/python/python3/CMakeFiles/python3-mraa.dir/mraa3PYTHON_wrap.cxx et faire les modifications suivantes :

//#define SWIGPYTHON 
//  extern mraa_lang_func_t* lang_func;                                          
  mraa_lang_func_t* lang_func = NULL;  
.../...

La compilation avec make -j4 aboutit et on peut installer les libs mraa avec sudo make install

La dernière version est disponible sur la forge tremplin. L'ensemble des modifications effectuées est obtenue en recherchent les différences entre master et tremplin sur la forge git diff master.

`

5.1.1.2. UPM

sudo apt install libjpeg-dev

Au 2026-04-21 lorsque cette compilation a été effectuée avec succès, le logiciel a besoin d'une profonde révision du fait des importantes évolutions des codes annexes (cmake, python node). En particulier la compilation s'appuie sur python2 avec des extensions en python3 alors que que python2 a disparu. La solution utilisée a été un empilement de contournements pour utiliser les versions à jour et réussir la compilation. Il est nécessaire de reprendre le code avec les nouvelles versions des logiciels impliqués.

Pour plus de commodité et permettre de reproduire ce travail la version opérationnelle a été déposée en l'état sur la forge du projet tremplin des sciences. La liste des fichiers modifiés est la suivante : * modifié : CMakeLists.txt * modifié : cmake/modules/FindNode.cmake * modifié : cmake/modules/FindNpm.cmake * modifié : cmake/modules/OpenCVDetectPython.cmake * nouveau fichier : cmake/modules/OpenCVDetectPython.oldcmake * modifié : include/upm_types.h * modifié : src/CMakeLists.txt * modifié : src/ehr/ehr.cxx * supprimé : src/hp20x/CMakeLists.txt * supprimé : src/hp20x/hp20x.cxx * supprimé : src/hp20x/hp20x.hpp * supprimé : src/hp20x/hp20x.json

cd ~/Logiciels/IoT/
git clone https://depot.tremplin.ens-lyon.fr/Raspberries/upm.git
cd upm/build

cmake -DCMAKE_INSTALL_PREFIX=/usr \
      -DCMAKE_MODULE_PATH=/usr/local/share/cmake-4.3/Modules/ \
      -DNODE_ROOT_DIR=/home/ens-ife/.nvm/versions/node/v24.14.0/ \
      .. >& trace.txt

sudo rm -r ./*;\
cmake -DCMAKE_INSTALL_PREFIX=/usr \
      -DCMAKE_MODULE_PATH=/usr/local/share/cmake-4.3/Modules/ \
      -DNODEJS_INCLUDE_DIRS=/home/ens-ife/.nvm/versions/node/v25.8.1/include/node \
      -DSWIG_EXECUTABLE=/usr/local/bin/swig .. >& ../trace.txt


make -j4
sudo make install

# Pour lancer une compilation complète effacer si besoin le dossier
sudo rm -r ./*

Si besoin : npm install -g upm-cordova-binding

5.2 Installation de Jupyterlab et Jupyterhub

Jupyter est un interface graphique de développement et de programmation multilangages qui permet de se familiariser simplement avec la programmation. Il permet d'approcher simplement un langage de programmation, sa syntaxe, son vocabulaire et sa logique. Il permet de produire et d'exploiter des cahiers de programmes ipython intégrant code source et commentaire qui s'avèrent être d'excellents outils pédagogiques pour l'apprentissage du code voir les cahiers de programmes du projet Tremplin et par exemple la ministation météo. Jupyterhub est un outil companion de Jupyter qui permet de servir jupyter sur le web à plusieurs usagers en même temps, lors d'un TP ou TD par exemple.

Jupyter et Jupyterhub sont des logiciels python et peuvent donc être installés avec pip ou poetry. Il est possible de réaliser une installation dans un environnement virtuel poetry la compatibilité et l'interopérabilité entre les paquets python est garantie sans perturber le fonctionnement du python global du système. L'inconvénient est que l'environnement virtuel duplique l'espace occupé par python.

Pour éviter que le serveur jupyterlab soit contrôlé par root On installe l'environnement virtuel et les ressources jupyter sous la responsabilité du user callisto.

5.2.1 Installation de poetry

Depuis ens-ife . 

sudo cp .bashrc /home/callisto
sudo chown callisto:callisto /home/callisto/.bashrc
sudo cp -r .ssh /home/callisto
sudo chown -R callisto:callisto /home/callisto/.ssh
sudo apt install python3-poetry rustc

Passer ensuite sous callisto.

sudo su callisto
cd
mkdir Jupyter
cd Jupyter/
poetry init
Package name [jupyter]:  
Version [0.1.0]:  1.0.0
Description []:  Jupyter dev tool
Author [None, n to skip]:  n
License []:  
Compatible Python versions [>=3.13]:  

Would you like to define your main dependencies interactively? (yes/no) [yes] no
Would you like to define your development dependencies interactively? (yes/no) [yes] no
Generated file

[project]
name = "jupyter"
version = "1.0.0"
description = "Jupyter dev tool"
authors = [
    {name = "Your Name",email = "you@example.com"}
]
readme = "README.md"
requires-python = ">=3.13"
dependencies = [
]


[build-system]
requires = ["poetry-core>=2.0.0,<3.0.0"]
build-backend = "poetry.core.masonry.api"


Do you confirm generation? (yes/no) [yes]

5.2.2 Installation de jupyterlab et jupyterhub

cd ~/Jupyter
poetry add jupyterlab jupyterhub notebook
poetry add sudospawner flexx plotly pandas netCDF4 numpy six spidev pillow RPi.GPIO

5.2.3 Installation des ressources mraa et upm dans l'environnement virtuel de callisto

Détection de la localisation de l'environnement virtuel python

sudo su callisto
cd ~/Jupyter
poetry env info
.../...
/home/callisto/.cache/pypoetry/virtualenvs/jupyter-cp9TDEDI-py3.13
.../...

Localisation des librairies et binaires python de mraa et copie dans l'environnement virtuel.

ls /lib/python3.13/dist-packages/
mraa.py  _mraa.so  upm
cp /lib/python3.13/dist-packages/*mraa* /home/callisto/.cache/pypoetry/virtualenvs/jupyter-cp9TDEDI-py3.13/lib/python3.13/site-packages/

Localisation des librairies et binaires python de upm et copie dans l'environnement virtuel.

ls src/*/python3.13/*.py
sudo cp /home/ens-ife/Logiciels/IoT/upm/build/src/*/python3.13/*.py /home/callisto/.cache/pypoetry/virtualenvs/jupyter-cp9TDEDI-py3.13/lib/python3.13/site-packages/
sudo chown -R callisto:callisto  /home/callisto/.cache/pypoetry/virtualenvs/jupyter-cp9TDEDI-py3.13/lib/python3.13/site-packages

5.3 Configuration de jupyterhub et de la sécurité du lancement par callisto

5.3.1 Création du fichier de configuration

Callisto va regrouper toutes les informations concernant jypyterhub même si les fichiers de configuration sont dispatchés dans d'autres dossiers.

En callisto : 

cd ~/Jupyter
`poetry env activate`
cd
mkdir Jupyterhub
cd !$
jupyterhub --generate-config

Pour tester à tout moment l'état du fichier de onfiguration 

sed -e '/^\s*#.*$/d' -e '/^\s*$/d' jupyterhub_config.py

Modifier le fichier schema.py comme indiqué ci-dessous pour éviter l'alerte au lancement de jupyterhub.

/home/callisto/.cache/pypoetry/virtualenvs/jupyter-cp9TDEDI-py3.13/lib/python3.13/site-packages/jupyter_events/schema.py

    @property                                                                                       
#    def version(self) -> int:                                                                      
    def version(self) -> str:

5.3.2 Création des fichiers de sécurisation

Pour assumer la configuration envisagée l'utilisateur callisto doit créer le certificat de sécurité ainsi que le token partagé et le cookie secret.

sudo su callisto
cd
mkdir -p Utils/Certificates
cd !$
# elliptic
openssl ecparam -list_curves
# c2pnb272w1
openssl ecparam -rand /dev/urandom -name c2pnb272w1 -genkey -noout -out meteojuphub.key
openssl req -new -x509 -days 365 -noenc -key meteojuphub.key -out meteojuphub.pem 

# ECDSA en une seule commande
openssl req -newkey rsa:4096  -x509  -sha512  -days 365 -noenc -out meteojuphub.pem -keyout meteojuphub.key

Répondre aux questions posées en fonction de vos paramètres.

Création du token partagé de jupyterhub.

cd
mkdir Tokens
cd Tokens/
openssl rand -hex 32 > tokenJupyterhub.txt

5.3.3 Modification du fichier des sudoers

Pour que Jupyterhub puisse être lancé par callisto et fonctionne correctement callisto (que nous avons choisi comme user pour lancer Jupyterhub doit disposer de quelques privilèges qui doivent être ajoutés par l'administrateur (et pas par callisto qui n'a pas de privilèges suffisants) au fichier sudoers avec la commande sudo visudo en ajoutant les lignes suivantes :

# Cmnd alias specification
#---- Jupyterhub---- 
# the command(s) the Hub can run on behalf of the jupyterhub group users          
# without needing a password                                                      
# the exact path may differ, depending on how sudospawner was installed           
Cmnd_Alias JUPYTER_CMD = /home/callisto/.cache/pypoetry/virtualenvs/jupyter-cp9TDEDI-py3.13/bin/sudospawner

# actually give the Hub user permission to run the above command                  
# on behalf of the above users without prompting for a password                                                           
callisto ALL=(%jupyterhub) NOPASSWD:JUPYTER_CMD  
#-------------------

L'utilisateur callisto doit aussi appartenir au groupe shadow.

sudo adduser callisto shadow

On dispose maintenant des fichiers de sécurisaton nécessaires meteojuphub.key meteojuphub.pem qui vont être utilisés pour protéger l'accès à jupyterhub. Par défaut un fichier de sécurisation a été installé pour permettre un fonctionnement immédiat mais chaque nouvel administrateur doit impérativement créer son propre fichier de sécurité.

5.3.4 Configuration

La configuration de jupyterhub est une opération délicate qui peut être faite en suivant pas à pas ce tutoriel. Dans plusieurs étapes des choix alternatifs sont possibles nous ne reproduirons ici que les choix faits pour l'image Tremplin des sciences.

Il est possible d'effectuer un démarrage par défaut avant configuration : jupyterhub -f /etc/jupyterhub/jupyterhub_config.py cela permet de vérifier l'installation mais ne fournit pas tous les services.

5.3.4.1 Activation du lancement par callisto

Nous avons choisi de lancer le hub par un utilisateur non privilégié il est nécessaire d'effectuer quelques modifications dans le fichier de configuration pour permettre le lancement d'un jupyterlab par plusieurs utilisateurs à partir d'un hub lancé par callisto.

Le fichier jupyterhub_config.py original est recopié dans le dossier /home/callisto/Jupyterhub et est modifié comme indiqué ci-dessous :

c = get_config()  #noqa
c.JupyterHub.spawner_class='sudospawner.SudoSpawner'
c.JupyterHub.ssl_cert = '/home/callisto/Utils/Certificates/meteojuphub.pem'
c.JupyterHub.ssl_key = '/home/callisto/Utils/Certificates/meteojuphub.key'
c.Authenticator.admin_users = set(['localadm','callisto','ens-ife'])
c.Authenticator.allow_all = True
c.Authenticator.any_allow_config = True

La méthode d'authentification permet à tous les usagers capables de se connecter à la raspberry de pouvoir accèder à jupyterlab. Cette méthode pourra être affinée ultérieurement, ce qui n'interfère pas avec l'installation.

5.3.4.2 Lancement de traefik séparément du hub

Pour fonctionner jupyterhub utilise un serveur web relais qui envoie depuis interne (localhost:8000 dans notre configuration), vers une adresse et un port externe (192.168.10.49:443 dans notre configuration). Nous utilisons traefik qui est activé sous la forme d'un service systemd.

Installation de traefik par le user callisto

Installer l'exécutable:

cd /home/poetry/Jupyter
poetry add jupyterhub-traefik-proxy
`poetry env activate`
python3 -m jupyterhub_traefik_proxy.install
sudo mkdir /home/callisto/Jupyterhub/Utils/Traefikraefik
cd ../Jupyterhub/Utils/Traefikraefik

Créer les fichiers de configuration traefik.toml et rules.toml

nano traefik.toml
cat /etc/traefik/traefik.toml
[api]

[providers]
providersThrottleDuration = "0s"

[log]
level = "DEBUG"

[providers.file]
directory = "/home/callisto/Jupyterhub/Utils/Traefik"
filename = "/home/callisto/Jupyterhub/Utils/Traefik/rules.toml"
watch = true

[entryPoints.https]
address = "192.168.10.49:443"

[entryPoints.auth_api]
address = "localhost:8099"

[entryPoints.https.http.tls]
options = "default"

nano rules.toml
cat rules.toml 
[http.routers.route_api]
rule = "Host(`localhost`) && PathPrefix(`/api`)"
entryPoints = [ "auth_api",]
service = "api@internal"
middlewares = [ "auth_api",]

[http.routers.router__2F]
service = "service__2F"
rule = "PathPrefix(`/`)"
entryPoints = [ "https",]

[jupyterhub.routes.router__2F]
routespec = "/"
target = "http://127.0.0.1:8000"
router = "router__2F"
service = "service__2F"

[http.middlewares.auth_api.basicAuth]
users = [ "api_admin:$2b$12$myaveYCayZnQQz9c6oaSue7vw.kD7FklQrSSOAIJKRKnx8j5y5lGG",]

[http.services.service__2F.loadBalancer]
passHostHeader = true
[[http.services.service__2F.loadBalancer.servers]]
url = "http://127.0.0.1:8000"

[tls.stores.default.defaultCertificate]
certFile = "/home/callisto/Jupyterhub/Utils/Certificates/meteojuphub.pem"
keyFile = "/home/callisto/Jupyterhub/Utils/Certificates/meteojuphub.key"

[jupyterhub.routes.router__2F.data]
hub = true
Création du service traefik.service

Pour simplifier la gestion du serveur traefik on ajoute le fichier de service traefik.service dans /etc/systemd/system

cd /etc/systemd/system
nano traefik.service

cat traefik.service
[Unit]
Description=Traefik
Documentation=https://doc.traefik.io/traefik/
#After=network-online.target
#AssertFileIsExecutable=/usr/bin/traefik
#AssertPathExists=/etc/traefik/traefik.toml

[Service]
# Run traefik as its own user (create new user with: useradd -r -s /bin/false -U -M traefik)
#User=traefik
User=callisto
AmbientCapabilities=CAP_NET_BIND_SERVICE

# configure service behavior
Type=notify
ExecStart=/usr/local/bin/traefik --configFile=/home/callisto/Jupyterhub/Utils/Traefik/traefik.toml
Restart=always
WatchdogSec=1s

# lock down system access
# prohibit any operating system and configuration modification
#ProtectSystem=strict
# create separate, new (and empty) /tmp and /var/tmp filesystems
#PrivateTmp=true
# make /home directories inaccessible
#ProtectHome=true
# turns off access to physical devices (/dev/...)
#PrivateDevices=true
# make kernel settings (procfs and sysfs) read-only
#ProtectKernelTunables=true
# make cgroups /sys/fs/cgroup read-only
#ProtectControlGroups=true

# allow writing of acme.json
#ReadWritePaths=/etc/traefik/acme.json
# depending on log and entrypoint configuration, you may need to allow writing to other paths, too

# limit number of processes in this unit
#LimitNPROC=1

[Install]
WantedBy=multi-user.target

Le service est lancé par la commande sudo systemctl start traefik.service. Le service peut être configuré pour être mis en route au démarrage par la commande sudo systemctl enable traefik.service

5.3.4.3 Lancement de jupyterhub

Pour plus de commodité jupyterhub est lancé comme un service (après traefik !), il est nécessaire de créer le fichier jupyterhub.service dans le dossier /etc/systemd/system contenant les instructions ci-dessous :

cd /etc/systemd/system
nano jupyterhub.service

cat jupyterhub.service
[Unit]
Description=JupyterHub
After=syslog.target network.target traefik.target

[Service]
User=callisto
WorkingDirectory=/home/callisto/Jupyterhub
Environment="PATH=/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/home/callisto/.cache/pypoetry/virtualenvs/jupyter-cp9TDEDI-py3.13/bin"
ExecStart=/home/callisto/.cache/pypoetry/virtualenvs/jupyter-cp9TDEDI-py3.13/bin/jupyterhub -f /home/callisto/Jupyterhub/Utils/jupyterhub_config.py

[Install]
WantedBy=multi-user.target

Le service est lancé par la commande sudo systemctl start jupyterhub.service. Le service peut être configuré pour être mis en route au démarrage par la commande sudo systemctl enable jupyterhub.service

5.4 Ajout de moteurs l'environnement jupyter/jupyterhub

Jupyter et Jupyterhub sont programmés en python mais les notebooks (cahiers d'exercices) qu'ils utilisent peuvent fonctionner avec d'autres langages, voir ici la liste des langages disponibles. À titre d'exemple nous proposons ici l'installation de quelques noyaux additionnels.

5.4.1 Langage C++

Pour réaliser des notebooks en langage il suffit d'ajouter l'extension clang_repl_kernel qui fournit un noyau proposant plusieurs versions de C++. L'ajout se fait via poetry :

sudo su callisto
cd ~/Jupyter
poetry add clang-repl clang_repl_kernel

le noyau clang est immédiatement accessible depuis jupyterlab Mais les sous-versions 14 17 20 23 (qui correspondent aux années de normalisation) ne sont pas accessibles. Les fichiers jupyter/kernels/clang_repl_cpp##/kernel.json sont anormaux il est ncessaire de les remplacer par les fichiers suivants :

clang_repl/kernel.json
{"argv": ["python", "-m", "clang_repl", "-f", "{connection_file}"], "display_name": "clang_repl", "language": "c++"}
clang_repl_cpp14/kernel.json
{"argv": ["python", "-m", "clang_repl", "-f", "{connection_file}", "--std=c++14"], "display_name": "clang_repl (C++14)", "language": "c++"}
clang_repl_cpp17/kernel.json
{"argv": ["python", "-m", "clang_repl", "-f", "{connection_file}", "--std=c++17"], "display_name": "clang_repl (C++17)", "language": "c++"}
clang_repl_cpp20/kernel.json
{"argv": ["python", "-m", "clang_repl", "-f", "{connection_file}", "--std=c++20"], "display_name": "clang_repl (C++20)", "language": "c++"}
clang_repl_cpp23/kernel.json
{"argv": ["python", "-m", "clang_repl", "-f", "{connection_file}", "--std=c++23"], "display_name": "clang_repl (C++23)", "language": "c++"}

5.4.2 Langages javascript et typescript

Il n'est pas facile de trouver un noyau javascript stable du fait de l'évolution ultra-rapide de ce langage; il est probable que peu de mainteneurs puissent suivre la cadence. Il semble que deno soit une solution alternative intéressante (installée non testée dans ce projet), facile à installer.

Installer deno

sudo su callisto
cd
curl -fsSL https://deno.land/install.sh | sh

Installer le noyau jupyter

deno jupyter --install 
# si le kernel est installé dans le .local/share le copier
cp -r /home/callisto/.local/share/jupyter/kernels/deno /home/callisto/.cache/pypoetry/virtualenvs/jupyter-cp9TDEDI-py3.13/share/jupyter/kernels/
# si cela fonctionne  le supprimer du .local
rm -r /home/callisto/.local/share/jupyter/kernels/deno

5.4.3 Langage Java

Pour ajouter un noyau java la ressource ijava est obsolète, un nouvel utilitaire jjava est en cours de développement (pre-release) mais déjà opérationnel c'est lui qui est utilisé. L'installation a été faite en suivant la procédure ci-dessous.

sudo su callisto
cd ../Jupyterhub/Utils/
mkdir Java
cd Java/
wget https://github.com/dflib/jjava/releases/download/1.0-a7/jjava-1.0-a7-kernelspec.zip
unzip jjava-1.0-a7-kernelspec.zip
jupyter kernelspec install ../Java --user --name=java
jupyter kernelspec list

Available kernels:
  java                /home/callisto/.local/share/jupyter/kernels/java
  clang_repl          /home/callisto/.cache/pypoetry/virtualenvs/jupyter-cp9TDEDI-py3.13/share/jupyter/kernels/clang_repl
  clang_repl_cpp14    /home/callisto/.cache/pypoetry/virtualenvs/jupyter-cp9TDEDI-py3.13/share/jupyter/kernels/clang_repl_cpp14
  clang_repl_cpp17    /home/callisto/.cache/pypoetry/virtualenvs/jupyter-cp9TDEDI-py3.13/share/jupyter/kernels/clang_repl_cpp17
  clang_repl_cpp20    /home/callisto/.cache/pypoetry/virtualenvs/jupyter-cp9TDEDI-py3.13/share/jupyter/kernels/clang_repl_cpp20
  clang_repl_cpp23    /home/callisto/.cache/pypoetry/virtualenvs/jupyter-cp9TDEDI-py3.13/share/jupyter/kernels/clang_repl_cpp23
  deno                /home/callisto/.cache/pypoetry/virtualenvs/jupyter-cp9TDEDI-py3.13/share/jupyter/kernels/deno
  python3             /home/callisto/.cache/pypoetry/virtualenvs/jupyter-cp9TDEDI-py3.13/share/jupyter/kernels/python3

Il est nécessaire de déplacer le noyau dans l'environnement virtuel qui n'a pas été pris en compte (comme pour deno).

mv /home/callisto/.local/share/jupyter/kernels/java /home/callisto/.cache/pypoetry/virtualenvs/jupyter-cp9TDEDI-py3.13/share/jupyter/kernels

5.4.4 Extensions

La version 3 de jupyterlab permet d'ajouter les extensions depuis l'interface web. Pour que les usagers puissent ajouter leurs extensions il est nécessaire d'avoir le droit d'écriture dans le dossier jupyter/labextensions, par construction les permissions de ce dossier permettent à tous les usagers du groupe jupyterhub d'écrire ce qui permet un fonctionnement direct. En cas de problème vérifier les permissions de ce dossier.

6. Activation des accès aux périphériques

6.1 Accès au GPIO

6.1.1 Configuration globale du GPIO

Pour un fonctionnement sécurisé permettant l'accès de plusieurs utilisteurs au bus GPIOsans privilèges particuliers il est nécessaire d'opérer certaines modifications donnant à un utilisateur ordinaire membre du groupe gpiole droit d'accéder aux ressources connectées au bus GPIO. On rajoute le fichier 50-gpio.rules au répertoire /etc/udev/rules.d avec la commande ci-dessous et on ajoute le contenu suivant (on termine avec Ctrl-D):

sudo su
cat >  /etc/udev/rules.d/50-gpio.rules
SUBSYSTEM=="gpio*", PROGRAM="/bin/sh -c 'chown -R root:gpio /sys/class/gpio && chmod -R 770 /sys/class/gpio; \
chown -R root:gpio /sys/devices/platform/soc/3f200000.gpio && chmod -R 770 /sys/devices/platform/soc/3f200000.gpio; \
chown -R root:gpio /sys/bus/platform/drivers/pinctrl-bcm2835 && chmod -R 770 /sys/bus/platform/drivers/pinctrl-bcm2835 '"

SUBSYSTEM=="bcm2835-gpiomem", KERNEL=="gpiomem", GROUP="gpio", MODE="0660"
SUBSYSTEM=="gpio", KERNEL=="gpiochip*", ACTION=="add", \
PROGRAM="/bin/sh -c 'chown root:gpio /sys/class/gpio/export /sys/class/gpio/unexport ; \
chmod 220 /sys/class/gpio/export /sys/class/gpio/unexport'"

SUBSYSTEM=="gpio", KERNEL=="gpio*", ACTION=="add", PROGRAM="/bin/sh -c \
'chown root:gpio /sys%p/active_low /sys%p/direction /sys%p/edge /sys%p/value ; \
chmod 660 /sys%p/active_low /sys%p/direction /sys%p/edge /sys%p/value'"

Dans la version actuelle les dossiers virtgpio ont disparu, les documentations précisent qu'une modification a été faite dans l'organisation de la configuration rendant obsolète les commandes suivantes, elles sont reprises ici en cas d'évolution du système.

chown -R root:gpio /sys/devices/virtual/gpio && chmod -R 770 /sys/devices/virtual/gpio; \
chown -R root:gpio /sys/devices/platform/soc/soc:virtgpio && chmod -R 770 /sys/devices/platform/soc/soc:virtgpio; \

6.1.2 Ajout du bus SPI

Pour l'utilisation du SPI Le fichier 50-gpio.rules doit être modifié il prend la forme suivante :

SUBSYSTEM=="gpio*", PROGRAM="/bin/sh -c 'chown -R root:gpio /sys/class/gpio && chmod -R 770 /sys/class/gpio; \
chown -R root:gpio /sys/devices/platform/soc/fe200000.gpio && chmod -R 770 /sys/devices/platform/soc/fe200000.gpio; \
chown -R root:gpio /sys/bus/platform/drivers/pinctrl-bcm2835 && chmod -R 770 /sys/bus/platform/drivers/pinctrl-bcm2835 '"

SUBSYSTEM=="spidev*", PROGRAM="/bin/sh -c 'chown -R root:gpio /sys/class/spidev && chmod -R 770 /sys/class/spidev; \
chown -R root:gpio /sys/devices/platform/soc/fe204000.spi/spi_master/spi0/spi0.0/spidev && \
chmod -R 770 /sys/devices/platform/soc/fe204000.spi/spi_master/spi0/spi0.0/spidev; \
chown -R root:gpio /dev/spidev0.0  && chmod -R 770 /dev/spidev0.0'"

SUBSYSTEM=="bcm2835-gpiomem", KERNEL=="gpiomem", GROUP="gpio", MODE="0660"
SUBSYSTEM=="gpio", KERNEL=="gpiochip*", ACTION=="add", \
PROGRAM="/bin/sh -c 'chown root:gpio /sys/class/gpio/export /sys/class/gpio/unexport ; \
chmod 220 /sys/class/gpio/export /sys/class/gpio/unexport'"

SUBSYSTEM=="gpio", KERNEL=="gpio*", ACTION=="add", PROGRAM="/bin/sh -c \
'chown root:gpio /sys%p/active_low /sys%p/direction /sys%p/edge /sys%p/value ; \
chmod 660 /sys%p/active_low /sys%p/direction /sys%p/edge /sys%p/value'"

Même remarque que ci-dessus pour le virtgpio.

chown -R root:gpio /sys/devices/virtual/gpio && chmod -R 770 /sys/devices/virtual/gpio; \
chown -R root:gpio /sys/devices/platform/soc/soc:virtgpio && chmod -R 770 /sys/devices/platform/soc/soc:virtgpio; \

On modifie aussi la ligne de commande dans /boot/firmware/cmdline.txt en ajoutant en fin de ligne spidev.bufsiz=32768 et enfin on ajoute l'activation du bus SPI et le contrôle de la fréquence dans le fichier /boot/config.txt pour contrôler un rubande leds librairie rpi_ws281x

dtparam=spi=on # activation du bus SPI
# to use SPI for ledstrip
core_freq_min=500 # pour la raspi4
# core_freq=250 # pour la pi3

Attention aux conflits en activant le bus SPI

6.2 Accès à l'USB

Tout comme le GPIO l'USB n'est pas accessible aux utilisateurs de base. Par exemple quand il existe l'utilsateur weewx est un utilisateur non privilégié qui doit pouvoir accéder à la station via une interface USB. Pour y parvenir on ajoute au même endroit le fichier 40-usbweewx.rules avec la commande ci-dessous. Il suffit d'adapter cet exemple a tout utilisateur et tout appareil connecté à l'USB.

cat >  /etc/udev/rules.d/40-usbweewx.rules

on ajoute le contenu suivant avec les informations issues de la console connectée (idVendor et IdProduct) :

# make any te923 station connected via usb accessible to non-root
SUBSYSTEM=="usb", ATTR{idVendor}=="1130", ATTR{idProduct}=="6801", ACTION=="add", GROUP="weewx", MODE="0664"

# make any Vantage Pro2 station connected via usb accessible to non-root
#SUBSYSTEM=="usb", ATTR{idVendor}=="10c4", ATTR{idProduct}=="ea60", ACTION=="add", GROUP="weewx", MODE="0664"

6.3 Accès à la caméra

L'activation de la caméra se passe en deux étapes car par défaut la détection de la caméra n'est pas activée, cette situation est probablement due à la volonté de ne pas "gaspiller les ressources limitées de la Raspberry. Dans cette optique il est conseillé de n'activer la caméra qu'uniquement quand on va l'utiliser car contrairement à d'autres fonctionnalités celle ci immobilise des ressources notamment de la mémoire.

6.3.1 Détection de la caméra

Pour détecter la camera il est nécesaire de modifier la configuration du fichier de boot mais ce dernier est reconstruit avec les autres fichiers de configuration du boot :

/etc/default/raspi-firmware
/etc/default/raspi-firmware-custom
/etc/default/raspi-extra-cmdline

Pour le moment nous avons seulement modifié directement le fichier config.txt comme indiqué ci-dessous. La procédure n'a pas été testée avec la une cam mais la répartitionde mémoire a fonctionné : passage de 943 Mo à 843 Mo.

La fin du fichier est recopiée ci-dessous.

gpu_mem=16
initramfs initramfs-4.13.16-v7 followkernel
dtparam=i2c_arm=on
dtparam=spi=on

La modifier pour lui donner l'aspect suivant

initramfs initramfs-4.13.16-v7 followkernel
dtparam=i2c_arm=on
dtparam=spi=on

gpu_mem=16 # Comment this line when activating the camera to provide more memory
# camera activation
# To activate camera at least uncomment the two following lines
# AND comment the line above gpu_mem=16
#
#start_x=1             # essential
#gpu_mem=128           # at least, or maybe more if you wish
#

Pour activer la camera il faut commenter la ligne gpu_mem=16 et décommenter les deux lignes start_x=1 et gpu_mem=128 puis impérativement rebooter. Une fois le reboot effectué si la caméra est connectée elle apparait aux côtés des autres périphériques sous le nom /dev/vchiq

6.3.2 Ajout des logiciels de pilotage de la caméra

La caméra et le module de pilotage sont alignés sur les modules standard de la distribution Debian dont v4l2. Plusieurs paquets fournissent des librairies et des outils qui permettent d'interagir avec les Picaméras. Il existe de nombreux modèles avec des compatibilités variées suivant les modèles de raspberryPi, choisir avec attention sa caméra.

Les paquets debian suivants ont été installés (non testés)

sudo apt install libcamera-tools libcamera-v4l2
sudo apt install v4l-utils uvcdynctrl ustreamer qv4l2 megapixels libwebcam0

Il existe une librairie python fournissant des applications d'interface avec les cameras des raspberryPi. Elle est en version beta mais est installable en suivant cette procédure (la doc dit qu'il existe un paquet debian mais il est introuvable)

sudo apt install libcap-dev
mkdir Logiciels/Camera
cd Logiciels/Camera
wget https://datasheets.raspberrypi.com/camera/picamera2-manual.pdf
wget https://github.com/raspberrypi/picamera2/archive/refs/tags/v0.3.36.tar.gz
tar xvfz v0.3.36.tar.gz
cd picamera2-0.3.36
poetry lock
poetry update
`poetry env activate`

6.4 Installation d'un simulateur graphique de réseau

Le logiciel filius est répandu dans l'éducationale, il ne fournit pas les fonctions avancées de quelques autres outils professionnels mais permet d'effectuer un grand nombre de manipulations. Il est installé par la méthode ordinaire d'installation des paquets, le nombre de dépendances est toutefois important.

sudo apt install filius

6.5 Installation de Snap!BYOB

Jupyter est un outil très performant pour un apprentissage progressif du codage mais il ne s'adresse pas à des novices absolus. Le logiciel Snap!BYOB est un outil de programmation graphique par blocs plus puissant que Scratch qui permet une introduction à la programmation. Comme Jupyter il propose ue interface web que la Raspberry fournit sans problème. Pour installer Snap télécharger le code depuis github.

cd
mkdir Logiciels/Snap
cd !$
git clone https://github.com/jmoenig/Snap.git --single-branch
sudo cp -r Snap /opt
sudo ln -s /opt/Snap /var/www/html/snap

Attention taille du transfert > 1.5 Go.

Snap!BYOB est maintenant directement accessible sur le serveur web de la Raspberry Pi http://$$$.$$$.$$$.$$$/snap

Le serveur web doit être configuré (test à réaliser)

6.6 Installation de Domoticz pour piloter des objets connectés du commerce

cd
mkdir Logiciels/Domoticz
cd !$
wget https://github.com/domoticz/domoticz/releases/download/2026.1/domoticz_linux_aarch64.tgz
tar xvfz domoticz_linux_aarch64.tgz
sudo apt install libusb-0.1-4 libmosquitto1

Le serveur web doit être configuré (test à réaliser)

Pour créer le service domotique et qu'il puisse démarrer seul ajouter le fichier /etc/systemd/system/domoticz.service :

sudo nano /etc/systemd/system/domoticz.service
#ajouter le contenu suivant
[Unit]
Description=domoticz_service

[Service]
User=domotic
Group=domotic
WorkingDirectory=/opt/Domoticz
ExecStart=/opt/Domoticz/domoticz -www 8080 -sslwww 0  -wwwbind 192.168.10.212
#ExecStartPre=setcap 'cap_net_bind_service=+ep' /opt/Domoticz/domoticz
Restart=on-failure
RestartSec=1m
#StandardOutput=null

[Install]
WantedBy=multi-user.target

Déplacer le contenu durépertoire dans /opt/Domoticz et modifier les droits d'accès :

cd 
cd Logiciels/Domoticz/domoticz
sudo mkdir /opt/Domoticz
sudo cp -r ./* /opt/Domoticz/
sudo chown -R domotic.domotic /opt/Domoticz/
sudo chmod -R g+rwX /opt/Domoticz/

6.7 Ajout de scripts pour démarrer ou supprimer un service au démarrage

Un certain nombre de services ont été mis en place lors des étapes précédentes et cette logique peut-être étendue à à peu près tous les services installés. Il faut créer un fichier de service dans /etc/systemd/system portant une extension .service avec la syntaxe suivante (exemple jupyterhub):

[Unit]
Description=JupyterHub
After=syslog.target network.target traefik.target

[Service]
User=callisto
WorkingDirectory=/home/callisto/Jupyterhub
Environment="PATH=/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/home/callisto/.cache/pypoetry/virtualenvs/jupyter-cp9TDEDI-py3.13/bin"
ExecStart=/home/callisto/.cache/pypoetry/virtualenvs/jupyter-cp9TDEDI-py3.13/bin/jupyterhub -f /home/callisto/Jupyterhub/Utils/jupyterhub_config.py

[Install]
WantedBy=multi-user.target

6.8 Ajout d'un media-center

La raspberryPi peut aussi être utilisée en media-center pour y parvenir il suffit de disposer d'une bibliothèque de médias accessibles depuis la raspberry et du logiciel kodi. La manipulation du media-center se fait via l'interface intuitive de kodi. Le cœur du logiciel a été installé il dispose nombreuses extensions qui peuvet être ajoutées par des paquets debian.

Pour installer :

sudo apt install kodi kodi-bin kodi-data

6.9 Installation et configuration d'un pare-feu

La Raspberry va être exposée sur le net il est important d'être attentifs à la sécurité de cette machine. Une première méthode est de mettre en place un pare-feu mais cette opération est délicate et difficile à faire à la main; nous utiliserons donc un logiciel d'asssitance à la création de pare-feu nftables. Ce logiciel permet d'établir des règles de filtrage avec une syntaxe (relativement) intelligible dans un fichier de configuration, il se charge ensuite de construire et activer les règles de filtrage correspondant aux instructions de l'usager. L'installation du paquet se fait avec la procédure habituelle.

sudo apt install nftables

Par défaut le service est désactivé et le fichier de configuration totalement permissif. Pour activer nftables au démarrage par défaut:

sudo systemctl enable nftables.service

Le fichier de configuration se trouve ici. À titre d'exemple la configuration du pare-feu pour le projet tremplin est proposée ci-dessous afin de permettre le fonctionnement à minima du pare-feu. Il doit être configuré avec les paramètres locaux de l'usager, si la configuration ne correspond pas à l'environnement réseau de la Raspberry cette dernière peut devenir inaccessible ! Soyez prudents. En cas de problème il est toujours possible d'accéder au contenu de la microSD depuis une machine GNU/linux et de modifier le fichier de configuration; si vous êtes sous un autre système d'exploitation il est possible de démarrer votre ordinateur en utilisant une clef USB GNU/linux live qui fournit un ordinateur opérationnel sans rien toucher de ce qui est installé par exemple debian live.

Exemple de fichier de configuration nftables.conf (les *** doivent être remplacés par les valeurs du réseau local où est installée la _raspberryPi).

#!/usr/sbin/nft -f

flush ruleset

table inet filter {
        set ALLOWED_SSH {
        type ipv4_addr
        flags interval
        # Institution : ***.***.***.0/24
        # Individual : ***.***.***.***  
        # Internal : ***.***.***.0/24, ***.***.***.0/23
        # outbound : ***.***.***.*** 
        elements = {
            ***.***.***.0/24, \
            ***.***.***.***, \
            ***.***.***.0/24, ***.***.***.0/23, \
            ***.***.***.*** 
        }
    }

    chain input {
        type filter hook input priority 0;
        policy drop;
        # established/related connections
        ct state established,related accept
        # invalid connections
        ct state invalid drop
        # loopback interface
        iif lo accept
        # ICMP & IGMP
        ip protocol icmp icmp type { echo-request, echo-reply, destination-unreachable, router-solicitation, router-advertisement, time-exceeded, parameter-problem } accept
        ip protocol igmp accept
        # SSH (port #####)
        tcp dport ##### ip saddr @ALLOWED_SSH accept
        # HTTP (ports 80, #####, #####:#####)
        tcp dport { http, https } accept
        # HTTPS (ports 443, #####)
        tcp dport { https, ##### } accept
        # mysql
        tcp dport ##### accept
        # email
        tcp dport { 25, 587 } accept        
    }
    chain forward {
        type filter hook forward priority 0;
        policy drop;
    }
    chain output {
        type filter hook output priority 0;
        policy accept;
    }
}

6.10 Ajout des cahiers de programmes pour apprendre/enseigner la programmation (À tester vérifier augmenter)

le projet Tremplin des Sciences a fourni une variété de cahiers de programmes disponibles sur la forge github. Ils peuvent être téléchargés et exécutés depuis le serveur jupyterhub de la raspberryPi.

moon est l'utilisateur lambda de la raspberryPi, il est utilisé à titre d'exemple ici.

sudo su moon
cd
git clone http://vidal@depot.tremplin.ens-lyon.fr/Tremplin-des-Sciences/CahiersDeProgrammesCodage
git clone http://vidal@depot.tremplin.ens-lyon.fr/Tremplin-des-Sciences/CahiersDeProgrammesClimat

6.11 Organisation des services au démarrage

Tous les services et logiciels décrits ci-dessus sont opérationnels mais par défaut une partie seulement sont activés au démarrage. Il est possible de les démarrer à tout moment soit par ens-ife ou par localadm (qui dispose des droits de root via le sudo, soit en ligne de commande. Ci dessous le statut des services par défaut :

  • jupyter is set sudo systemctl enable jupyterhub
  • xrdp is set sudo systemctl enable xrdp
  • domoticz is not set sudo systemctl disable domoticz
  • nginx is set sudo systemctl enable nginx
  • kodi is not set sudo systemctl disable kodi

7. Clonage et mise à disposition

Une fois que tous les programmes souhaités sont ajoutés et toutes les options configurées les images peuvent être diffusées sous forme binaire compressée, il suffit alors à tout usager qui souhaite se les approprier de téchager le fichier et le copier sur une micro-SD qui sera immédiatement opérationnelle. Éteindre la Raspberry pi et extraire la micro-SD puis l'insérer dans un ordinateur (dans le cas ci-dessous elle apparaît sur le device /dev/mmcblk0. Copier "bit à bit" le contenu de la micro-SD sur le disque dur de l'ordinateur avec les options de maîtrise des espaces vides et le contrôle de la taille; l'image proposée dans ce blog pouvant contenir dans une micro-SD de 24 Go. Pour faciliter la copie de l'image on propose de créer le fichier bmap correspondant et de la compresser (le logiciel bmaptools traite directement les images compressées ce qui minimise les temps de téléchargement et évite le temps de décompression). La nomenclature a été définie au chapitre 3.1.

sudo dd if=/dev/mmcblk0 of=rpi3-dev-trixie64_2026-05-16.img bs=16M conv=sparse count=1200
bmaptool create -o rpi3-dev-trixie64_2026-05-16.bmap rpi3-dev-trixie64_2026-05-16.img
7z a -txz rpi3-dev-trixie64_2026-05-16.img.xz rpi3-dev-trixie64_2026-05-16.img

Les usagers devront télécharger les deux fichiers rpi3-dev-trixie64_2026-05-16.img.xz et rpi3-dev-trixie64_2026-05-16.bmap et utiliser ensuite bmaptool pour la recopier sur une micro-SD vierge :

sudo bmaptool copy --bmap rpi3-dev-trixie64_2026-05-16.bmap rpi3-dev-trixie64_2026-05-16.img.xz /dev/mmcblk0

Une fois la copie terminée la micro-SD est immédiatement opérationnelle.

Webographie

  1. Site principal Raspberry Pi
  2. Scripts de création de l'image
  3. Image Debian Live
  4. Comment créer une clef USB bootable Debian
  5. nmcli authorization management
  6. nmcli examples
  7. wpa_cli configuration

Comments !