Mise en Place et Utilisation de Rust Hors Ligne pour un Développement Sans Faille : Un Tutoriel Étape par Étape

C’est un processus simple de mettre en place Rust lorsque vous avez accès à Internet, mais que se passe-t-il si vous êtes hors ligne?

Rust est un langage de programmation exceptionnel. Il est soutenu par une vaste gamme d’outils qui constituent la chaîne d’outils Rust. L’outil Rustup gère la chaîne d’outils de développement, tandis que Cargo gère l’environnement de build. Ces outils sont très intuitifs et conviviaux.

La chaîne d’outils Rust peut être rapidement mise en place. Vous pouvez le faire à l’aide d’une simple commande Rustup. cette command télécharge automatiquement tous les outils de développement nécessaires. De même, Cargo récupère les dépendances et compile les crates sans aucune difficulté.

Cependant, il n’est pas rare que les développeurs Rust travaillent hors ligne. Cela est particulièrement vrai dans les entreprises qui appliquent des mesures de sécurité strictes limitant l’accès à l’internet sur les machines de développement.

Dans de telles situations, Rustup et Cargo peuvent ne pas fonctionner correctement. Par conséquent, les développeurs concernés devront installer l’environnement de développement Rust et gérer les dépendances en toute sécurité sans accès à l’Internet.

Cet article de blog est un guide complet pour les développeurs Rust. Il est conçu pour ceux qui travaillent dans des environnements où l’accès à Internet est restreint ou inexistant. L’objectif est de garantir qu’ils puissent poursuivre leur travail de manière efficace.

​

Mise en place d’un environnement de développement Rust hors ligne - Localement

Cette section explique la configuration locale de l’environnement de développement. Pour la configuration à l’aide de conteneurs Docker de développement, rendez-vous à la section suivante ci-dessous.

Pour mettre en place un environnement de développement Rust hors ligne, vous devez obtenir, transférer et installer 2 fichiers sur votre machine de développement hors ligne :

• Installateur autonome de Rust qui inclut le code de la chaîne d’outils Rust précompilé et prêt à être installé.
• Installateur rustup-init qui installe le programme rustup.

Rustup est principalement conçu pour gérer plusieurs versions de Rust installées sur le même hôte. Cela est très utile lorsque vous devez passer d’un projet à un autre qui nécessite différentes versions de Rust. De plus, il s’avère être un outil utile pour expérimenter avec les versions plus récentes de Rust.

​

Étape 1 : Télécharger les fichiers nécessaires sur un ordinateur de confiance ayant un accès à l’internet

Commencez par télécharger les fichiers nécessaires sur un ordinateur connecté à Internet.

1. Téléchargez l’Installateur Autonome Rust : Obtenez l’installateur autonome Rust adapté à l’architecture de votre ordinateur de développement cible ici.
   Par exemple, vous pouvez choisir de télécharger l’installateur autonome Rust x86_64-unknown-linux-gnu pour x86_64 Linux.
   Si vous avez besoin d’une version spécifique de Rust, vous pouvez modifier la version dans l’URL de téléchargement.
   En option, vous pouvez vérifier l’authenticité de l’installateur en vérifiant la signature GPG à l’aide du fichier ‘.asc’ correspondant.

2. Téléchargez rustup-init : Téléchargez rustup-init conçu pour l’architecture de votre ordinateur de développement cible ici.
   Gardez à l’esprit que rustup-init fonctionne de manière indépendante de la version spécifique de Rust que vous avez l’intention d’installer. Sa principale fonction est de gérer plusieurs versions de la chaîne d’outils Rust.
   En option, vous pouvez vérifier l’intégrité du fichier téléchargé en comparant sa somme de contrôle sha256 avec le fichier sha256 correspondant.

 1############################
 2# Constantes configurables #
 3############################
 4# Définir les variables pour la triple cible sélectionnée, ainsi que la version de Rust
 5VERSION_RUST="1.73.0"
 6ARCHITECTURE_DISTRO="x86_64-unknown-linux-gnu"
 7# Définir le dossier de téléchargement
 8DOSSIER_TELECHARGEMENT="${HOME}/Téléchargements/rust-hors-ligne"
 9
10#############
11# Principal #
12#############
13# Définir les URL de téléchargement
14fichier_installeur_rust_autonome="rust-${VERSION_RUST}-${ARCHITECTURE_DISTRO}.tar.gz"
15url_installeur_rust_autonome="https://static.rust-lang.org/dist/${fichier_installeur_rust_autonome}"
16fichier_rustup_init="rustup-init"
17url_rustup_init="https://static.rust-lang.org/rustup/dist/${ARCHITECTURE_DISTRO}/${fichier_rustup_init}"
18
19# Assurez-vous que le dossier de téléchargement existe
20test -d ${DOSSIER_TELECHARGEMENT} || mkdir -p ${DOSSIER_TELECHARGEMENT}
21
22# Télécharger l'installateur autonome Rust
23wget -P ${DOSSIER_TELECHARGEMENT} ${url_installeur_rust_autonome}
24# Alternativement, 'curl' peut être utilisé comme suit :
25# cd ${DOSSIER_TELECHARGEMENT}; curl --remote-name ${url_installeur_rust_autonome}; cd -
26
27# Télécharger Rustup-init
28wget -P ${DOSSIER_TELECHARGEMENT} ${url_rustup_init}
29# Alternativement, 'curl' peut être utilisé comme suit :
30# cd ${DOSSIER_TELECHARGEMENT}; curl --remote-name ${url_rustup_init}; cd -
31
32############################
33# Vérification facultative #
34############################
35# Il est également possible de vérifier que les fichiers téléchargés 
36# n'ont pas été corrompus lors du téléchargement.
37# Cela peut être fait en utilisant le fichier de hachage SHA 
38# et le fichier de signature GPG disponibles sur les pages de téléchargement.

 1############################
 2# Constantes configurables #
 3############################
 4# Définir les variables pour la triple cible sélectionnée, ainsi que la version de Rust
 5$VERSION_RUST="1.73.0"
 6$ARCHITECTURE_DISTRO="x86_64-pc-windows-gnu"
 7# Définir le dossier de téléchargement
 8$DOSSIER_TELECHARGEMENT="${env:USERPROFILE}\Téléchargements\rust-hors-ligne"
 9
10#############
11# Principal #
12#############
13# Définir les URL de téléchargement
14$fichier_installeur_rust_autonome="rust-${VERSION_RUST}-${ARCHITECTURE_DISTRO}.msi"
15$url_installeur_rust_autonome="https://static.rust-lang.org/dist/${fichier_installeur_rust_autonome}"
16$fichier_rustup_init="rustup-init.exe"
17$url_rustup_init="https://static.rust-lang.org/rustup/dist/${ARCHITECTURE_DISTRO}/${fichier_rustup_init}"
18
19# Assurez-vous que le dossier de téléchargement existe
20if (!(Test-Path ${DOSSIER_TELECHARGEMENT} -PathType Container)) {
21    New-Item -ItemType Directory -Force -Path ${DOSSIER_TELECHARGEMENT}
22}
23
24# Télécharger l'installateur autonome Rust
25wget ${url_installeur_rust_autonome} -OutFile ${DOSSIER_TELECHARGEMENT}\${fichier_installeur_rust_autonome}
26
27# Télécharger Rustup-init
28wget ${url_rustup_init} -OutFile ${DOSSIER_TELECHARGEMENT}\${fichier_rustup_init}
29
30############################
31# Vérification facultative #
32############################
33# Il est également possible de vérifier que les fichiers téléchargés
34# n'ont pas été corrompus lors du téléchargement.
35# Cela peut être fait en utilisant le fichier de hachage SHA
36# et le fichier de signature GPG disponibles sur les pages de téléchargement.

 1::::::::::::::::::::::::::::::
 2:: Constantes configurables ::
 3::::::::::::::::::::::::::::::
 4:: Définir les variables pour la triple cible sélectionnée, ainsi que la version de Rust
 5SET "VERSION_RUST=1.73.0"
 6SET "ARCHITECTURE_DISTRO=x86_64-pc-windows-gnu"
 7:: Définir le dossier de téléchargement
 8SET "DOSSIER_TELECHARGEMENT=%USERPROFILE%\Téléchargements\rust-hors-ligne"
 9
10:::::::::::::::
11:: Principal ::
12:::::::::::::::
13:: Définir les URL de téléchargement
14SET "fichier_installeur_rust_autonome=rust-%VERSION_RUST%-%ARCHITECTURE_DISTRO%.msi"
15SET "url_installeur_rust_autonome=https://static.rust-lang.org/dist/%fichier_installeur_rust_autonome%"
16SET "fichier_rustup_init=rustup-init.exe"
17SET "url_rustup_init=https://static.rust-lang.org/rustup/dist/%ARCHITECTURE_DISTRO%/%fichier_rustup_init%"
18
19:: Assurer que le dossier de téléchargement existe
20IF NOT EXIST %DOSSIER_TELECHARGEMENT% (mkdir %DOSSIER_TELECHARGEMENT%)
21
22:: Télécharger l'installateur autonome Rust
23curl %url_installeur_rust_autonome% --output %DOSSIER_TELECHARGEMENT%\%fichier_installeur_rust_autonome%
24
25:: Télécharger Rustup-init
26curl %url_rustup_init% --output %DOSSIER_TELECHARGEMENT%\%fichier_rustup_init%
27
28::::::::::::::::::::::::::::::
29:: Vérification facultative ::
30::::::::::::::::::::::::::::::
31:: Il est également possible de vérifier que les fichiers téléchargés
32:: n'ont pas été corrompus lors du téléchargement. 
33:: Cela peut être fait en utilisant le fichier de hachage SHA
34:: et le fichier de signature GPG disponibles sur les pages de téléchargement.

​

Étape 2 : Copiez en toute sécurité les fichiers téléchargés sur l’ordinateur de développement hors ligne

Maintenant, transférez en toute sécurité ces 2 fichiers téléchargés vers l’ordinateur de développement hors ligne via :

• Des transfert de fichiers géré (MFT).
• Des dispositifs de stockage de données tels que des clés USB.
• Des drives partagés.
• Tout autre moyen disponible.

​

Étape 3 : Installer la chaîne d’outils Rust

Avec les fichiers sur votre ordinateur de développement hors ligne, vous pouvez installer la chaîne d’outils Rust à l’aide des commandes scriptées suivantes.

Pour continuer, sélectionnez l’onglet correspondant au système d’exploitation de votre ordinateur de développement cible.

 1############################
 2# Constantes configurables #
 3############################
 4# Définir les variables pour la triple cible sélectionnée, ainsi que la version de Rust
 5VERSION_RUST="1.73.0"
 6ARCHITECTURE_DISTRO="x86_64-unknown-linux-gnu"
 7# Définir le chemin du fichier d'installation autonome Rust copié
 8DOSSIER_FICHIERS_COPIES="${HOME}/Téléchargements/rust-hors-ligne"
 9# Définir le dossier d'installation (le chemin d'installation par défaut est /usr/local)
10DOSSIER_INSTALLATION_AUTONOME="${HOME}/rust-installation/rust-${VERSION_RUST}-${ARCHITECTURE_DISTRO}"
11# Définir le nom de la chaîne d'outils Rust installée
12NOM_CHAINE_OUTILS_RUST="rust-toolchain-${VERSION_RUST}"
13
14#############
15# Principal #
16#############
17fichier_archive=${DOSSIER_FICHIERS_COPIES}/rust-${VERSION_RUST}-${ARCHITECTURE_DISTRO}.tar.gz
18dossier_extraction_archive=${DOSSIER_FICHIERS_COPIES}/rust-${VERSION_RUST}-${ARCHITECTURE_DISTRO}
19
20# Extraire l'archive de l'installateur autonome Rust
21tar -xzf ${fichier_archive} -C ${DOSSIER_FICHIERS_COPIES}
22
23# Exécuter le script d'installation
24# (pour voir les arguments d'installation personnalisés, appelez le script d'installation avec l'option : '--help')
25${dossier_extraction_archive}/install.sh --prefix=${DOSSIER_INSTALLATION_AUTONOME}
26
27# Supprimer le dossier extrait (nettoyage)
28rm -r ${dossier_extraction_archive}

 1############################
 2# Constantes configurables #
 3############################
 4# Définir les variables pour la triple cible sélectionnée, ainsi que la version de Rust
 5${VERSION_RUST}="1.73.0"
 6${ARCHITECTURE_DISTRO}="x86_64-pc-windows-gnu"
 7# Définir le chemin du fichier d'installation autonome Rust copié
 8${DOSSIER_FICHIERS_COPIES}="${env:USERPROFILE}\Téléchargements\rust-hors-ligne"
 9# Définir le dossier d'installation parent
10${DOSSIER_INSTALLATION_AUTONOME_PARENT}="${env:USERPROFILE}\rust-install\rust-${VERSION_RUST}-${ARCHITECTURE_DISTRO}"
11# Définir le dossier d'installation
12${DOSSIER_INSTALLATION_AUTONOME}="${DOSSIER_INSTALLATION_AUTONOME_PARENT}\Rust"
13# Définir le nom de la chaîne d'outils Rust installée
14${NOM_CHAINE_OUTILS_RUST}="rust-toolchain-${VERSION_RUST}"
15
16#############
17# Principal #
18#############
19${fichier_msi}="${DOSSIER_FICHIERS_COPIES}\rust-${VERSION_RUST}-${ARCHITECTURE_DISTRO}.msi"
20
21# Exécuter le script d'installation (il ne l'installe pas vraiment sur le système mais l'extrait simplement)
22msiexec /a "${fichier_msi}" /qb TARGETDIR="${DOSSIER_INSTALLATION_AUTONOME_PARENT}"

 1::::::::::::::::::::::::::::::
 2:: Constantes configurables ::
 3::::::::::::::::::::::::::::::
 4:: Définir les variables pour la triple cible sélectionnée, ainsi que la version de Rust
 5SET "VERSION_RUST=1.73.0"
 6SET "ARCHITECTURE_DISTRO=x86_64-pc-windows-gnu"
 7:: Définir le chemin du fichier d'installation autonome Rust copié
 8SET "DOSSIER_FICHIERS_COPIES=%USERPROFILE%\Téléchargements\rust-hors-ligne"
 9:: Définir le dossier d'installation
10SET "DOSSIER_INSTALLATION_AUTONOME_PARENT=%USERPROFILE%\rust-install\rust-%VERSION_RUST%-%ARCHITECTURE_DISTRO%"
11:: Définir le dossier d'installation
12SET "DOSSIER_INSTALLATION_AUTONOME=%DOSSIER_INSTALLATION_AUTONOME_PARENT%\Rust"
13:: Définir le nom de la chaîne d'outils Rust installée
14SET "NOM_CHAINE_OUTILS_RUST=rust-toolchain-%VERSION_RUST%"
15
16:::::::::::::::
17:: Principal ::
18:::::::::::::::
19SET "fichier_msi=%DOSSIER_FICHIERS_COPIES%\rust-%VERSION_RUST%-%ARCHITECTURE_DISTRO%.msi"
20
21:: Exécuter le script d'installation (il ne l'installe pas vraiment sur le système mais l'extrait simplement)
22msiexec /a "%fichier_msi%" /qb TARGETDIR="%DOSSIER_INSTALLATION_AUTONOME_PARENT%"

Ces commandes scriptées installent la chaîne d’outils Rust dans un dossier sans modifier le PATH du système. Ceci est crucial pour éviter toute interférence avec Rustup dans le futur.

Rustup s’assure que la version de la chaîne d’outils sélectionnée est disponible dans le PATH du système.

Dans la prochaine étape, vous apprendrez comment gérer la chaîne d’outils Rust installée avec Rustup.

​

Étape 4: Gérez la chaîne d’outils Rust avec Rustup

Maintenant que vous avez installé la chaîne d’outils Rust, il est temps de la gérer à l’aide de Rustup. Tout d’abord, assurez-vous que Rustup est installé.

​

I. Installez Rustup

Si vous n’avez pas encore installé Rustup, suivez ces instructions pour l’installer à l’aide du programme d’installation rustup-init téléchargé.

Notez que le processus d’installation nécessite la gestion de 2 répertoires :

• Le répertoire des paramètres Rustup (qui est par défaut .rustup dans le répertoire personnel de votre utilisateur).
• Le répertoire des paramètres Cargo et des mandataires de chaîne d’outils (qui est par défaut .cargo dans le répertoire personnel de votre utilisateur).

Vous pouvez modifier le répertoire d’installation de Rustup en définissant la variable d’environnement RUSTUP_HOME lors de l’installation. De même, vous pouvez modifier le répertoire des paramètres Cargo et des mandataires de chaîne d’outils en définissant la variable d’environnement CARGO_HOME lors de l’installation.

Pour continuer, sélectionnez l’onglet correspondant au système d’exploitation de développement cible.

 1# XXX: Utiliser les mêmes "constantes configurables" que dans les scripts de l'étape 3.
 2
 3# S'assurer que rustup-init est exécutable
 4chmod +x ${DOSSIER_FICHIERS_COPIES}/rustup-init
 5# Exécutez le script d'installation
 6# Exécutez-le avec la chaîne d'outils par défaut définie sur `none` afin qu'aucun téléchargement ne soit tenté. 
 7# L'option '-y' est utilisée pour exécuter en mode batch (non interactif).
 8# Cela installera `rustup` et configurera les mandataires dans le dossier `${CARGO_HOME}/bin`.
 9${DOSSIER_FICHIERS_COPIES}/rustup-init --default-toolchain none -y
10
11# Pour configurer le PATH du système pour la session de terminal en cours :
12source ${CARGO_HOME:-${HOME}/.cargo}/env

1# XXX: Utiliser les mêmes "constantes configurables" que dans les scripts de l'étape 3.
2
3# Exécutez le script d'installation
4# Exécutez-le avec la chaîne d'outils par défaut définie sur `none` afin qu'aucun téléchargement ne soit tenté. 
5# L'option '-y' est utilisée pour exécuter en mode batch (non interactif).
6# Cela installera `rustup` et configurera les mandataires dans le dossier `${CARGO_HOME}\bin`.
7&${DOSSIER_FICHIERS_COPIES}\rustup-init.exe --default-toolchain none -y 
8
9# Vous devrez redémarrer le Shell afin de recharger la variable d'environnement PATH.

1:: XXX: Utiliser les mêmes "constantes configurables" que dans les scripts de l'étape 3.
2
3:: Exécutez le script d'installation
4:: Exécutez-le avec la chaîne d'outils par défaut définie sur `none` afin qu'aucun téléchargement ne soit tenté. 
5:: L'option '-y' est utilisée pour exécuter en mode batch (non interactif).
6:: Cela installera `rustup` et configurera les mandataires dans le dossier `%CARGO_HOME%\bin`.
7%DOSSIER_FICHIERS_COPIES%\rustup-init.exe "--default-toolchain" "none" "-y"
8
9:: Vous devrez redémarrer le Shell afin de recharger la variable d'environnement PATH.

​

II. Gérez la chaîne d’outils Rust installée avec Rustup

Maintenant que vous avez Rustup installé, vous pouvez l’utiliser pour gérer la chaîne d’outils installée en tant que chaîne d’outils personnalisée. Pour gérer une nouvelle chaîne d’outils installée, suivez ces étapes simples :

1. Liez la chaîne d’outils.
2. Définissez-la comme la chaîne d’outils par défaut pour l’activer.

 1# XXX: Utiliser les mêmes "constantes configurables" que dans les scripts de l'étape 3.
 2
 3# Lier la chaîne d'outils installée à Rustup
 4# Rustup va créer un lien symbolique nommé '${NOM_CHAINE_OUTILS_RUST}' vers 
 5# le répertoire d'installation '${DOSSIER_INSTALLATION_AUTONOME}'. 
 6rustup toolchain link ${NOM_CHAINE_OUTILS_RUST} ${DOSSIER_INSTALLATION_AUTONOME}
 7
 8# Définir la chaîne d'outils comme par défaut
 9rustup default ${NOM_CHAINE_OUTILS_RUST}
10
11# Vérifier l'installation
12rustc --version

 1# XXX: Utiliser les mêmes "constantes configurables" que dans les scripts de l'étape 3.
 2
 3# Lier la chaîne d'outils installée à Rustup
 4# Rustup va créer un lien symbolique nommé '${NOM_CHAINE_OUTILS_RUST}' vers 
 5# le répertoire d'installation '${DOSSIER_INSTALLATION_AUTONOME}'. 
 6rustup toolchain link "${NOM_CHAINE_OUTILS_RUST}" "${DOSSIER_INSTALLATION_AUTONOME}"
 7
 8# Définir la chaîne d'outils comme par défaut
 9rustup default "${NOM_CHAINE_OUTILS_RUST}"
10
11# Vérifier l'installation
12rustc --version

 1:: XXX: Utiliser les mêmes "constantes configurables" que dans les scripts de l'étape 3.
 2
 3:: Lier la chaîne d'outils installée à Rustup
 4:: Rustup va créer un lien symbolique nommé '%NOM_CHAINE_OUTILS_RUST%' vers 
 5:: le répertoire d'installation '%DOSSIER_INSTALLATION_AUTONOME%'. 
 6rustup toolchain link "%NOM_CHAINE_OUTILS_RUST%" %DOSSIER_INSTALLATION_AUTONOME%
 7
 8:: Définir la chaîne d'outils comme par défaut
 9rustup default "%NOM_CHAINE_OUTILS_RUST%"
10
11:: Vérifier l'installation
12rustc --version

​

Configuration de l’environnement de développement Rust hors ligne - Utilisation de conteneurs Docker de développement

Cette section explique comment configurer l’environnement de développement à l’aide de conteneurs Docker de développement. Pour une configuration locale, consultez la section précédente ci-dessus.

La condition préalable est que Docker soit installé sur l’ordinateur de développement hors ligne.

Pour travailler avec le conteneur Docker de développement, vous pouvez utiliser une image Docker officielle de Rust toolchain.

Ce guide utilise l’image Docker Rust rust:1.73-bookworm à des fins d’illustration.

​

Étape 1 : Télécharger et sauvegarder l’image Docker de développement sur un ordinateur de confiance avec accès à Internet

Pour télécharger l’image Docker de développement, utilisez la commande docker pull. Ensuite, utilisez la commande docker save pour sauvegarder l’image Docker dans un fichier tar.

1docker pull rust:1.73-bookworm
2docker save -o /tmp/saved_rust_image.tar rust:1.73-bookworm

1docker pull "rust:1.73-bookworm"
2docker save -o $env:Temp\saved_rust_image.tar "rust:1.73-bookworm"

1docker pull rust:1.73-bookworm
2docker save -o %Temp%\saved_rust_image.tar rust:1.73-bookworm

​

Étape 2 : Copier de manière sécurisée l’image Docker de développement téléchargée vers l’ordinateur de développement hors ligne

Cela peut être fait comme mentionné dans la section ci-dessus.

​

Étape 3 : Charger l’image Docker de développement copiée dans Docker (sur l’ordinateur de développement hors ligne)

Sur l’ordinateur de développement hors ligne, utilisez la commande docker load pour charger l’image Docker depuis le fichier tar.

1docker load -i /tmp/saved_rust_image.tar

1docker load -i $env:Temp\saved_rust_image.tar

1docker load -i %Temp%\saved_rust_image.tar

Après cela, l’image Docker sera disponible sur l’ordinateur de développement hors ligne pour être utilisée avec Docker. Le nom et la balise seront les mêmes qu’au téléchargement à l’étape 1 (rust:1.73-bookworm ici).

​

Étape 4 : Utiliser l’image Docker chargée pour créer des conteneurs de développement

De plus en plus d’éditeurs de code prennent en charge le développement de conteneurs à distance. Si votre éditeur de code ne prend pas en charge le développement de conteneurs à distance, vous pouvez soit en installer un qui le prend en charge, soit simplement utiliser le conteneur Docker de développement pour construire et déboguer le logiciel développé.

​

Cas de Visual Studio Code

Suivez les instructions fournies dans la documentation des DevContainers de Visual Studio Code pour configurer votre environnement de développement avec des conteneurs Docker. Vous pouvez commencer par le template DevContainer de Visual Studio Code pour Rust.

​

Cas de (Neo)Vim

Consultez le référentiel GitHub nvim-remote-containers pour des instructions sur la configuration de (Neo)Vim avec des conteneurs Docker de développement.

​

Éditeurs de code non pris en charge

Exécutez le conteneur Docker de développement Rust avec le dépôt de code monté. Effectuez des modifications sur le code et construisez à l’aide du terminal du conteneur Docker. Pour faciliter le débogage, montez le référentiel sur le même chemin que celui ouvert dans l’éditeur de code.

​

Gestion des dépendances et des paquets hors ligne

Lorsque vous utilisez Cargo dans un environnement de développement hors ligne, il n’est pas possible d’accéder aux dépendances depuis crates.io (le référentiel de paquets Cargo par défaut). Pour résoudre ce problème, les dépendances logicielles doivent être téléchargées et rendues disponibles hors ligne.

Ici, nous allons présenter 2 solutions pour gérer les paquets de dépendances dans un environnement de développement hors ligne.

​

Solution 1 : Intégration des paquets de dépendances

L’intégration des dépendances implique de télécharger toutes les dépendances de votre logiciel, de les rendre disponibles à la fois pour le développement et l’exécution, et de les prendre en charge avec Cargo.

Voici comment travailler avec des dépendances intégrées dans un environnement de développement hors ligne.

​

I. Configuration de Cargo pour utiliser les dépendances intégrées

En supposant que vos dépendances intégrées se trouvent dans le sous-dossier du dépôt de code source nommé third-party/vendor (sur Windows, third-party\vendor), voici ce que vous devez faire :

1. Créez un dossier .cargo à la racine du répertoire de votre dépôt logiciel.
2. Dans le dossier .cargo, créez un fichier config.toml avec la configuration suivante :

1# Utilisation des dépendances intégrées
2[source.crates-io]
3replace-with = "vendored-sources"
4# Définir le sous-dossier intégrées
5[source.vendored-sources]
6directory = "third-party/vendor"

​

II. Intégration des dépendances et copie vers l’ordinateur de développement

Voici le processus étape par étape :

1. Sur un ordinateur connecté à Internet, assurez-vous que la chaîne d’outils Rust est installée en suivant les instructions officielles.

2. Créez un projet Cargo factice.

   • Linux
   • Windows-Powershell
   • Windows-CMD

   1cargo new factice
   

   1cargo new factice
   

   1cargo new factice
   

3. Copiez les sections de dépendances (y compris les dépendances de développement et de build) du fichier Cargo.toml de votre logiciel à la fin du fichier Cargo.toml du projet factice.

4. Integrez les dépendances du projet factice, qui correspondront à celles de votre logiciel en développement :

   • Linux
   • Windows-Powershell
   • Windows-CMD

   1# Passez au projet factice
   2cd factice
   3
   4# integrez (cela génère le dossier "vendor" dans le répertoire actuel)
   5cargo vendor --versioned-dirs
   

   1# Passez au projet factice
   2cd factice
   3
   4# integrez (cela génère le dossier "vendor" dans le répertoire actuel)
   5cargo vendor --versioned-dirs
   

   1:: Passez au projet factice
   2cd /D factice
   3
   4:: integrez (cela génère le dossier "vendor" dans le répertoire actuel)
   5cargo vendor --versioned-dirs
   

5. Copiez en toute sécurité le dossier des dependance a integrer vendor sur l’ordinateur de développement hors ligne. Vous pouvez le faire comme mentionné précédemment.

6. Copiez le dossier des dépendances a integrer vendor dans l’emplacement configuré de Cargo (third-party/vendor), comme spécifié dans le fichier config.toml . Procédez ensuite au build du logiciel que vous avez développé.

​

Solution 2 : Utilisation d’un miroir crates.io

La création d’un miroir de crate.io est une autre solution. Deux des options existantes sont :

• panamax, développé en Rust.
• romt, développé en Python.

​

Conclusion

Bien installer et gérer la chaîne d’outils Rust hors ligne peut sembler intimidant pour les nouveaux venus, mais, comme détaillé dans cet article, c’est un processus simple. Il existe deux options pour y parvenir :

Option 1 : Installation locale

1. Téléchargez le Programme d’Installation Autonome Rust et le Programme d’Initialisation rustup-init (rustup-init uniquement la Première Fois) : Commencez par obtenir le programme d’installation autonome Rust et le programme d’initialisation rustup-init sur un appareil connecté à Internet.
2. Copiez les Fichiers Téléchargés en Toute Sécurité : Transférez en toute sécurité ces fichiers téléchargés sur votre ordinateur de développement hors ligne.
3. Installation de Rustup (Uniquement la Première Fois) : Installez Rustup sur votre ordinateur de développement hors ligne à l’aide du programme d’Initialisation rustup-init.
4. Installez la Chaîne d’Outils Rust : Utilisez le programme d’Installation autonome Rust pour installer la chaîne d’outils Rust sur votre ordinateur de développement hors ligne.
5. Gérez les Chaîne d’Outils Installées avec Rustup : Utilisez Rustup pour gérer efficacement les chaîne d’outils installées.

Option 2 : Utilisation de conteneurs Docker de développement

1. Télécharger et enregistrer l’image Docker de développement : Téléchargez l’image Docker de développement et enregistrez-la sur un appareil connecté à Internet.
2. Copier de manière sécurisée le fichier image Docker de développement téléchargé : Copiez en toute sécurité le fichier image Docker de développement téléchargé sur votre ordinateur de développement hors ligne.
3. Charger l’image Docker de développement copiée dans Docker : Sur l’ordinateur de développement hors ligne, utilisez la commande docker load pour charger l’image Docker à partir du fichier enregistré.
4. Utiliser l’image Docker chargée pour créer des conteneurs de développement : Une fois chargée, utilisez l’image Docker pour créer des conteneurs de développement pour vos projets Rust.

Pour la gestion des dépendances, il est conseillé d’utiliser un miroir du dépôt de paquets chaque fois que possible. Cette approche simplifie le processus d’ajout et de mise à jour des dépendances. Cependant, dans les cas où l’utilisation d’un miroir n’est pas possible, la gestion des dépendances par integration reste une alternative robuste.