CI/CD pour projets C++ : GitHub Actions niveau avancé

CI/CD avancé pour projets C++ sur GitHub Actions

Lorsque le pipeline simple « compiler — lancer les tests — déployer » ne suffit plus, il est temps de passer aux techniques avancées. Dans cet article, nous verrons comment configurer GitHub Actions pour des projets C++ à un niveau professionnel : mise en cache des dépendances, matrice de builds pour différents compilateurs, analyse statique du code, artefacts et déclencheurs intelligents. Tous les exemples sont donnés en C++ avec CMake.

1. Mise en cache des dépendances et accélération de la compilation

Chaque exécution d'un workflow démarre sur une machine virtuelle propre. Sans mise en cache, vous téléchargerez et compilerez à chaque fois la même bibliothèque (par exemple, Boost ou Google Test). La solution consiste à utiliser la mise en cache intégrée de GitHub Actions.

name: CI pour C++ (avancé)on: [push, pull_request]

jobs:  build:    runs-on: ubuntu-latest    steps:      - uses: actions/checkout@v4

      - name: Mise en cache des dépendances        uses: actions/cache@v3        with:          path: |            ~/.cache            build/_deps          key: ${{ runner.os }}-c++-${{ hashFiles('CMakeLists.txt', '**/*.cmake') }}          restore-keys: |            ${{ runner.os }}-c++-

      - name: Installation des dépendances système        run: sudo apt-get update && sudo apt-get install -y libboost-all-dev

      - name: Compilation        run: |          cmake -B build -DCMAKE_BUILD_TYPE=Release          cmake --build build -j$(nproc)

La clé key est générée à partir du hash de CMakeLists.txt — lorsque la liste des dépendances change, le cache est automatiquement invalidé. Le paramètre restore-keys permet de restaurer partiellement le cache si la clé exacte n'est pas trouvée.

2. Matrice de builds : plusieurs compilateurs et plateformes

Lors du développement d'une application C++ multiplateforme, il est important de vérifier la compilation avec différents compilateurs. GitHub Actions prend en charge la matrice de stratégies (matrix strategy).

jobs:  build:    strategy:      matrix:        os: [ubuntu-latest, windows-latest, macos-latest]        compiler: [gcc, clang, msvc]        exclude:          - os: ubuntu-latest            compiler: msvc          - os: windows-latest            compiler: clang          - os: macos-latest            compiler: msvc

    runs-on: ${{ matrix.os }}

    steps:      - uses: actions/checkout@v4

      - name: Configuration du compilateur (Linux)        if: runner.os == 'Linux'        run: |          if [ "${{ matrix.compiler }}" == "gcc" ]; then            echo "CC=gcc" >> $GITHUB_ENV            echo "CXX=g++" >> $GITHUB_ENV          elif [ "${{ matrix.compiler }}" == "clang" ]; then            echo "CC=clang" >> $GITHUB_ENV            echo "CXX=clang++" >> $GITHUB_ENV          fi

      - name: Compilation avec CMake        run: |          cmake -B build -DCMAKE_BUILD_TYPE=Debug          cmake --build build

La matrice génère automatiquement 6 tâches (3 OS × 2 compilateurs après exclusion des combinaisons invalides). Cela permet de détecter rapidement les problèmes spécifiques à un compilateur ou à une plateforme particulière.

3. Analyse statique et linters

La qualité du code C++ est cruciale. Intégrez dans le pipeline l'analyse statique avec Clang-Tidy, Cppcheck ou SonarCloud. Examinons un exemple avec Clang-Tidy.

jobs:  static-analysis:    runs-on: ubuntu-latest    steps:      - uses: actions/checkout@v4

      - name: Installation des outils        run: |          sudo apt-get install -y clang-tidy cppcheck          pip install compiledb

      - name: Génération de compile_commands.json        run: |          cmake -B build -DCMAKE_EXPORT_COMPILE_COMMANDS=ON          compiledb -o build/compile_commands.json make -C build

      - name: Lancement de Clang-Tidy        run: |          find . -name '*.cpp' -o -name '*.hpp' | xargs clang-tidy -p build --checks='*,-modernize-use