Skip to main content
Mapagam

49 SECTIONS · 1192 TOPICS

Gitlab CI Roadmap

  1. Understanding GitLab CI/CD Fundamentals

    1. 1. Understanding CI/CD Concepts
    2. Example: CI/CD Pipeline Workflow
    3. Key CI/CD Concepts Summary
    4. 2. Understanding Pipeline Architecture
    5. Example: Basic Pipeline Structure
    6. Key Concepts
    7. 3. Understanding GitLab CI/CD Terminology
    8. Example: Pipeline with Multiple Stages
    9. 4. Understanding Pipeline Types
    10. 5. Understanding Pipeline Triggers
    11. Example: Manual Trigger Configuration
    12. 6. Understanding Pipeline Status
    13. 7. Understanding Job States
    14. Example: Job state transition in a pipeline
    15. 8. Understanding Runner Types
    16. Example: Using Tags to Match Runners
    17. 9. Understanding Executor Types
    18. Example: Using Docker Executor
    19. 10. Understanding Artifacts vs Cache
    20. Example: Using Artifacts
    21. Example: Using Cache

  2. Setting Up Pipeline Configuration

    1. 1. Creating .gitlab-ci.yml File
    2. Example: Basic .gitlab-ci.yml Structure
    3. 2. Understanding YAML Syntax
    4. Example: Basic YAML Structure
    5. 3. Defining Pipeline Stages
    6. Example: Defining Stages in .gitlab-ci.yml
    7. 4. Setting Default Configuration
    8. Example: Default configuration with .gitlab-ci.yml
    9. 5. Setting Global Variables
    10. Example: Using Global Variables in a Job
    11. 6. Configuring Workflow Rules
    12. Example: Using rules for conditional execution
    13. 7. Using YAML Anchors and Aliases (&, *)
    14. 8. Using YAML Merge Keys (<<: *)
    15. Example: Reusing Configuration with Merge Keys
    16. Example: Defining Merge Key Templates
    17. 9. Validating Pipeline Syntax
    18. Example: Basic .gitlab-ci.yml syntax validation
    19. Validation Checklist
    20. 10. Using Include for External Configuration
    21. Example: Including a Local File
    22. Example: Including a Remote Template
    23. Example: Including a GitLab CI Template

  3. Installing GitLab Runner

    1. 1. Installing Runner on Linux
    2. Example: Registering a Runner
    3. 2. Installing Runner on macOS
    4. Example: Install using Homebrew
    5. Example: Install using official binary
    6. 3. Installing Runner on Windows
    7. Example: Registering Runner on Windows
    8. 4. Installing Runner via Docker
    9. Example: Run GitLab Runner in a Docker container
    10. 5. Installing Runner via Kubernetes
    11. Example: Deploy GitLab Runner using Helm Chart
    12. Installation Steps
    13. 6. Using Runner Authentication
    14. Example: Registering a Runner with Authentication
    15. 7. Registering Runners
    16. Example: Registering a Runner with Shell Executor
    17. 8. Verifying Runner Installation
    18. Example: Check runner status
    19. Example: List registered runners
    20. Example: Check runner configuration
    21. 9. Understanding Runner Versioning
    22. Example: Checking Runner Version
    23. Versioning Strategy
    24. 10. Managing Runner Configuration File
    25. Example: Configuration file structure

  4. Configuring GitLab Runner Settings

    1. 1. Configuring Runner Tags
    2. Example: Setting Runner Tags
    3. 2. Setting Runner Concurrency
    4. Example: Configuring Runner Concurrency
    5. 3. Setting Runner Limits
    6. Example: Configuring Runner Limits in
    7. 4. Configuring Runner Cache
    8. Example: Basic Cache Configuration
    9. 5. Setting Runner Timeout
    10. Example: Setting timeout in config.toml
    11. 6. Configuring Log Level
    12. Example: Setting Log Level in gitlab-runner config
    13. 7. Setting Check Interval
    14. Example: Configuring check_interval in config.toml
    15. 8. Configuring Session Server
    16. Example: Enabling Session Server in config.toml
    17. 9. Using Runner Feature Flags (FF_*)
    18. Example: Setting Feature Flags
    19. 10. Configuring Pre-Clone and Post-Clone Scripts
    20. Example: Using pre_clone_script and post_clone_script

  5. Configuring Runner Executors

    1. 1. Using Shell Executor
    2. Example: Configuring Shell Executor in .gitlab-ci.yml
    3. 2. Using Docker Executor
    4. Example: Docker Executor Configuration
    5. 3. Using Kubernetes Executor
    6. Example: Kubernetes Executor Configuration
    7. 4. Using SSH Executor
    8. Example: SSH Executor Configuration
    9. 5. Using VirtualBox Executor
    10. Example: Configuring VirtualBox Executor
    11. 6. Using Docker Machine Executor
    12. Example: Configuring Docker Machine Executor
    13. 7. Using Custom Executor
    14. Example: Custom Executor Configuration
    15. 8. Configuring Executor-Specific Settings
    16. Example: Docker Executor Configuration
    17. Example: Kubernetes Executor Configuration
    18. 9. Configuring Executor Volumes
    19. Example: Configuring Volume Mounts in GitLab CI
    20. 10. Managing Executor Security
    21. Example: Configuring Runner Security with Environment Variables
    22. Security Best Practices for Executor Configuration

  6. Defining Jobs and Scripts

    1. 1. Creating Basic Job Definition
    2. Example: Basic job definition
    3. 2. Assigning Jobs to Stages
    4. Example: Defining Jobs in Stages
    5. 3. Defining Job Scripts
    6. Example: Basic script usage
    7. Example: Using before_script and after_script
    8. 4. Using before_script Hook
    9. Example: before_script with multiple commands
    10. 5. Using after_script Hook
    11. Example: after_script with cleanup
    12. 6. Setting Job Images
    13. Example: Using a Custom Image
    14. 7. Configuring Job Services
    15. Example: Using a PostgreSQL Service
    16. 8. Setting Job Timeout
    17. Example: Setting a 30-minute job timeout
    18. 9. Using retry for Failed Jobs
    19. Example: Retry configuration
    20. 10. Setting Job Tags
    21. Example: Setting Job Tags

  7. Using Job Dependencies and Artifacts Passing

    1. 1. Setting Job Dependencies
    2. Example: Basic needs usage
    3. Example: Needs with artifacts
    4. 2. Using needs for DAG Pipelines
    5. Example: Basic needs usage
    6. Example: Using needs with pipeline reference
    7. Key Points
    8. 3. Creating Directed Acyclic Graph
    9. Example: Basic DAG Configuration
    10. 4. Passing Artifacts Between Jobs
    11. Example: Artifact Configuration
    12. 5. Using needs:artifacts Configuration
    13. Example: Using needs:artifacts
    14. 6. Implementing Optional Dependencies
    15. Example: Using
    16. 7. Using Cross-Stage Dependencies
    17. Example: Defining a Job with Cross-Stage Dependency
    18. Key Points
    19. 8. Understanding Job Ordering
    20. Example: Basic Job Dependency
    21. Key Concepts
    22. 9. Implementing Fan-In Patterns
    23. Example: Fan-In Pattern with Artifacts
    24. Key Points
    25. 10. Implementing Fan-Out Patterns
    26. Example: Fan-Out with Dependencies

  8. Working with Job Rules and Conditions

    1. 1. Defining Job Rules
    2. Example: Basic job rules with
    3. Example: Using
    4. Example: Setting variables in rules
    5. 2. Using if Conditionals
    6. Example: Conditional Job Execution
    7. 3. Matching File Changes
    8. Example: Using
    9. 4. Using exists for File Detection
    10. Example: Using exists in a job rule
    11. 5. Controlling Job Creation
    12. Example: Using rules for conditional job execution
    13. 6. Setting Variables in Rules
    14. Example: Setting Variables Based on Branch
    15. Example: Conditional Variable with GitLab Variables
    16. 7. Combining Multiple Rule Conditions
    17. Example: Combining multiple conditions in a rule
    18. 8. Using allow_failure with Rules
    19. Example: Using allow_failure with rules
    20. 9. Creating Manual Jobs (when: manual)
    21. Example: Manual Job Configuration
    22. 10. Using only and except
    23. Example: Using only and except
    24. Key Points

  9. Working with Predefined Variables

    1. 1. Using Project Variables (CI_PROJECT_*)
    2. Example: Using CI_PROJECT_NAME in a script
    3. 2. Using Pipeline Variables (CI_PIPELINE_*)
    4. Example: Using CI_PIPELINE_ID in a Script
    5. 3. Using Job Variables (CI_JOB_*)
    6. Example: Using CI_JOB_ID in a script
    7. Example: Using CI_JOB_NAME to conditionally run a task
    8. 4. Using Commit Variables (CI_COMMIT_*)
    9. Example: Using Commit Variables in a Job
    10. 5. Using Merge Request Variables (CI_MERGE_REQUEST_*)
    11. Example: Using Merge Request Variables in a Pipeline
    12. 6. Using Tag Variables
    13. Example: Using Tag Variables in a Job
    14. 7. Using Environment Variables (CI_ENVIRONMENT_*)
    15. Example: Setting environment variable in a job
    16. 8. Using Runner Variables (CI_RUNNER_*)
    17. Example: Using Runner Variables in a Script
    18. 9. Using Registry Variables (CI_REGISTRY_*)
    19. Example: Pushing to GitLab Container Registry
    20. 10. Using Server Variables (CI_SERVER_*)
    21. Example: Using CI_SERVER_VERSION in a script

  10. Managing Pipeline Variables and Secrets

    1. 1. Defining Pipeline Variables
    2. Example: Setting a Project Variable in .gitlab-ci.yml
    3. 2. Setting Job-Level Variables
    4. Example: Setting a Job-Level Variable
    5. 3. Using Environment Variables in Scripts ($VAR)
    6. Example: Using CI_PIPELINE_ID in a script
    7. Example: Using CI_COMMIT_SHA in a script
    8. 4. Expanding Variable References ($VAR, ${VAR})
    9. Example: Using Variable References in Scripts
    10. 5. Masking Sensitive Variables
    11. Example: Setting a masked variable in .gitlab-ci.yml
    12. 6. Protecting Variables
    13. Example: Setting a Protected Variable
    14. 7. Setting Variable Scope
    15. Example: Setting Project-Level Variables in .gitlab-ci.yml
    16. Example: Setting Job-Level Variables in .gitlab-ci.yml
    17. 8. Using File-Type Variables
    18. Example: Using file-type variables in a script
    19. 9. Accessing Project and Group Variables
    20. Example: Using Project Variables in a Job
    21. Example: Using Group Variables
    22. 10. Using Raw Variables
    23. Example: Using raw variables in a script

  11. Using Dynamic Variables and Configuration

    1. 1. Using dotenv for Dynamic Variables
    2. Example: Setting up dotenv in a GitLab CI job
    3. 2. Using Variables from Previous Jobs
    4. Example: Accessing job variables in subsequent jobs
    5. 3. Generating Dynamic Configuration
    6. Example: Using GitLab CI Variables in Configuration
    7. 4. Creating Dynamic Job Names
    8. Example: Dynamic Job Name Based on Branch
    9. Example: Using Pipeline ID in Job Name
    10. 5. Using Dynamic Includes
    11. Example: Using
    12. 6. Using Variable Expressions (${VAR:-default})
    13. Example: Setting a Default Image Tag
    14. 7. Creating Conditional Variables
    15. Example: Setting Conditional Variables in .gitlab-ci.yml
    16. 8. Using Multi-Line Variables
    17. Example: Setting a Multi-Line Variable in GitLab CI
    18. 9. Implementing Variable Inheritance
    19. Example: Inheriting Variables in a Job
    20. 10. Implementing Dynamic Environments
    21. Example: Environment Configuration
    22. Example: Dynamic Environment Variables

  12. Working with Include and Templates

    1. 1. Including Local Files
    2. Example: Including a local template file
    3. 2. Including Remote Files
    4. Example: Including a remote CI configuration
    5. 3. Using Project Templates
    6. Example: Using a Project Template
    7. Example: Extending a Template
    8. 4. Including GitLab Templates
    9. Example: Using a project template
    10. Example: Including a local template file
    11. Example: Including a remote template
    12. 5. Using Component-Based Includes
    13. Example: Including a Component
    14. 6. Extending Job Configurations
    15. Example: Extending a Job Configuration
    16. 7. Using Hidden Jobs
    17. Example: Define a hidden job
    18. 8. Creating Reusable Job Templates (!reference)
    19. Example: Using !reference to extend a template
    20. 9. Overriding Included Jobs (job redefinition)
    21. Example: Overriding a job script
    22. 10. Using Template Variables (TEMPLATE_*)
    23. Example: Using Template Variables in a Job

  13. Working with Docker Images

    1. 1. Using Docker Images
    2. Example: Using a Docker image in a job
    3. Example: Using a service with Docker image
    4. 2. Specifying Image Tags
    5. Example: Using Tag in GitLab CI
    6. 3. Setting Image Entrypoint
    7. Example: Setting entrypoint in a job
    8. 4. Pulling Images from Private Registries
    9. Example: Using GitLab Container Registry
    10. 5. Using CI_REGISTRY Variables
    11. Example: Pushing an image to the registry
    12. 6. Configuring Pull Policy
    13. Example: Setting Pull Policy in .gitlab-ci.yml
    14. 7. Using Image Aliases
    15. Example: Defining Image Aliases in .gitlab-ci.yml
    16. 8. Caching Docker Images
    17. Example: Caching Docker Images in GitLab CI
    18. 9. Using Minimal Base Images
    19. Example: Using Alpine as Base Image in GitLab CI
    20. 10. Debugging Image Issues
    21. Example: Inspect Docker Image Layers
    22. Example: Check Image Size

  14. Working with Docker Services

    1. 1. Configuring Docker Services
    2. Example: Configuring a PostgreSQL Service
    3. 2. Setting Service Aliases
    4. Example: Defining a service with an alias
    5. 3. Using Database Services
    6. Example: Using PostgreSQL service in a job
    7. 4. Using Redis Service
    8. Example: Using Redis in a Job
    9. 5. Using Elasticsearch Service
    10. Example: Elasticsearch Service Configuration
    11. 6. Using Docker-in-Docker Service
    12. Example: Using Docker-in-Docker in a Job
    13. 7. Configuring Service Health Checks
    14. Example: Configuring a service with health checks
    15. 8. Setting Service Variables
    16. Example: Using Service Variables in a Job
    17. 9. Using Service Entrypoint
    18. Example: Setting a custom entrypoint
    19. 10. Networking Between Job and Services
    20. Example: Connecting to a Database Service

  15. Building Docker Images in Pipelines

    1. 1. Building Images with Docker Build
    2. Example: Building a Docker Image in GitLab CI
    3. 2. Using Docker-in-Docker
    4. Example: Building and pushing a Docker image using DnD
    5. 3. Using Kaniko for Builds
    6. Example: Basic Kaniko Job Configuration
    7. Key Features of Kaniko
    8. 4. Using Buildah for Builds
    9. Example: Buildah Docker Image
    10. Key Features of Buildah
    11. 5. Using Multi-Stage Docker Builds
    12. Example: Multi-stage build in GitLab CI
    13. 6. Optimizing Build Cache (--cache-from)
    14. Example: Using --cache-from with Docker Build
    15. 7. Building Multi-Architecture Images
    16. Example: Building for AMD64 and ARM64
    17. 8. Using Build Arguments (--build-arg)
    18. Example: Setting Build Arguments in GitLab CI
    19. 9. Setting Build Context
    20. Example: Setting build context in a GitLab CI job
    21. 10. Tagging Images
    22. Example: Using Git Tags for Image Tagging
    23. Example: Tagging with Branch and Commit SHA

  16. Managing Artifacts

    1. 1. Defining Artifacts
    2. Example: Defining Artifacts in a Job
    3. 2. Setting Artifact Paths
    4. Example: Basic Artifact Path Configuration
    5. Example: Using Wildcards in Artifact Paths
    6. 3. Excluding Files from Artifacts
    7. Example: Exclude specific files from artifacts
    8. 4. Setting Artifact Expiration
    9. Example: Setting Artifact Expiration
    10. 5. Using artifacts:when Conditions
    11. Example: Using artifacts:when with on_success
    12. Example: Using artifacts:when with always
    13. 6. Exposing Artifacts
    14. Example: Exposing Test Artifacts
    15. Example: Exposing Build Artifacts
    16. 7. Using Untracked Files
    17. Example: Using untracked files in artifacts
    18. 8. Naming Artifacts
    19. Example: Naming Artifacts
    20. 9. Downloading Artifacts via API
    21. Example: Download Artifact via API
    22. 10. Viewing Artifacts in Merge Requests
    23. Example: Accessing Merge Request Artifacts

  17. Using Artifact Reports

    1. 1. Using JUnit Reports
    2. Example: Configuring JUnit Reports in .gitlab-ci.yml
    3. 2. Using Coverage Reports
    4. Example: Configuring Coverage Report in .gitlab-ci.yml
    5. 3. Using Code Quality Reports
    6. Example: Configuring Code Quality Report in .gitlab-ci.yml
    7. 4. Using SAST Reports
    8. Example: Configure SAST Report in GitLab CI
    9. 5. Using Dependency Scanning Reports
    10. Example: Configuring Dependency Scanning
    11. 6. Using Container Scanning Reports
    12. Example: Container Scanning Job Configuration
    13. 7. Using DAST Reports
    14. Example: DAST Report Configuration
    15. 8. Using License Reports
    16. Example: License Report Configuration
    17. 9. Using dotenv Reports
    18. Example: dotenv Report Configuration
    19. 10. Using Terraform Reports
    20. Example: Configuring Terraform Report

  18. Implementing Caching Strategies

    1. 1. Defining Cache Configuration
    2. Example: Basic Cache Configuration
    3. Example: Cache with TTL
    4. 2. Setting Cache Paths
    5. Example: Basic Cache Configuration
    6. Example: Cache with Wildcards
    7. 3. Using Cache Keys
    8. Example: Using Cache Keys in a Job
    9. 4. Creating Dynamic Cache Keys
    10. Example: Using GitLab CI Variables in Cache Keys
    11. Example: Dynamic Cache Key with Build Dependencies
    12. 5. Using Cache Key Prefix
    13. Example: Cache Key Prefix with Branch Name
    14. Example: Cache Key with Build Type
    15. 6. Setting Cache Policy
    16. Example: Basic Cache Configuration
    17. Example: Cache with TTL
    18. 7. Configuring Cache Fallback
    19. Example: Configuring Cache Fallback
    20. 8. Using Distributed Cache
    21. Example: Configuring GitLab CI to use a Redis cache
    22. 9. Optimizing Cache for Dependencies
    23. Example: Caching Node.js Dependencies
    24. 10. Clearing Cache
    25. Example: Clearing Pipeline Cache

  19. Working with Parallel Jobs

    1. 1. Controlling Job Parallelism
    2. Example: Using parallel jobs
    3. Example: Using parallel matrix
    4. 2. Using Parallel with Index
    5. Example: Using parallel with index
    6. Key Points
    7. 3. Distributing Tests Across Parallel Jobs
    8. Example: Distributing tests across parallel jobs
    9. Key Points
    10. 4. Using Parallel for Build Distribution
    11. Example: Parallel Build Distribution
    12. Example: Matrix Parallel Jobs
    13. 5. Implementing Parallel Deployments
    14. Example: Parallel Deployment Strategy
    15. Key Concepts
    16. 6. Using needs with Parallel Jobs
    17. Example: Using needs with parallel jobs
    18. 7. Optimizing Parallel Execution
    19. Example: Using
    20. Example: Limiting Concurrent Jobs
    21. Example: Parallel Matrix Jobs
    22. 8. Debugging Parallel Job Issues
    23. Example: Identifying Job Failures in Parallel Execution
    24. Debugging Steps for Parallel Jobs
    25. 9. Setting Parallel Limits
    26. Example: Using parallel with matrix
    27. 10. Using Parallel with Matrix
    28. Example: Parallel Jobs with Matrix

  20. Using Matrix Builds

    1. 1. Creating Matrix Jobs
    2. Example: Basic Matrix Job Configuration
    3. Example: Matrix with Variables
    4. 2. Defining Matrix Variables
    5. Example: Matrix Variables in .gitlab-ci.yml
    6. 3. Combining Matrix with Variables
    7. Example: Using Matrix Variables in Jobs
    8. 4. Using Matrix for Multi-Platform Builds
    9. Example: Matrix Configuration for Multi-Platform Builds
    10. 5. Using Matrix for Multi-Version Testing
    11. Example: Matrix Build Configuration
    12. Example: Including Custom Configurations
    13. Example: Excluding Specific Combinations
    14. 6. Using Matrix for Cross-Browser Testing
    15. Example: Matrix Configuration for Cross-Browser Testing
    16. 7. Filtering Matrix Combinations
    17. Example: Using
    18. 8. Using Matrix with needs
    19. Example: Using needs with matrix jobs
    20. 9. Optimizing Matrix Performance
    21. Example: Parallel Jobs with Caching
    22. 10. Debugging Matrix Configurations
    23. Example: Using
    24. Debugging Workflow

  21. Using Job Triggers and Child Pipelines

    1. 1. Creating Pipeline Triggers
    2. Example: Basic Pipeline Trigger Configuration
    3. 2. Triggering Child Pipelines
    4. Example: Triggering a Child Pipeline
    5. 3. Using Trigger Strategies
    6. Example: Pipeline Trigger Configuration
    7. Example: Manual Trigger Job
    8. 4. Passing Variables to Triggered Pipelines
    9. Example: Triggering a Pipeline with Variables
    10. 5. Using Forward Variables
    11. Example: Forwarding Variables in a Trigger Job
    12. 6. Creating Parent-Child Pipelines
    13. Example: Triggering a Child Pipeline
    14. Key Points
    15. 7. Triggering via API
    16. Example: Triggering a Pipeline via API
    17. 8. Using Trigger Rules
    18. Example: Using Trigger Rules in a Pipeline
    19. 9. Waiting for Child Pipeline
    20. Example: Wait for child pipeline completion
    21. 10. Debugging Trigger Issues
    22. Example: Trigger Job Configuration
    23. Common Debugging Steps

  22. Using Multi-Project Pipelines

    1. 1. Triggering Multi-Project Pipelines
    2. Example: Triggering a Pipeline in Another Project
    3. 2. Using Downstream Pipelines
    4. Example: Triggering a Downstream Pipeline
    5. Key Points
    6. 3. Passing Artifacts Between Projects
    7. Example: Fetching artifacts from another project
    8. 4. Setting Project Permissions
    9. Example: Setting Pipeline Permissions via API
    10. 5. Using Cross-Project Dependencies
    11. Example: Triggering a Pipeline in Another Project
    12. Key Points
    13. 6. Implementing Microservice Pipelines
    14. Example: Triggering a Pipeline in Another Project
    15. Example: Passing Variables to a Multi-Project Pipeline
    16. Key Points
    17. 7. Using needs:project Configuration
    18. Example: Using needs:project to fetch artifacts from another project
    19. 8. Tracking Multi-Project Status
    20. Example: Pipeline Status API Response
    21. 9. Debugging Multi-Project Pipelines
    22. Example: Using debug job in multi-project pipeline
    23. Debugging Workflow
    24. Debugging Tips
    25. 10. Implementing Release Coordination
    26. Example: Creating a Release

  23. Working with Pipeline Schedules

    1. 1. Creating Pipeline Schedules
    2. Example: Creating a Schedule via API
    3. 2. Setting Schedule Variables
    4. Example: Using Scheduled Variables in a Job
    5. 3. Using Scheduled Pipeline Rules
    6. Example: Scheduled Pipeline with Variables
    7. 4. Configuring Cron Syntax
    8. Example: Cron Syntax in GitLab CI/CD
    9. 5. Setting Schedule Timezone
    10. Example: Setting Schedule Timezone
    11. 6. Using Schedule for Nightly Builds
    12. Example: Schedule Configuration
    13. 7. Using Schedule for Periodic Scans
    14. Example: Schedule a Daily Security Scan
    15. 8. Deactivating Schedules
    16. Example: Deactivating a Schedule via GitLab UI
    17. 9. Running Schedules Manually
    18. Example: Manual Trigger via API
    19. 10. Monitoring Schedule Execution
    20. Example: Check schedule status via API

  24. Working with Merge Request Pipelines

    1. 1. Enabling Merge Request Pipelines
    2. Example: Enabling MR Pipelines with Rules
    3. 2. Using Merge Request Variables (CI_MERGE_REQUEST_*)
    4. Example: Using Merge Request Variables in a Pipeline
    5. 3. Running Only on MR
    6. Example: Running job only on MRs
    7. 4. Using Merged Results Pipelines
    8. Example: Enabling Merged Results Pipelines
    9. 5. Implementing Merge Trains
    10. Example: Enabling Merge Trains
    11. Key Features of Merge Trains
    12. Merge Trains vs Regular Merging
    13. 6. Using Coverage Comparison
    14. Example: Setting up coverage comparison in a GitLab CI job
    15. How Coverage Comparison Works
    16. 7. Setting MR Pipeline Strategy
    17. Example: Configuring MR Pipeline Strategy
    18. 8. Blocking MR on Pipeline Failure
    19. Example: Enabling Merge Request Pipeline Blocking
    20. 9. Running MR-Specific Jobs
    21. Example: Running MR-specific job
    22. 10. Using MR Labels in Rules
    23. Example: Using MR Labels in Rules

  25. Working with Environments and Deployments

    1. 1. Defining Environments
    2. Example: Defining a staging environment in a job
    3. 2. Setting Environment URLs
    4. Example: Setting Environment URL in CI/CD
    5. 3. Using Dynamic Environments
    6. Example: Deploy to Dynamic Environment
    7. 4. Configuring Deployment Jobs
    8. Example: Basic Deployment Job Configuration
    9. Example: Environment with Stop Action
    10. 5. Using Environment Tiers
    11. Example: Environment Tier Configuration
    12. 6. Creating Review Apps
    13. Example: Enable Review App for a Job
    14. 7. Stopping Environments
    15. Example: Stopping an Environment
    16. 8. Auto-Stopping Inactive Environments
    17. Example: Configure auto-stop for an environment
    18. 9. Protecting Environments
    19. Example: Protecting an Environment
    20. 10. Tracking Deployments
    21. Example: Deployment Tracking in GitLab CI

  26. Implementing Release Automation

    1. 1. Creating Releases
    2. Example: Creating a Release
    3. 2. Setting Release Name and Tag
    4. Example: Setting Release Name and Tag in GitLab CI
    5. 3. Adding Release Description
    6. Example: Setting Release Description
    7. 4. Creating Release Assets
    8. Example: Creating Release Assets
    9. 5. Generating Changelog
    10. Example: Using GitLab Changelog Generator
    11. 6. Using Semantic Versioning
    12. Example: Version Bump in GitLab CI
    13. Comparison: Manual vs Automated Versioning
    14. 7. Automating Version Bumps
    15. Example: Using GitLab CI to Bump Version
    16. 8. Publishing Release Notes
    17. Example: Publishing Release Notes
    18. 9. Using Release Milestones
    19. Example: Configure Release Milestone in GitLab CI
    20. 10. Creating Pre-Release Versions
    21. Example: Creating a Pre-Release Version

  27. Implementing Testing Strategies

    1. 1. Running Unit Tests
    2. Example: Unit Test Configuration
    3. 2. Running Integration Tests
    4. Example: Integration Test Job Configuration
    5. 3. Running End-to-End Tests
    6. Example: End-to-End Test Configuration
    7. 4. Using Test Fixtures
    8. Example: Setting Up a Mock Service in GitLab CI
    9. 5. Parallel Test Execution
    10. Example: Running Tests in Parallel Jobs
    11. Best Practices for Parallel Test Execution
    12. 6. Configuring Test Coverage
    13. Example: Configuring test coverage in GitLab CI
    14. 7. Setting Coverage Regex
    15. Example: Configuring Coverage Regex
    16. 8. Splitting Tests by Timing
    17. Example: Splitting Test Jobs in GitLab CI
    18. Timing-Based Test Strategy
    19. 9. Implementing Test Retries
    20. Example: Retry configuration in GitLab CI
    21. 10. Generating Test Reports
    22. Example: Configuring JUnit Test Reports
    23. Example: Configuring Cobertura Code Coverage Reports

  28. Implementing Code Quality Checks

    1. 1. Using Code Quality Template
    2. Example: Include code quality template in a GitLab CI job
    3. Summary of Code Quality Template Components
    4. 2. Running Linting Jobs
    5. Example: ESLint Configuration
    6. 3. Running Static Analysis
    7. Example: Using ESLint in a GitLab CI Job
    8. 4. Configuring Code Quality Thresholds
    9. Example: Setting Code Quality Thresholds in .gitlab-ci.yml
    10. 5. Using Code Climate Integration
    11. Example: Code Climate Configuration in .gitlab-ci.yml
    12. 6. Generating Code Coverage Reports
    13. Example: Configuring Code Coverage in GitLab CI
    14. 7. Using Coverage Visualization
    15. Example: Setting up Code Coverage in GitLab CI
    16. Supported Coverage Report Formats
    17. Steps to Visualize Coverage
    18. 8. Implementing Quality Gates
    19. Example: Code Coverage Gate
    20. 9. Tracking Code Quality Trends
    21. Example: Code Coverage Report Configuration
    22. Workflow: Tracking Trends Over Time
    23. 10. Customizing Code Quality Tools
    24. Example: Customizing ESLint Rules
    25. Example: Configuring Prettier

  29. Implementing Security Scanning

    1. 1. Running SAST Scans
    2. Example: Basic SAST job configuration
    3. Example: SAST with custom config
    4. 2. Running Dependency Scanning
    5. Example: Enable Dependency Scanning in a Pipeline
    6. 3. Using Container Scanning
    7. Example: Enable container scanning in GitLab CI
    8. Container Scanning Workflow
    9. 4. Running DAST Scans
    10. Example: DAST Scan Configuration
    11. 5. Implementing Secret Detection
    12. Example: Basic secret detection configuration
    13. 6. Using License Scanning
    14. Example: License Scanning Configuration
    15. Example: License Report Output
    16. 7. Running Coverage-Guided Fuzzing
    17. Example: Configuring a Fuzzing Job
    18. 8. Implementing API Security Testing
    19. Example: API Security Scan with OWASP ZAP
    20. 9. Using Security Dashboards
    21. Example: Configuring Security Dashboard in GitLab
    22. Security Dashboard Features
    23. Setting Up Security Dashboard
    24. 10. Configuring Security Policies
    25. Example: SAST Policy Configuration
    26. Example: DAST Policy Configuration

  30. Working with Container Registry

    1. 1. Authenticating to Registry
    2. Example: Using Registry Credentials in a Job
    3. 2. Using CI_REGISTRY Variables
    4. Example: Pushing an image to GitLab Container Registry
    5. 3. Building and Pushing Images
    6. Example: Building and Pushing an Image
    7. 4. Tagging Images ($CI_COMMIT_REF_SLUG)
    8. Example: Using
    9. Example: Using
    10. 5. Using Multi-Architecture Images
    11. Example: Building Multi-Architecture Images with Docker Buildx
    12. Key Points
    13. 6. Scanning Container Images
    14. Example: Enable image scanning in GitLab CI/CD
    15. 7. Cleaning Up Old Images
    16. Example: Configure Cleanup Policy in .gitlab-ci.yml
    17. 8. Using Registry API
    18. Example: Fetching Registry Repositories
    19. Example: Deleting a Tag
    20. 9. Configuring Registry Mirrors
    21. Example: Configure registry mirror in GitLab CI
    22. Configuration Summary
    23. 10. Implementing Image Signing
    24. Example: Enable image signing in a GitLab CI job

  31. Managing Package Registry

    1. 1. Publishing npm Packages
    2. Example: Publishing to npm registry
    3. Example: Using GitLab CI to publish
    4. 2. Publishing Maven Artifacts
    5. Example: Publishing to GitLab Package Registry
    6. 3. Publishing Python Packages
    7. Example: Publishing to GitLab Package Registry
    8. Key Steps
    9. 4. Publishing Go Modules
    10. Example: Publishing to GitLab Package Registry
    11. Example: GitLab CI Configuration
    12. 5. Using Generic Package Registry
    13. Example: Uploading a Generic Package
    14. Example: Downloading a Generic Package
    15. 6. Publishing Composer Packages
    16. Example: Publishing to GitLab Package Registry
    17. 7. Publishing NuGet Packages
    18. Example: Publishing a NuGet Package
    19. 8. Using Conan Packages
    20. Example: Using Conan in GitLab CI
    21. 9. Configuring Package Registry Authentication
    22. Example: Using GitLab CI/CD with Package Registry
    23. 10. Managing Package Versions and Cleanup
    24. Example: Configuring Package Cleanup

  32. Using GitLab Pages

    1. 1. Configuring GitLab Pages
    2. Example: GitLab Pages Configuration in
    3. 2. Setting Pages Artifacts
    4. Example: Configure GitLab Pages artifacts
    5. 3. Using Custom Domains
    6. Example: Configuring Custom Domain in
    7. 4. Deploying Static Site Generators
    8. Example: Deploying a Hugo Site
    9. Example: Deploying a Jekyll Site
    10. 5. Building React/Vue Apps for Pages
    11. Example: Basic React App Build Configuration
    12. Example: Building a Vue App with Custom Output Path
    13. React vs Vue Build Process
    14. 6. Configuring SSL for Pages
    15. Example: GitLab Pages with Custom Domain and SSL
    16. 7. Using pages:path_prefix
    17. Example: Setting path_prefix in .gitlab-ci.yml
    18. 8. Setting Pages Access Control
    19. Example: Configuring Pages Access Control
    20. 9. Using Pages with Subgroups
    21. Example: Configuring Pages in a Subgroup
    22. 10. Deploying Documentation Sites
    23. Example: Deploying documentation with MkDocs

  33. Deploying to Cloud Platforms

    1. 1. Deploying to AWS
    2. Example: Basic AWS Deployment Configuration
    3. Example: Deploying to AWS Lambda
    4. Deployment Options Comparison
    5. 2. Using AWS ECS Deployments
    6. Example: Deploying to AWS ECS
    7. 3. Deploying to Google Cloud
    8. Example: Deploying to Google App Engine
    9. Example: Deploying to Google Kubernetes Engine
    10. 4. Using Azure Deployments
    11. Example: Deploying to Azure App Service
    12. Deployment Steps
    13. 5. Deploying to Heroku
    14. Example: Deploying to Heroku
    15. 6. Using DigitalOcean Deployments
    16. Example: Deploy to DigitalOcean App Platform
    17. Deployment Process
    18. 7. Deploying Serverless Functions
    19. Example: Deploying to AWS Lambda
    20. 8. Configuring Terraform Deployments
    21. Example: Basic Terraform Deployment Configuration
    22. 9. Using Infrastructure as Code
    23. Example: Deploying a VPC with GitLab CI
    24. Key Concepts in IaC with GitLab CI
    25. 10. Managing Cloud Credentials
    26. Example: Using AWS Credentials in a Job

  34. Implementing CI/CD for Kubernetes

    1. 1. Configuring kubectl Access
    2. Example: Setting up kubectl in GitLab CI
    3. 2. Using Kubernetes Executor
    4. Example: Basic Kubernetes Executor Configuration
    5. 3. Deploying with kubectl
    6. Example: Deploying a Kubernetes Deployment
    7. Example: Updating a Deployment Image
    8. Example: Rolling Out a New Version
    9. 4. Using Helm Charts
    10. Example: Deploying with Helm in GitLab CI
    11. 5. Configuring Agent for Kubernetes
    12. Example: Kubernetes Agent Configuration
    13. 6. Using Review Apps on Kubernetes
    14. Example: Enabling Review Apps for Kubernetes
    15. Review Apps Benefits
    16. Review Apps vs Staging Environments
    17. 7. Implementing Auto Deploy
    18. Example: Enabling Auto DevOps
    19. Example: Deploying to Kubernetes
    20. 8. Using kustomize for Deployments
    21. Example: GitLab CI/CD with Kustomize
    22. 9. Configuring Namespace Management
    23. Example: Creating a namespace in GitLab CI
    24. 10. Using GitOps with ArgoCD
    25. Example: ArgoCD Application Definition
    26. GitOps Workflow with ArgoCD
    27. GitOps Tools Comparison

  35. Implementing Advanced Deployment Patterns

    1. 1. Implementing Blue-Green Deployments
    2. Example: GitLab CI/CD Blue-Green Deployment
    3. Benefits of Blue-Green Deployment
    4. 2. Using Canary Deployments
    5. Example: Canary Deployment Configuration
    6. Canary Deployment Benefits
    7. 3. Implementing Rolling Updates
    8. Example: Rolling Update Configuration
    9. 4. Using Shadow Deployments
    10. Example: Shadow Deployment Configuration
    11. Key Benefits of Shadow Deployments
    12. 5. Creating A/B Testing Pipelines
    13. Example: A/B Testing Pipeline Configuration
    14. Key Concepts in A/B Testing Pipelines
    15. 6. Implementing Feature Flag Deployments
    16. Example: Feature Flag in GitLab CI
    17. Feature Flag vs. Environment-Based Deployment
    18. 7. Using Progressive Delivery
    19. Example: Canary Release with GitLab CI/CD
    20. Example: Blue-Green Deployment Strategy
    21. Key Benefits of Progressive Delivery
    22. 8. Implementing Rollback Strategies
    23. Example: Automated Rollback in GitLab CI
    24. 9. Using Deployment Rings
    25. Example: Deployment Ring Configuration
    26. 10. Implementing GitOps Workflows
    27. Example: GitOps Pipeline Configuration
    28. GitOps vs Traditional Deployment
    29. GitOps Workflow Steps

  36. Working with Notifications and Integrations

    1. 1. Configuring Email Notifications
    2. Example: Email Notification Configuration
    3. 2. Using Slack Notifications
    4. Example: Slack Notification Configuration
    5. 3. Configuring Microsoft Teams Notifications
    6. Example: GitLab CI Configuration
    7. 4. Using Discord Notifications
    8. Example: GitLab CI Configuration
    9. 5. Implementing Custom Webhooks
    10. Example: Setting up a Custom Webhook in GitLab CI
    11. Key Considerations for Webhook Implementation
    12. 6. Using ChatOps Integrations
    13. Example: Slack Integration Setup
    14. ChatOps Integration Benefits
    15. 7. Configuring Jira Integration
    16. Example: GitLab CI/CD Configuration
    17. 8. Using PagerDuty Integration
    18. Example: Configure PagerDuty Integration in .gitlab-ci.yml
    19. Integration Workflow
    20. 9. Implementing Custom Notification Scripts
    21. Example: Custom Notification Script
    22. Key Points
    23. 10. Using GitLab API for Notifications
    24. Example: Get Project Notifications
    25. Example: Update Project Notifications

  37. Working with CI/CD API and Automation

    1. 1. Using CI/CD Pipeline API
    2. Example: Fetching Pipeline Details
    3. Example: Triggering a New Pipeline
    4. 2. Triggering Pipelines via API
    5. Example: Triggering a Pipeline
    6. 3. Managing Jobs via API
    7. Example: Get job details
    8. Example: Cancel a job
    9. Example: Retry a failed job
    10. 4. Using Job Tokens (CI_JOB_TOKEN)
    11. Example: Using CI_JOB_TOKEN to access GitLab API
    12. 5. Accessing GitLab API in Jobs
    13. Example: Using GitLab API Token in CI Job
    14. 6. Configuring Pipeline Webhooks
    15. Example: Setting up a Webhook
    16. Webhook Event Types
    17. 7. Creating Pipeline Badges
    18. Example: Adding a Build Status Badge to README.md
    19. Badge Configuration Options
    20. 8. Using Coverage Badges
    21. Example: Adding Coverage Badge to README
    22. 9. Implementing Custom Integrations
    23. Example: Triggering a Pipeline via API
    24. Example: Using GitLab API to Get Pipeline Status
    25. Custom Integration Best Practices
    26. 10. Using GraphQL API for CI/CD
    27. Example: Query project pipelines
    28. Example: Mutate pipeline variables

  38. Working with Monorepo Pipelines

    1. 1. Using rules:changes for Selective Execution
    2. Example: Using rules:changes to run jobs only on relevant file changes
    3. 2. Implementing Microservice Pipelines
    4. Example: Pipeline Configuration for Microservice
    5. Example: Shared Job Template
    6. Key Considerations for Microservice Pipelines
    7. 3. Using needs for Complex Dependencies
    8. Example: Using needs with job dependency
    9. Example: Using needs with artifacts
    10. 4. Creating Component-Specific Jobs
    11. Example: Component-specific job configuration
    12. Example: Using component variables
    13. 5. Using Dynamic Child Pipelines
    14. Example: Triggering a Dynamic Pipeline
    15. Key Points
    16. 6. Implementing Cross-Project Dependencies
    17. Example: Triggering a Pipeline in Another Project
    18. Example: Using Variables in Cross-Project Triggers
    19. 7. Using Path-Based Job Triggers
    20. Example: Path-Based Job Trigger
    21. Example: Excluding Paths
    22. 8. Optimizing Artifact Passing in Monorepos
    23. Example: Using
    24. Example: Using
    25. Example: Using
    26. 9. Using Matrix for Multi-Component Testing
    27. Example: Matrix Job Configuration
    28. 10. Implementing Conditional Deployments
    29. Example: Using Rules for Conditional Deployments
    30. Example: Deploying Only on Specific File Changes

  39. Using Advanced Pipeline Patterns

    1. 1. Using Bridge Jobs
    2. Example: Basic Bridge Job Configuration
    3. 2. Implementing Fan-In Fan-Out Patterns
    4. Example: Fan-Out Fan-In with Parallel Jobs
    5. Key Concepts
    6. 3. Using Pipeline Generators
    7. Example: Basic Pipeline Generator
    8. Key Points
    9. 4. Creating Conditional Stages
    10. Example: Basic Conditional Stage
    11. Example: Conditional Stage with Variables
    12. 5. Implementing Dynamic Pipeline Creation
    13. Example: Using
    14. Example: Conditional Pipeline Jobs Based on Branch
    15. Dynamic Pipeline Creation Patterns
    16. 6. Using Cross-Project Pipeline Dependencies
    17. Example: Triggering a Pipeline in Another Project
    18. Key Considerations
    19. 7. Creating Pipeline as Code Patterns
    20. Example: Basic Pipeline Template
    21. Example: Using Variables in Templates
    22. Best Practices for Pipeline Templates
    23. 8. Implementing Event-Driven Pipelines
    24. Example: Triggering a Pipeline on Merge Request
    25. Example: Using Scheduled Pipelines
    26. Key Features of Event-Driven Pipelines
    27. 9. Using Pipeline Composition Patterns
    28. Example: Using
    29. Example: Extending Jobs with Templates
    30. Key Benefits of Pipeline Composition
    31. 10. Creating Self-Healing Pipelines
    32. Example: Retry on Failure
    33. Example: Conditional Rollback
    34. Key Concepts

  40. Working with CI/CD Components and Catalog

    1. 1. Creating Reusable Components
    2. Example: Define a reusable component in a YAML file
    3. Key Features of Reusable Components
    4. 2. Publishing to CI/CD Catalog
    5. Example: Publishing a Pipeline Template
    6. Key Steps for Publishing
    7. 3. Using Component Inputs
    8. Example: Using Component Inputs
    9. 4. Versioning Components
    10. Example: Versioning in GitLab CI
    11. 5. Including Catalog Components
    12. Example: Including a Catalog Component
    13. 6. Creating Component Templates
    14. Example: Component Template YAML
    15. Best Practices
    16. 7. Using Component Outputs
    17. Example: Using Artifacts to Pass Data Between Jobs
    18. Example: Using Reports to Store Test Results
    19. 8. Implementing Component Testing
    20. Example: Running Jest Tests in GitLab CI
    21. Example: Running Cypress Tests
    22. 9. Documenting Components
    23. Example: Component Metadata File
    24. Best Practices for Component Documentation
    25. 10. Managing Component Dependencies
    26. Example: Defining Component Dependencies in CI/CD

  41. Optimizing Pipeline Performance

    1. 1. Using DAG Pipelines
    2. Example: DAG Pipeline Configuration
    3. 2. Implementing Parallel Execution
    4. Example: Basic Parallel Jobs
    5. Example: Parallel Test Jobs
    6. Best Practices for Parallel Execution
    7. 3. Optimizing Cache Usage
    8. Example: Using cache key with branch and commit
    9. Example: Cache with fallback key
    10. Cache Optimization Tips
    11. 4. Reducing Docker Image Size
    12. Example: Multi-stage Dockerfile
    13. 5. Using Interruptible Jobs
    14. Example: Enabling Interruptible Jobs
    15. 6. Skipping Unnecessary Jobs
    16. Example: Using
    17. Example: Using
    18. 7. Optimizing Artifact Size
    19. Example: Reducing Artifact Size
    20. 8. Using Resource Groups
    21. Example: Define a resource group in a job
    22. 9. Implementing Fail-Fast Strategies
    23. Example: Using
    24. Example: Using
    25. Best Practices for Fail-Fast
    26. 10. Monitoring Pipeline Duration
    27. Example: Fetching Pipeline Duration via API
    28. Key Metrics for Pipeline Duration Monitoring

  42. Using GitLab CI/CD Advanced Features

    1. 1. Using Auto DevOps
    2. Example: Enabling Auto DevOps in
    3. Auto DevOps Capabilities
    4. 2. Configuring Release Management
    5. Example: Basic Release Configuration
    6. Example: Release with Assets
    7. 3. Using Feature Flags (FF_* variables)
    8. Example: Enabling a feature flag in a job
    9. 4. Implementing Compliance Pipelines
    10. Example: Security Scan Job
    11. Example: Compliance Job
    12. 5. Using Pipeline Subscriptions
    13. Example: Configuring a Webhook for Pipeline Events
    14. 6. Configuring Required Pipelines
    15. Example: Required Pipeline Configuration
    16. 7. Using Pipeline Artifacts
    17. Example: Basic Artifact Usage
    18. Example: Artifact with Exclusions
    19. 8. Implementing External Pull Policies
    20. Example: Configuring External Pull Policy
    21. 9. Using Pipeline Efficiency Analytics
    22. Example: Setting up Pipeline Efficiency Metrics
    23. Key Metrics for Pipeline Efficiency
    24. Pipeline Efficiency vs Manual Monitoring
    25. Steps to Implement Pipeline Efficiency Analytics
    26. 10. Using id_tokens for OIDC Authentication
    27. Example: Using id_token in a job

  43. Managing GitLab Runner at Scale

    1. 1. Implementing Runner Autoscaling
    2. Example: Configure autoscaling with Kubernetes
    3. Key Considerations
    4. 2. Monitoring Runner Health
    5. Example: Check runner status via API
    6. Example: Monitor runner metrics with Prometheus
    7. Key Metrics to Monitor
    8. 3. Using Runner Fleet Management
    9. Example: Configure a GitLab Runner with Fleet Management
    10. Key Features of GitLab Runner Fleet Management
    11. 4. Configuring Runner Load Balancing
    12. Example: Configuring concurrent jobs
    13. Load Balancing Best Practices
    14. 5. Implementing Runner High Availability
    15. Example: Configuring HA runners with shared cache
    16. Runner HA vs Single Instance
    17. High Availability Runner Setup Steps
    18. 6. Using Runner Monitoring and Alerting
    19. Example: Configure runner monitoring with Prometheus
    20. Example: Set up alerting rules in Prometheus
    21. Runner Alerting Best Practices
    22. Runner Monitoring Tools
    23. 7. Optimizing Runner Resource Allocation
    24. Example: Configuring concurrent_jobs
    25. 8. Implementing Runner Cost Optimization
    26. Example: Configuring runner limits and resource constraints
    27. Example: Using tags to manage runner cost
    28. Runner Cost Optimization Strategies
    29. 9. Using Runner Capacity Planning
    30. Example: Configuring runner limits
    31. Capacity Planning Best Practices
    32. 10. Upgrading GitLab Runner
    33. Example: Upgrade GitLab Runner via Package Manager

  44. Managing Compute Minutes and Costs

    1. 1. Understanding Compute Minutes Allocation
    2. Example: Compute Minutes Usage
    3. Key Points
    4. 2. Tracking Compute Usage
    5. Example: Pipeline with Timeout Configuration
    6. 3. Optimizing Job Duration
    7. Example: Parallel Jobs
    8. Example: Caching Dependencies
    9. 4. Using Cost Factors
    10. Example: Cost Factor Configuration
    11. 5. Implementing Resource Limits
    12. Example: Setting Resource Limits in .gitlab-ci.yml
    13. 6. Using Timeout Optimization
    14. Example: Setting Timeout in .gitlab-ci.yml
    15. 7. Reducing Unnecessary Pipelines
    16. Example: Using
    17. Example: Using
    18. Best Practices for Reducing Pipeline Costs
    19. 8. Implementing Cost Alerts
    20. Example: Setting up a cost alert in GitLab
    21. 9. Using Efficient Docker Images
    22. Example: Using Alpine-based image in GitLab CI
    23. 10. Monitoring Cost Trends
    24. Example: Cost Trend Query

  45. Implementing Security Best Practices

    1. 1. Using Protected Branches
    2. Example: Protecting a Branch in GitLab CI/CD
    3. 2. Configuring Protected Tags
    4. Example: Protecting a Tag in .gitlab-ci.yml
    5. 3. Implementing Least Privilege for Runners
    6. Example: Project Runner Configuration
    7. 4. Using Masked Variables (masked: true)
    8. Example: Masked Variable in GitLab CI/CD
    9. 5. Rotating CI/CD Tokens Regularly
    10. Example: Rotating Job Token in CI/CD Pipeline
    11. 6. Implementing Secrets Management
    12. Example: Using GitLab CI Variables
    13. 7. Using Signed Commits Verification
    14. Example: Enabling commit signing in GitLab CI
    15. Verification Process
    16. 8. Configuring RBAC for Runners
    17. Example: Setting up RBAC for runners in GitLab
    18. 9. Implementing Audit Logging
    19. Example: Enabling Audit Logging in GitLab CI/CD
    20. 10. Using Security Policies
    21. Example: Enforcing Code Review Policy

  46. Working with Compliance and Governance

    1. 1. Implementing Compliance Frameworks
    2. Example: GitLab CI/CD Compliance Configuration
    3. 2. Using Compliance Pipeline Configuration
    4. Example: Enabling Compliance Pipeline
    5. Example: Defining Compliance Rules
    6. 3. Configuring Separation of Duties
    7. Example: Setting up Separation of Duties
    8. 4. Implementing Approval Rules
    9. Example: Configuring Approval Rules in .gitlab-ci.yml
    10. 5. Using Audit Events
    11. Example: Audit Event Configuration
    12. 6. Configuring License Compliance
    13. Example: License Compliance Configuration
    14. 7. Implementing Security Policies
    15. Example: Security Scanning Configuration
    16. Example: Compliance Check Configuration
    17. 8. Using Compliance Dashboards
    18. Example: Setting up a compliance dashboard in GitLab
    19. Key Features of Compliance Dashboards
    20. 9. Configuring External Status Checks
    21. Example: Enable External Status Checks
    22. 10. Implementing Change Management Controls
    23. Example: Enforcing Branch Protection
    24. Example: Setting Merge Request Approvals

  47. Monitoring and Analyzing Pipelines

    1. 1. Using Pipeline Analytics
    2. Example: Accessing Pipeline Analytics in GitLab
    3. Key Features of Pipeline Analytics
    4. 2. Tracking Pipeline Duration
    5. Example: Pipeline Duration in GitLab CI/CD
    6. 3. Identifying Pipeline Bottlenecks
    7. Example: Analyzing Job Duration Logs
    8. 4. Using Value Stream Analytics
    9. Example: Setting up Value Stream Analytics
    10. Key Features of Value Stream Analytics
    11. 5. Implementing Pipeline Success Rate Tracking
    12. Example: Pipeline Metrics in GitLab CI/CD
    13. Tracking Pipeline Success Rate
    14. 6. Monitoring Runner Queue Times
    15. Example: Calculating Queue Time
    16. 7. Using DORA Metrics
    17. Example: Setting up DORA Metrics in GitLab CI
    18. 8. Tracking Pipeline Costs
    19. Example: Pipeline Duration in API Response
    20. Cost Tracking Best Practices
    21. 9. Optimizing Pipeline Schedules
    22. Example: Schedule Configuration
    23. Optimization Tips
    24. 10. Using Pipeline Insights API
    25. Example: Fetching Pipeline Metrics
    26. Key Features of Pipeline Insights API

  48. Handling Errors and Debugging

    1. 1. Using allow_failure for Non-Critical Jobs
    2. Example: Using allow_failure in a job
    3. 2. Debugging with CI_DEBUG_TRACE
    4. Example: Enabling Debug Trace
    5. 3. Viewing Job Logs
    6. Example: Accessing Job Logs via GitLab UI
    7. Log Debugging Tips
    8. 4. Using echo for Debug Output
    9. Example: Basic echo usage in a GitLab CI job
    10. Best Practices for Debugging with echo
    11. 5. Handling Script Failures
    12. Example: Handling Script Failures
    13. 6. Retrying Failed Jobs
    14. Example: Retry configuration in .gitlab-ci.yml
    15. 7. Using when:on_failure Jobs
    16. Example: Defining a job that runs on failure
    17. 8. Debugging Variable Expansion
    18. Example: Using Variables in Scripts
    19. 9. Validating YAML Syntax
    20. Example: Basic YAML Validation
    21. Validation Tips
    22. 10. Using Job Artifacts for Debugging
    23. Example: Configuring Artifacts in a Job
    24. Key Points

  49. Troubleshooting Common Issues

    1. 1. Resolving Runner Connection Issues
    2. Example: Re-registering a GitLab Runner
    3. 2. Fixing Docker Authentication Errors
    4. Example: Setting up Docker registry credentials in GitLab CI
    5. 3. Debugging Cache Miss Issues
    6. Example: Cache Key Configuration
    7. 4. Resolving Artifact Download Failures
    8. Example: Artifact Upload and Download Configuration
    9. 5. Fixing YAML Syntax Errors
    10. Example: Correct YAML Syntax
    11. Example: Incorrect YAML Syntax
    12. 6. Debugging Variable Expansion Issues
    13. Example: Variable Expansion in Script
    14. Common Expansion Issues
    15. 7. Resolving Permission Denied Errors
    16. Example: Setting up SSH Keys for GitLab CI
    17. Common Permission Issues
    18. 8. Fixing Timeout Issues
    19. Example: Setting Job Timeout
    20. Example: Configuring Runner Timeout
    21. 9. Debugging Merge Conflict Failures
    22. Example: Resolving Merge Conflicts Locally
    23. 10. Resolving Resource Exhaustion
    24. Example: Limiting Concurrent Jobs
    25. Example: Setting Cache Limits