CI/CD pour projets Rust : configuration de GitHub Actions

Introduction : Pourquoi CI/CD est important pour les projets Rust

Développer en Rust ne concerne pas seulement la sécurité mémoire et les hautes performances. Dans le monde moderne, tout projet sérieux nécessite l'automatisation des processus de construction, de test et de déploiement. CI/CD (Continuous Integration / Continuous Deployment) permet aux équipes de publier des mises à jour plus rapidement, en réduisant le risque d'erreurs humaines et en assurant la stabilité de la base de code.

GitHub Actions est un outil intégré à GitHub pour automatiser les workflows. Il est parfaitement adapté aux projets Rust car il fournit des actions prêtes à l'emploi pour installer le compilateur, mettre en cache les dépendances et publier des crates sur crates.io. Dans cet article, nous allons voir comment configurer un pipeline CI/CD complet pour une application Rust à partir de zéro.

1. Bases de GitHub Actions pour Rust

Avant de plonger dans le code, comprenons la structure de base de GitHub Actions. Chaque workflow est défini par un fichier YAML situé dans le répertoire .github/workflows/. Un workflow se compose d'un ou plusieurs jobs (tâches) qui s'exécutent séquentiellement ou en parallèle sur des machines virtuelles (runners).

Pour les projets Rust, un workflow minimal comprend les étapes suivantes :

• Checkout — récupération de la dernière version du code depuis le dépôt.
• Installation de Rust — via l'action actions-rs/toolchain ou l'action officielle dtolnay/rust-toolchain.
• Mise en cache des dépendances — accélération de la construction en sauvegardant target/ et ~/.cargo/.
• Construction et test — exécution de cargo build et cargo test.

Exemple de workflow de base (fichier .github/workflows/ci.yml) :

name: Rust CI

on:  push:    branches: [ main ]  pull_request:    branches: [ main ]

env:  CARGO_TERM_COLOR: always

jobs:  build:    runs-on: ubuntu-latest

    steps:    - uses: actions/checkout@v3        - name: Install Rust      uses: dtolnay/rust-toolchain@stable      with:        components: clippy, rustfmt        - name: Cache dependencies      uses: actions/cache@v3      with:        path: |          ~/.cargo/          target/        key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}        - name: Build      run: cargo build --verbose        - name: Run tests      run: cargo test --verbose        - name: Lint with clippy      run: cargo clippy -- -D warnings        - name: Check formatting      run: cargo fmt --check

Ce workflow s'exécute à chaque push vers la branche main et lors de la création d'une pull request. Il vérifie que le code compile, passe les tests, ne contient pas d'erreurs de lint et respecte le style de formatage.

2. Stratégies avancées : construction matricielle et mise en cache

Rust est un langage multiplateforme, et il est souvent nécessaire de vérifier la construction sur plusieurs systèmes d'exploitation ou architectures. Pour cela, on utilise la construction matricielle (matrix build).

Ajoutons à notre workflow le support de Windows et macOS :

jobs:  build:    strategy:      matrix:        os: [ubuntu-latest, windows-latest, macos-latest]        rust: [stable, beta]        runs-on: ${{ matrix.os }}        steps:    - uses: actions/checkout@v3        - name: Install Rust      uses: dtolnay/rust-toolchain@master      with:        toolchain: ${{ matrix.rust }}        components: clippy        - name: Cache      uses: actions/cache@v3      with:        path: |          ~/.cargo/registry/          ~/.cargo/git/          target/        key: ${{ matrix.os }}-cargo-${{ matrix.rust }}-${{ hashFiles('**/Cargo.lock') }}        - name: Build      run: cargo build --