Continuous Integration and Delivery Pipelines for C++

Detailed Description

Continuous Integration and Delivery (CI/CD) represents a fundamental shift in how modern software development teams build, test, and deploy applications. For C++ projects, which often involve complex build systems, multiple platform targets, and extensive testing requirements, CI/CD pipelines automate the entire software delivery process from code commit to production deployment. This automation ensures that every code change is automatically built, tested, and validated against quality standards, dramatically reducing the time between writing code and delivering value to users.

In today's fast-paced development environment, manual building and testing of C++ applications is not only time-consuming but also error-prone. CI/CD pipelines address this challenge by creating a standardized, repeatable process that runs automatically whenever code changes are pushed to a repository. For C++ developers, this means that compilation errors, unit test failures, memory leaks, and performance regressions are caught immediately rather than days or weeks later. Major technology companies like Google, Microsoft, and Amazon rely heavily on CI/CD pipelines to manage their massive C++ codebases, enabling them to deploy updates multiple times per day while maintaining high quality standards.

The core concepts of CI/CD include several interconnected practices. Continuous Integration (CI) involves automatically building and testing code whenever changes are committed to version control. Continuous Delivery (CD) extends CI by ensuring that code is always in a deployable state, automatically preparing release candidates. Continuous Deployment takes this further by automatically deploying validated changes to production. Key terminology includes pipelines (the automated workflow), stages (logical groupings of jobs), jobs (individual tasks like compilation or testing), artifacts (build outputs preserved between stages), and runners or agents (the machines that execute pipeline jobs).

For C++ projects specifically, CI/CD pipelines commonly handle multiple build configurations (Debug/Release), cross-platform compilation (Linux, Windows, macOS), different compiler toolchains (GCC, Clang, MSVC), static and dynamic analysis, unit and integration testing, code coverage reporting, performance benchmarking, and package generation. Real-world scenarios include building cross-platform desktop applications, compiling embedded systems firmware, creating game engines with multiple target platforms, developing high-performance server applications, and building scientific computing libraries that must maintain compatibility across various systems.

By completing this lesson, you will master the practical skills needed to implement professional-grade CI/CD pipelines for C++ projects. You'll learn to configure popular CI/CD platforms like Jenkins, GitLab CI/CD, and GitHub Actions specifically for C++ development workflows. You'll understand how to structure pipelines for optimal efficiency, implement comprehensive testing strategies, manage build artifacts across different platforms, integrate static analysis and code quality tools, handle complex dependencies, and create deployment automation that meets enterprise standards. These skills are essential for any C++ developer working in a professional team environment or maintaining open-source projects.

The knowledge gained from this lesson directly translates to improved code quality, faster development cycles, reduced integration issues, and more reliable deployments. You'll be able to identify and fix problems earlier in the development process, collaborate more effectively with team members, and deliver software with greater confidence. Whether you're building commercial applications, contributing to open-source projects, or developing embedded systems, mastering CI/CD for C++ will significantly enhance your productivity and the quality of your software deliverables.

Practical Examples

Example 1: Basic GitLab CI/CD Pipeline for C++ Project

This example demonstrates a fundamental GitLab CI/CD pipeline configuration for a C++ project using CMake. The pipeline includes compilation, testing, and artifact generation stages.

# .gitlab-ci.yml
# GitLab CI/CD configuration for C++ project with CMake

# Define stages in the pipeline execution order
stages:
  - build
  - test
  - package

# Global variables accessible to all jobs
variables:
  BUILD_TYPE: "Release"
  CMAKE_VERSION: "3.20"
  GCC_VERSION: "11"

# Template for common job configurations using YAML anchors
.common_setup: &common_setup
  before_script:
    # Update package lists and install required dependencies
    - apt-get update -qq
    - apt-get install -y cmake g++ libgtest-dev
    # Display versions for debugging and reproducibility
    - cmake --version
    - g++ --version

# Build job - compiles the C++ project
build_job:
  <<: *common_setup
  stage: build
  image: gcc:11
  script:
    # Create and enter build directory
    - mkdir -p build && cd build
    # Configure CMake with specific build type
    - cmake -DCMAKE_BUILD_TYPE=${BUILD_TYPE} ..
    # Build using all available CPU cores
    - cmake --build . -j$(nproc)
    # Display build artifacts for verification
    - ls -lah
  # Preserve build artifacts for subsequent stages
  artifacts:
    paths:
      - build/
    expire_in: 1 hour
  # Cache CMake files to speed up subsequent builds
  cache:
    key: ${CI_COMMIT_REF_SLUG}
    paths:
      - build/CMakeCache.txt
      - build/CMakeFiles/

# Test job - runs unit tests with coverage
test_job:
  <<: *common_setup
  stage: test
  image: gcc:11
  # This job depends on build_job completing successfully
  dependencies:
    - build_job
  script:
    - cd build
    # Execute all tests with verbose output
    - ctest --output-on-failure --verbose
    # Run tests with memory leak detection using valgrind if needed
    # - ctest -T memcheck
  # Generate test report for GitLab UI
  artifacts:
    reports:
      junit: build/test-results.xml
    when: always

# Package job - creates distributable artifacts
package_job:
  stage: package
  image: gcc:11
  dependencies:
    - build_job
  script:
    - cd build
    # Create installation package
    - cpack -G TGZ
    # Display created packages
    - ls -lah *.tar.gz
  artifacts:
    paths:
      - build/*.tar.gz
    expire_in: 1 week
  # Only run packaging on tagged releases
  only:
    - tags

Explanation: This pipeline configuration defines three stages that execute sequentially. The build stage compiles the C++ code using CMake and preserves the build directory as an artifact. The test stage runs automated tests using CTest, which discovers and executes all tests defined in the CMakeLists.txt file. The package stage creates distributable archives but only executes when code is tagged, preventing unnecessary packaging on every commit.

Best Practices: Always use specific Docker image versions (like gcc:11 instead of gcc:latest) to ensure reproducible builds. Utilize caching for dependencies and intermediate build files to reduce pipeline execution time. Set appropriate artifact expiration times to manage storage costs while maintaining necessary build history.

Common Mistakes to Avoid: Don't forget to include the dependencies keyword when a job needs artifacts from previous stages. Avoid hardcoding paths that might differ between local development and CI environments. Never commit sensitive information like API keys or passwords to the pipeline configuration file.

Example 2: Multi-Platform Jenkins Pipeline with Matrix Builds

This Jenkinsfile demonstrates a more advanced pipeline that builds and tests a C++ project across multiple platforms and compiler combinations using Jenkins' matrix build feature.

// Jenkinsfile - Declarative Pipeline for Multi-Platform C++ Builds

pipeline {
    // Use any available agent for the pipeline coordination
    agent none
    
    // Define environment variables available to all stages
    environment {
        PROJECT_NAME = 'MyCppProject'
        BUILD_DIR = 'build'
        ARTIFACT_DIR = 'artifacts'
    }
    
    // Configure build options and parameters
    options {
        // Keep only last 10 builds to save disk space
        buildDiscarder(logRotator(numToKeepStr: '10'))
        // Abort pipeline if it exceeds time limit
        timeout(time: 1, unit: 'HOURS')
        // Add timestamps to console output
        timestamps()
    }
    
    stages {
        stage('Build and Test') {
            // Create matrix for multiple platform/compiler combinations
            matrix {
                // Define the matrix axes
                axes {
                    axis {
                        name 'PLATFORM'
                        values 'linux', 'windows', 'macos'
                    }
                    axis {
                        name 'COMPILER'
                        values 'gcc', 'clang', 'msvc'
                    }
                    axis {
                        name 'BUILD_TYPE'
                        values 'Debug', 'Release'
                    }
                }
                
                // Exclude invalid combinations
                excludes {
                    exclude {
                        axis {
                            name 'PLATFORM'
                            values 'linux'
                        }
                        axis {
                            name 'COMPILER'
                            values 'msvc'
                        }
                    }
                    exclude {
                        axis {
                            name 'PLATFORM'
                            values 'windows'
                        }
                        axis {
                            name 'COMPILER'
                            notValues 'msvc'
                        }
                    }
                }
                
                // Specify agent based on platform
                agent {
                    label "${PLATFORM}"
                }
                
                stages {
                    stage('Checkout') {
                        steps {
                            // Clean workspace before checkout
                            cleanWs()
                            // Checkout source code from version control
                            checkout scm
                        }
                    }
                    
                    stage('Configure') {
                        steps {
                            script {
                                // Set compiler-specific CMake flags
                                def cmakeGenerator = ''
                                def compilerFlags = ''
                                
                                if (env.COMPILER == 'gcc') {
                                    compilerFlags = '-DCMAKE_C_COMPILER=gcc -DCMAKE_CXX_COMPILER=g++'
                                } else if (env.COMPILER == 'clang') {
                                    compilerFlags = '-DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++'
                                } else if (env.COMPILER == 'msvc') {
                                    cmakeGenerator = '-G "Visual Studio 17 2022"'
                                }
                                
                                // Configure CMake with platform-specific settings
                                sh """
                                    mkdir -p ${BUILD_DIR}
                                    cd ${BUILD_DIR}
                                    cmake ${cmakeGenerator} ${compilerFlags} \
                                          -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
                                          -DENABLE_TESTING=ON \
                                          -DCMAKE_INSTALL_PREFIX=../install \
                                          ..
                                """
                            }
                        }
                    }
                    
                    stage('Build') {
                        steps {
                            // Build the project using CMake's build abstraction
                            sh """
                                cd ${BUILD_DIR}
                                cmake --build . --config ${BUILD_TYPE} -j\$(nproc)
                            """
                        }
                    }
                    
                    stage('Test') {
                        steps {
                            // Run tests and collect results
                            sh """
                                cd ${BUILD_DIR}
                                ctest -C ${BUILD_TYPE} --output-on-failure -j\$(nproc)
                            """
                        }
                        post {
                            always {
                                // Publish test results regardless of outcome
                                junit "${BUILD_DIR}/test-results/*.xml"
                            }
                        }
                    }
                    
                    stage('Archive') {
                        steps {
                            script {
                                // Create artifact name with platform and compiler info
                                def artifactName = "${PROJECT_NAME}-${PLATFORM}-${COMPILER}-${BUILD_TYPE}"
                                
                                // Archive build artifacts
                                sh """
                                    mkdir -p ${ARTIFACT_DIR}
                                    cd ${BUILD_DIR}
                                    cmake --install . --prefix ../install
                                    cd ..
                                    tar czf ${ARTIFACT_DIR}/${artifactName}.tar.gz install/
                                """
                                
                                // Archive artifacts in Jenkins
                                archiveArtifacts artifacts: "${ARTIFACT_DIR}/*.tar.gz",
                                                fingerprint: true
                            }
                        }
                    }
                }
            }
        }
        
        stage('Deploy') {
            agent any
            when {
                // Only deploy on main branch with Release builds
                allOf {
                    branch 'main'
                    expression { return env.BUILD_TYPE == 'Release' }
                }
            }
            steps {
                echo 'Deploying artifacts to distribution server...'
                // Add deployment steps here
            }
        }
    }
    
    post {
        success {
            echo 'Pipeline completed successfully!'
        }
        failure {
            echo 'Pipeline failed! Check logs for details.'
            // Send notifications on failure
        }
    }
}

Explanation: This Jenkins pipeline uses the matrix feature to create multiple parallel build configurations automatically. Each combination of platform, compiler, and build type creates a separate job that runs independently. The pipeline excludes invalid combinations (like MSVC on Linux) and uses platform-specific agents labeled accordingly in the Jenkins setup.

Output/Results: Running this pipeline generates multiple builds simultaneously. For example, you might see builds labeled as "linux/gcc/Debug", "linux/gcc/Release", "windows/msvc/Debug", etc. Each produces its own artifacts and test results that can be downloaded or deployed independently.

Tips: Use matrix builds to catch platform-specific issues early. Label your Jenkins agents clearly by platform and capability. Always clean the workspace before building to prevent contamination from previous builds. Use the post sections to ensure cleanup and notifications happen regardless of build outcome.

Example 3: GitHub Actions Workflow with Code Coverage and Static Analysis

This example shows a comprehensive GitHub Actions workflow that includes compilation, testing, code coverage reporting, and static analysis using multiple tools.

# .github/workflows/ci.yml
# GitHub Actions workflow for C++ with coverage and static analysis

name: C++ CI with Quality Checks

# Trigger conditions for the workflow
on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]
  # Allow manual triggering
  workflow_dispatch:

# Define environment variables
env:
  BUILD_TYPE: Release
  COVERAGE_TYPE: Debug

jobs:
  # Job for building and testing with coverage
  build-and-test:
    name: Build, Test & Coverage
    runs-on: ${{ matrix.os }}
    
    strategy:
      # Don't cancel other jobs if one fails
      fail-fast: false
      matrix:
        os: [ubuntu-22.04, windows-latest, macos-latest]
        compiler: [gcc, clang]
        exclude:
          # MSVC is default on Windows
          - os: windows-latest
            compiler: gcc
          - os: windows-latest
            compiler: clang
    
    steps:
      # Checkout repository code
      - name: Checkout code
        uses: actions/checkout@v3
        with:
          submodules: recursive
          fetch-depth: 0
      
      # Install dependencies based on OS
      - name: Install dependencies (Ubuntu)
        if: runner.os == 'Linux'
        run: |
          sudo apt-get update
          sudo apt-get install -y \
            cmake \
            ninja-build \
            libgtest-dev \
            lcov \
            gcovr
      
      - name: Install dependencies (macOS)
        if: runner.os == 'macOS'
        run: |
          brew install cmake ninja googletest lcov
      
      - name: Install dependencies (Windows)
        if: runner.os == 'Windows'
        run: |
          choco install cmake ninja
      
      # Setup compiler environment
      - name: Setup GCC
        if: matrix.compiler == 'gcc' && runner.os == 'Linux'
        run: |
          sudo apt-get install -y gcc-11 g++-11
          echo "CC=gcc-11" >> $GITHUB_ENV
          echo "CXX=g++-11" >> $GITHUB_ENV
      
      - name: Setup Clang
        if: matrix.compiler == 'clang'
        run: |
          if [ "$RUNNER_OS" == "Linux" ]; then
            sudo apt-get install -y clang-14
            echo "CC=clang-14" >> $GITHUB_ENV
            echo "CXX=clang++-14" >> $GITHUB_ENV
          elif [ "$RUNNER_OS" == "macOS" ]; then
            echo "CC=clang" >> $GITHUB_ENV
            echo "CXX=clang++" >> $GITHUB_ENV
          fi
        shell: bash
      
      # Configure CMake with coverage flags for Debug builds
      - name: Configure CMake
        run: |
          cmake -B build \
            -G Ninja \
            -DCMAKE_BUILD_TYPE=${{ env.BUILD_TYPE }} \
            -DENABLE_TESTING=ON \
            -DENABLE_COVERAGE=ON \
            -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
      
      # Build the project
      - name: Build
        run: cmake --build build --config ${{ env.BUILD_TYPE }} -j $(nproc)
        shell: bash
      
      # Run tests with verbose output
      - name: Run tests
        run: |
          cd build
          ctest --output-on-failure --verbose -C ${{ env.BUILD_TYPE }}
        shell: bash
      
      # Generate code coverage report (Linux only with GCC)
      - name: Generate coverage report
        if: runner.os == 'Linux' && matrix.compiler == 'gcc'
        run: |
          # Capture coverage data
          lcov --directory build --capture --output-file coverage.info
          # Remove system and test files from coverage
          lcov --remove coverage.info '/usr/*' '*/test/*' '*/external/*' --output-file coverage.info
          # Generate HTML report
          genhtml coverage.info --output-directory coverage-report
      
      # Upload coverage to Codecov
      - name: Upload coverage to Codecov
        if: runner.os == 'Linux' && matrix.compiler == 'gcc'
        uses: codecov/codecov-action@v3
        with:
          files: ./coverage.info
          flags: unittests
          name: codecov-${{ matrix.os }}-${{ matrix.compiler }}
          fail_ci_if_error: false
      
      # Upload build artifacts
      - name: Upload artifacts
        uses: actions/upload-artifact@v3
        with:
          name: build-${{ matrix.os }}-${{ matrix.compiler }}
          path: |
            build/bin/
            build/lib/
          retention-days: 7
  
  # Separate job for static analysis
  static-analysis:
    name: Static Analysis
    runs-on: ubuntu-22.04
    
    steps:
      - name: Checkout code
        uses: actions/checkout@v3
      
      - name: Install tools
        run: |
          sudo apt-get update
          sudo apt-get install -y \
            clang-tidy-14 \
            cppcheck \
            cmake \
            ninja-build
      
      - name: Configure CMake
        run: |
          cmake -B build \
            -G Ninja \
            -DCMAKE_BUILD_TYPE=Debug \
            -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
      
      # Run clang-tidy on source files
      - name: Run clang-tidy
        run: |
          # Find all C++ source files and run clang-tidy
          find src -name '*.cpp' -o -name '*.hpp' | \
            xargs clang-tidy-14 -p build \
            --warnings-as-errors='*' || true
      
      # Run cppcheck for additional static analysis
      - name: Run cppcheck
        run: |
          cppcheck --enable=all \
                   --inconclusive \
                   --force \
                   --inline-suppr \
                   --xml \
                   --xml-version=2 \
                   --output-file=cppcheck-report.xml \
                   src/ 2>&1 || true
      
      - name: Upload static analysis results
        uses: actions/upload-artifact@v3
        with:
          name: static-analysis-results
          path: |
            cppcheck-report.xml
          retention-days: 30

Explanation: This GitHub Actions workflow demonstrates a production-ready CI pipeline for C++ projects. It uses matrix strategy to test across multiple operating systems and compilers, generates code coverage reports using lcov, uploads coverage data to Codecov for tracking over time, runs static analysis with clang-tidy and cppcheck, and preserves build artifacts for download or deployment.

Best Practices: Separate long-running jobs like static analysis from the main build-test cycle to get faster feedback on compilation and test failures. Use caching for dependencies to speed up workflow execution. Always generate and export the compile_commands.json file for tools like clang-tidy that need compilation database information.

Common Mistakes: Don't run coverage and static analysis on every commit during development; consider running them only on pull requests or nightly builds. Ensure your coverage exclusions don't accidentally remove legitimate source code from analysis. Be careful with "warnings as errors" in static analysis—it can block valid code during transition periods.

Example 4: Docker-Based CI/CD Pipeline with Dependency Caching

This example demonstrates a sophisticated pipeline using Docker containers for consistent build environments and implementing aggressive caching strategies to minimize build times.

# .gitlab-ci.yml or adaptable to other platforms
# Advanced Docker-based pipeline with multi-stage caching

# Use Docker-in-Docker service for building container images
image: docker:latest

services:
  - docker:dind

# Define stages
stages:
  - prepare
  - build
  - test
  - package
  - deploy

# Global variables
variables:
  DOCKER_DRIVER: overlay2
  DOCKER_TLS_CERTDIR: "/certs"
  REGISTRY: $CI_REGISTRY_IMAGE
  BUILD_IMAGE: $REGISTRY/build:latest
  CACHE_IMAGE: $REGISTRY/cache:latest

# Prepare build environment with cached dependencies
prepare-environment:
  stage: prepare
  script:
    # Login to container registry
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
    
    # Try to pull existing cache image to speed up build
    - docker pull $CACHE_IMAGE || true
    
    # Build new image with dependencies using cache
    - |
      docker build \
        --cache-from $CACHE_IMAGE \
        --target dependencies \
        --tag $CACHE_IMAGE \
        -f Dockerfile.build \
        .
    
    # Push updated cache image
    - docker push $CACHE_IMAGE
  
  # Only rebuild dependencies when Dockerfile or package files change
  only:
    changes:
      - Dockerfile.build
      - conanfile.txt
      - vcpkg.json
      - CMakeLists.txt

# Build the C++ project inside Docker container
build-project:
  stage: build
  script:
    - docker login -u $CI_REGISTRY_USER -p $CI_REGISTRY_PASSWORD $CI_REGISTRY
    
    # Pull cache image with dependencies
    - docker pull $CACHE_IMAGE
    
    # Build the actual project using multi-stage Docker build
    - |
      docker build \
        --cache-from $CACHE_IMAGE \
        --cache-from $BUILD_IMAGE \
        --target builder \
        --tag $BUILD_IMAGE \
        --build-arg BUILD_TYPE=Release \
        --build-arg ENABLE_TESTS=ON \
        -f Dockerfile.build \
        .
    
    # Extract build artifacts from container
    - |
      docker create --name extract $BUILD_IMAGE
      docker cp extract:/app/build ./build
      docker rm extract
  
  artifacts:
    paths:
      - build/bin/
      - build/lib/
      - build/test/
    expire_in: 1 hour

# Run unit tests
unit-tests:
  stage: test
  dependencies:
    - build-project
  script:
    - docker pull $BUILD_IMAGE
    
    # Run tests inside container
    - |
      docker run --rm \
        -v $(pwd)/build:/app/build \
        $BUILD_IMAGE \
        /bin/bash -c "cd /app/build && ctest --output-on-failure"
  
  artifacts:
    reports:
      junit: build/test-results/**/*.xml
    when: always

# Integration tests with service dependencies
integration-tests:
  stage: test
  services:
    # Add service dependencies for integration tests
    - postgres:14
    - redis:7
  variables:
    POSTGRES_DB: testdb
    POSTGRES_USER: testuser
    POSTGRES_PASSWORD: testpass
  dependencies:
    - build-project
  script:
    - docker pull $BUILD_IMAGE
    
    # Run integration tests with environment variables
    - |
      docker run --rm \
        -v $(pwd)/build:/app/build \
        -e DB_HOST=postgres \
        -e DB_PORT=5432 \
        -e REDIS_HOST=redis \
        -e REDIS_PORT=6379 \
        --network host \
        $BUILD_IMAGE \
        /bin/bash -c "cd /app/build && ./test/integration_tests"

# Create distribution package
create-package:
  stage: package
  dependencies:
    - build-project
  script:
    - docker pull $BUILD_IMAGE
    
    # Create runtime image with minimal footprint
    - |
      docker build \
        --cache-from $BUILD_IMAGE \
        --target runtime \
        --tag $REGISTRY:$CI_COMMIT_SHORT_SHA \
        --tag $REGISTRY:latest \
        -f Dockerfile.build \
        .
    
    # Push runtime image
    - docker push $REGISTRY:$CI_COMMIT_SHORT_SHA
    - docker push $REGISTRY:latest
    
    # Also create traditional packages
    - |
      docker run --rm \
        -v $(pwd)/packages:/packages \
        $BUILD_IMAGE \
        /bin/bash -c "cd /app/build && cpack -G DEB && cp *.deb /packages/"
  
  artifacts:
    paths:
      - packages/*.deb
    expire_in: 1 week

# Deploy to staging environment
deploy-staging:
  stage: deploy
  environment:
    name: staging
    url: https://staging.example.com
  dependencies:
    - create-package
  script:
    - echo "Deploying to staging environment..."
    
    # Pull the runtime image
    - docker pull $REGISTRY:$CI_COMMIT_SHORT_SHA
    
    # Deploy using docker-compose or Kubernetes
    - |
      docker run --rm \
        -v /var/run/docker.sock:/var/run/docker.sock \
        -e DEPLOY_ENV=staging \
        -e IMAGE_TAG=$CI_COMMIT_SHORT_SHA \
        deployment-tool:latest \
        deploy
  
  only:
    - develop
  when: manual

Supporting Dockerfile (Dockerfile.build):

# Multi-stage Dockerfile for C++ builds with dependency caching

# Stage 1: Dependencies - cached separately for faster rebuilds
FROM ubuntu:22.04 AS dependencies

# Install build tools and dependencies
RUN apt-get update && apt-get install -y \
    build-essential \
    cmake \
    ninja-build \
    git \
    libboost-all-dev \
    libssl-dev \
    libpq-dev \
    && rm -rf /var/lib/apt/lists/*

# Stage 2: Builder - compile the application
FROM dependencies AS builder

WORKDIR /app

# Copy source code
COPY . .

# Configure and build
ARG BUILD_TYPE=Release
ARG ENABLE_TESTS=OFF

RUN cmake -B build \
    -G Ninja \
    -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
    -DENABLE_TESTING=${ENABLE_TESTS} \
    && cmake --build build --parallel $(nproc)

# Stage 3: Runtime - minimal image with only runtime dependencies
FROM ubuntu:22.04 AS runtime

# Install only runtime dependencies
RUN apt-get update && apt-get install -y \
    libboost-system1.74.0 \
    libssl3 \
    libpq5 \
    && rm -rf /var/lib/apt/lists/*

# Copy built application
COPY --from=builder /app/build/bin /app/bin
COPY --from=builder /app/build/lib /app/lib

WORKDIR /app

# Set library path
ENV LD_LIBRARY_PATH=/app/lib:$LD_LIBRARY_PATH

# Default command
CMD ["/app/bin/myapp"]

Explanation: This pipeline uses Docker's multi-stage builds to create distinct layers for dependencies, building, and runtime. The dependencies stage is cached separately and only rebuilt when dependency files change, dramatically reducing build times. The builder stage compiles the C++ code, and the runtime stage creates a minimal production image containing only the necessary runtime dependencies and compiled binaries.

Performance Optimization: This approach can reduce typical build times from 20-30 minutes down to 2-5 minutes for incremental changes because Docker caches the expensive dependency installation step. Only source code changes trigger recompilation, while the base environment remains cached.

Tips: Tag your cache images with meaningful names and versions. Use .dockerignore to exclude unnecessary files from Docker context. Consider using BuildKit for advanced caching features. Monitor your Docker registry storage and implement cleanup policies for old images.

Practice Exercises

Exercise 1: Basic CI Pipeline Setup (Easy)

Objective: Create a simple CI pipeline that compiles a C++ project and runs basic unit tests.

Requirements:

Set up a GitHub Actions or GitLab CI pipeline
Configure the pipeline to trigger on push and pull request events
Install necessary dependencies (CMake, compiler, Google Test)
Build the project in Release mode
Execute unit tests and report results
Archive the compiled binary as an artifact

Hints:

Use official actions like actions/checkout@v3 for GitHub Actions
Reference the environment's package manager (apt, brew, choco) based on the operating system
Use CMake's --build command for platform-independent building
CTest automatically discovers tests when properly configured in CMakeLists.txt

Solution:

# .github/workflows/basic-ci.yml
name: Basic C++ CI

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

jobs:
  build-and-test:
    name: Build and Test
    runs-on: ubuntu-latest
    
    steps:
      # Step 1: Checkout the repository
      - name: Checkout code
        uses: actions/checkout@v3
      
      # Step 2: Install dependencies
      - name: Install dependencies
        run: |
          sudo apt-get update
          sudo apt-get install -y cmake g++ libgtest-dev
          # Build and install Google Test
          cd /usr/src/gtest
          sudo cmake .
          sudo make
          sudo cp lib/*.a /usr/lib
      
      # Step 3: Configure the project

C++ Complete Course- Beginner to Advanced

Module 1: C++ Fundamentals and Development Environment

Module 2: Object-Oriented Programming and Memory Management

Module 3: Generic Programming and the Standard Template Library

Module 4: Advanced C++ Features and Best Practices

Module 5: C++ Tooling and Build Systems

Module 6: Real-World C++ Projects and Best Practices