Skip to main content
Mapagam

43 SECTIONS · 1033 TOPICS

Circleci Roadmap

  1. Understanding CircleCI Fundamentals

    1. 1. Understanding CI/CD Concepts
    2. Example: CI/CD Pipeline Flow
    3. Core CI/CD Principles
    4. 2. Understanding CircleCI Architecture
    5. Example: Basic Workflow Configuration
    6. Architecture Overview
    7. 3. Understanding Credit-Based Pricing
    8. Example: Credit Usage Calculation
    9. 4. Comparing CircleCI Plans
    10. Free vs Pro Plan Comparison
    11. 5. Understanding Execution Environments
    12. Example: Using Docker Environment
    13. 6. Understanding Pipeline Lifecycle
    14. Example: Pipeline Configuration
    15. Key Pipeline Concepts
    16. 7. Understanding Config Structure
    17. Example: Basic config structure
    18. Key Concepts
    19. 8. Navigating CircleCI Dashboard
    20. Example: Dashboard Navigation Path
    21. 9. Understanding Built-in Environment Variables
    22. Example: Using Environment Variables in Config
    23. 10. Understanding Version Requirements
    24. Example: Setting CircleCI CLI Version
    25. Example: Using Docker Image with Specific Version

  2. Installing and Using CircleCI CLI

    1. 1. Installing CLI
    2. Example: Verify Installation
    3. 2. Setting Up CLI Authentication
    4. Example: Authenticating with CircleCI CLI
    5. 3. Validating Config Files
    6. Example: Basic config validation
    7. 4. Processing Config Locally
    8. 5. Running Jobs Locally
    9. Example: Running a local job with custom config
    10. 6. Testing Config Changes
    11. Example: Validate config locally
    12. Example: Pack config for debugging
    13. 7. Packing Orbs
    14. Example: Packing an Orb
    15. 8. Publishing Orbs
    16. Example: Publishing an Orb
    17. 9. Listing Available Orbs
    18. Example: Listing all orbs
    19. Example: Listing orbs in a namespace
    20. Example: Searching for orbs
    21. 10. Updating CLI Version
    22. Example: Update to latest version
    23. Example: Install specific version

  3. Setting Up Configuration Files

    1. 1. Creating Config File
    2. Example: Basic CircleCI Configuration
    3. 2. Specifying Config Version
    4. Example: Config Version Declaration
    5. 3. Understanding Config Hierarchy
    6. 4. Using YAML Anchors and Aliases
    7. Example: Reusing a Job Configuration
    8. 5. Commenting Configuration
    9. Example: Commenting in CircleCI Config
    10. 6. Validating Config Locally
    11. Example: Using circleci-cli to validate config
    12. 7. Using Config Processing
    13. Example: Basic config processing with environment variables
    14. Example: Conditional processing based on branch
    15. Config Processing Best Practices
    16. 8. Enabling Dynamic Configuration
    17. Example: Enabling Dynamic Configuration
    18. 9. Organizing Multi-File Configs
    19. Example: Splitting Configuration into Multiple Files
    20. Best Practices for Multi-File Configs
    21. 10. Setting Pipeline Parameters
    22. Example: Defining Pipeline Parameters
    23. Example: Using Pipeline Parameters in Jobs

  4. Configuring Docker Executor

    1. 1. Specifying Docker Executor
    2. Example: Basic Docker Executor Configuration
    3. 2. Using Docker Images
    4. Example: Using a Custom Docker Image
    5. Example: Using Private Docker Registry
    6. 3. Specifying Image Tags
    7. Example: Using a specific image tag
    8. Example: Using image digest for reproducibility
    9. 4. Using CircleCI Convenience Images
    10. Example: Using Python Convenience Image
    11. 5. Using Multiple Docker Images
    12. Example: Primary and Service Images
    13. Example: Auxiliary Image for Testing
    14. 6. Authenticating with Registries
    15. Example: Using Docker Login with Environment Variables
    16. 7. Using Private Docker Registries
    17. Example: Using Private Registry in CircleCI Config
    18. 8. Setting Container Environment
    19. Example: Setting Custom Environment Variables
    20. 9. Configuring Docker Entrypoint
    21. Example: Setting Docker Entrypoint
    22. 10. Using Docker Commands
    23. Example: Running a Docker Container in CircleCI
    24. Example: Building and Using a Custom Docker Image

  5. Configuring Machine and macOS Executors

    1. 1. Specifying Machine Executor
    2. Example: Using Machine Executor
    3. 2. Setting Machine Image Versions
    4. Example: Setting Machine Image in Config
    5. 3. Using Linux Machine Images
    6. Example: Using Ubuntu 22.04 Image
    7. 4. Specifying macOS Executor
    8. Example: macOS Executor Configuration
    9. 5. Configuring macOS Xcode Versions
    10. Example: Setting Xcode Version in CircleCI Config
    11. 6. Specifying Windows Executor
    12. Example: Using Windows Executor
    13. 7. Using Windows Orb
    14. Example: Using Windows Orb
    15. 8. Choosing Between Docker and Machine
    16. Comparison: Docker vs Machine Executors
    17. Example: Docker Executor Configuration
    18. Example: Machine Executor Configuration
    19. 9. Configuring Resource Classes
    20. Example: Setting Resource Class in Config
    21. 10. Using ARM Resources
    22. Example: ARM64 Configuration

  6. Creating Reusable Executors

    1. 1. Defining Executors
    2. Example: Defining a Docker Executor
    3. Example: Defining a Machine Executor
    4. 2. Creating Docker Executors
    5. Example: Basic Docker Executor Configuration
    6. Example: Executor with Custom Working Directory
    7. Example: Executor with Environment Variables
    8. 3. Creating Machine Executors
    9. Example: Defining a Machine Executor
    10. 4. Referencing Executors in Jobs
    11. Example: Referencing an Executor in a Job
    12. 5. Parameterizing Executors
    13. Example: Parameterized Executor
    14. Example: Using Parameterized Executor
    15. 6. Using Executor Parameters
    16. Example: Defining Executor Parameters
    17. Example: Using Executor Parameters in Jobs
    18. 7. Setting Default Parameter Values
    19. Example: Setting Default Parameter Values
    20. 8. Overriding Executor Settings
    21. Example: Overriding Environment Variables
    22. 9. Combining Executors with Resource Classes
    23. Example: Using Resource Class in Executor
    24. 10. Sharing Executors Across Jobs
    25. Example: Using a Shared Executor

  7. Working with Jobs

    1. 1. Defining Basic Jobs
    2. Example: Basic job definition
    3. 2. Adding Job Steps
    4. Example: Adding multiple steps
    5. 3. Setting Resource Classes
    6. Example: Using resource class
    7. 4. Configuring Job Environment
    8. Example: Setting environment variables
    9. 5. Using Working Directory
    10. Example: Setting working directory
    11. 6. Setting Job Shell
    12. Example: Using custom shell
    13. 7. Using Parallelism (parallelism key)
    14. Example: Using parallelism
    15. 8. Choosing Resource Classes
    16. Example: Choosing resource class
    17. 9. Using GPU Resources
    18. Example: Using GPU resources
    19. 10. Implementing Job Dependencies
    20. Example: Implementing job dependencies

  8. Working with Steps

    1. 1. Checking Out Code
    2. Example: Basic Checkout
    3. Example: Checkout to Custom Path
    4. 2. Running Shell Commands
    5. Example: Running a Multi-line Script
    6. 3. Naming Steps
    7. Example: Naming a Step
    8. 4. Using Step Conditionals
    9. Example: Using
    10. Example: Using
    11. 5. Setting Step Timeout
    12. Example: Setting Step Timeout
    13. 6. Running Background Commands
    14. Example: Running a Background Service
    15. 7. Using Working Directory in Steps
    16. Example: Setting Working Directory
    17. 8. Setting Step Environment
    18. Example: Setting Environment Variables
    19. Example: Using Resource Class
    20. 9. Using Shell Options
    21. Example: Setting shell options
    22. 10. Chaining Multiple Commands
    23. Example: Chaining commands in a single step

  9. Managing Caching

    1. 1. Understanding Cache Purpose
    2. Example: Caching Dependencies
    3. 2. Creating Cache Keys
    4. Example: Cache Key with Fallbacks
    5. 3. Using Template Variables
    6. Example: Using Variables in Config
    7. 4. Saving Cache
    8. Example: Saving Cache with CircleCI
    9. 5. Restoring Cache
    10. Example: Restoring Cache
    11. 6. Setting Cache Paths
    12. Example: Basic Cache Configuration
    13. Example: Cache with Fallback Keys
    14. 7. Caching Dependencies
    15. Example: Caching Node.js Dependencies
    16. 8. Using Multiple Restore Keys
    17. Example: Multiple Restore Keys Configuration
    18. 9. Implementing Partial Cache Restore
    19. Example: Restore cache with key pattern
    20. 10. Understanding Cache Expiration
    21. Example: Setting Cache TTL in Config
    22. 11. Optimizing Cache Size
    23. Example: Cache Size Configuration
    24. Cache Optimization Tips
    25. 12. Debugging Cache Misses
    26. Example: Cache miss debug output
    27. Cache Debugging Steps

  10. Using Workspaces for Data Sharing

    1. 1. Understanding Workspace Purpose
    2. Example: Storing Data in Workspace
    3. Example: Using Data from Workspace
    4. 2. Persisting Data to Workspace
    5. Example: Persisting Build Artifacts
    6. 3. Specifying Workspace Root
    7. Example: Setting Workspace Root
    8. 4. Adding Paths to Workspace (paths key)
    9. Example: Adding paths to workspace
    10. 5. Attaching Workspaces in Jobs
    11. Example: Attaching Workspace in a Job
    12. 6. Specifying Attachment Location
    13. Example: Attaching a Log File
    14. 7. Sharing Build Artifacts
    15. Example: Saving Build Artifacts
    16. Example: Using Artifacts in Another Job
    17. 8. Understanding Workspace Lifecycle
    18. Workspace Lifecycle Phases
    19. Key Points
    20. 9. Comparing Workspace vs Cache
    21. Workspace vs Cache
    22. 10. Optimizing Workspace Size
    23. Example: Exclude large files from workspace

  11. Managing Artifacts and Test Results

    1. 1. Storing Build Artifacts
    2. Example: Store Build Artifacts
    3. 2. Specifying Artifact Paths
    4. Example: Saving Test Results
    5. 3. Setting Artifact Destinations
    6. Example: Store Artifacts to Local Storage
    7. Example: Store Artifacts to S3
    8. 4. Accessing Artifacts via UI
    9. Steps to Access Artifacts in CircleCI UI
    10. 5. Downloading Artifacts via API
    11. Example: Download Artifact via API
    12. 6. Storing Test Results
    13. Example: Storing Test Results
    14. Example: Storing Artifacts
    15. 7. Using JUnit XML Format
    16. Example: Configuring JUnit XML Output
    17. 8. Using Custom Test Reporters
    18. Example: Custom Test Reporter Configuration
    19. 9. Understanding Artifact Retention
    20. Example: Setting Artifact Retention
    21. 10. Optimizing Artifact Storage
    22. Example: Storing Artifacts
    23. Example: Storing Test Results

  12. Working with Environment Variables

    1. 1. Defining Job-Level Variables
    2. Example: Setting Environment Variables
    3. 2. Defining Step-Level Variables
    4. Example: Setting Step-Level Variables
    5. 3. Referencing Variables in Config
    6. Example: Referencing Environment Variables
    7. Example: Using Context Variables
    8. Example: Parameter Variables in Config
    9. 4. Using Built-in Variables
    10. Example: Using Built-in Variables in a Script
    11. 5. Setting Project Variables
    12. Example: Setting a Project Variable via CLI
    13. Example: Using Project Variables in Configuration
    14. 6. Using Organization Variables
    15. Example: Setting an organization variable in a config
    16. 7. Setting Multiline Variables
    17. Example: Setting Multiline Variable in CircleCI Config
    18. 8. Escaping Special Characters
    19. Example: Using Escaped Characters in Environment Variables
    20. 9. Using Base64 Encoding
    21. Example: Encoding a Secret
    22. Example: Decoding a Secret
    23. 10. Debugging Variable Values
    24. Example: Print Environment Variables

  13. Managing Contexts

    1. 1. Understanding Context Purpose
    2. Example: Setting Environment Variables
    3. 2. Creating Contexts
    4. Example: Define a context with environment variables
    5. 3. Adding Variables to Contexts
    6. Example: Setting Environment Variables in a Job
    7. Example: Using Context Variables in a Pipeline
    8. 4. Using Contexts in Workflows
    9. Example: Using Context in a Workflow
    10. 5. Using Multiple Contexts
    11. Example: Defining Contexts in CircleCI Configuration
    12. 6. Restricting Context Access
    13. Example: Setting Context Permissions
    14. 7. Managing Context Permissions
    15. Example: Setting Context Permissions via API
    16. 8. Rotating Context Secrets
    17. Example: Rotating a Context Secret
    18. 9. Using Context Restrictions
    19. Example: Restricting Contexts in a Pipeline
    20. 10. Auditing Context Usage
    21. Example: Retrieving Context Variables
    22. Example: Listing All Contexts

  14. Managing Pipeline Parameters

    1. 1. Understanding Pipeline Parameters
    2. Example: Parameter Usage in Config
    3. 2. Defining Pipeline Parameters (parameters key)
    4. Example: Defining Parameters
    5. 3. Using Parameter Types
    6. Example: Enum Parameter
    7. 4. Setting Default Values
    8. Example: Default Value Usage
    9. 5. Referencing Parameters
    10. Example: Referencing Parameters in Steps
    11. 6. Using Parameters in Workflows
    12. Example: Workflow with Parameters
    13. 7. Using Parameters in Jobs
    14. Example: Job-Level Parameters
    15. 8. Validating Parameter Values
    16. Example: Validating String Parameters
    17. 9. Passing Parameters via API
    18. Example: API Call to Pass Parameters
    19. 10. Debugging Parameter Issues
    20. Common Debugging Tips
    21. Example: Debugging with Echo

  15. Managing Workflows

    1. 1. Defining Workflows
    2. Example: Basic Workflow Definition
    3. Example: Scheduled Workflow
    4. 2. Adding Jobs to Workflows
    5. Example: Adding Jobs to Workflow
    6. 3. Sequencing Jobs
    7. Example: Basic Job Dependencies
    8. Example: Matrix Job Configuration
    9. 4. Running Jobs in Parallel
    10. Example: Configuring Parallel Jobs
    11. 5. Configuring Workflow Parameters
    12. Example: Defining Workflow Parameters
    13. 6. Using Conditional Workflows
    14. Example: Conditional Job Execution
    15. Example: Branch-Based Conditional Workflow
    16. 7. Canceling Redundant Workflows
    17. Example: Canceling Redundant Workflows
    18. 8. Using Multiple Workflows
    19. Example: Defining Multiple Workflows
    20. Key Features of Multiple Workflows
    21. 9. Optimizing Workflow Graphs
    22. Example: Basic Workflow with Parallel Jobs
    23. Example: Optimized Workflow with Resource Class
    24. Optimization Tips
    25. 10. Naming Workflows
    26. Example: Defining a Workflow Name

  16. Filtering Workflows and Jobs

    1. 1. Filtering by Branch
    2. Example: Filtering by Branch
    3. 2. Filtering by Tag
    4. Example: Using Tag Filters in a Workflow
    5. Example: Excluding Jobs with a Specific Tag
    6. 3. Using Regex Patterns
    7. Example: Filtering by Branch Regex
    8. Example: Filtering by Tag Regex
    9. 4. Using Wildcard Patterns
    10. Example: Using Wildcard Patterns in Workflow Configuration
    11. 5. Combining Branch and Tag Filters
    12. Example: Combining Filters in Workflow
    13. 6. Understanding Filter Logic
    14. Example: Branch-based filtering
    15. Example: Tag-based filtering
    16. 7. Understanding Filter Precedence
    17. 8. Filtering Scheduled Workflows
    18. Example: Scheduled Workflow with Branch Filtering
    19. 9. Filtering API-Triggered Pipelines
    20. Example: Filtering by Branch
    21. Example: Filtering by Tag
    22. 10. Debugging Filter Issues
    23. Example: Using debug filter in CircleCI config
    24. Common Debugging Steps

  17. Scheduling Workflows

    1. 1. Using Scheduled Triggers
    2. Example: Basic Scheduled Workflow
    3. 2. Setting Cron Schedules
    4. Example: Cron Schedule Configuration
    5. 3. Understanding Cron Syntax
    6. Example: Cron Expression
    7. Common Cron Patterns
    8. 4. Specifying Schedule Timezone
    9. Example: Setting timezone in schedule
    10. 5. Filtering Scheduled Branches
    11. Example: Ignore specific branches
    12. 6. Setting Up Daily Builds
    13. Example: Daily Build Configuration
    14. 7. Setting Up Weekly Builds
    15. Example: Weekly Build Configuration
    16. 8. Using Multiple Schedules
    17. Example: Defining Multiple Schedules in a Workflow
    18. 9. Managing Scheduled Pipelines
    19. Example: Scheduling a Pipeline
    20. Scheduling Pipeline Management
    21. 10. Debugging Schedule Issues
    22. Example: Checking Workflow Schedules
    23. Common Schedule Debugging Steps

  18. Implementing Approval Jobs

    1. 1. Creating Manual Approval Jobs
    2. Example: Approval Job Configuration
    3. 2. Sequencing with Approval
    4. Example: Approval Job Configuration
    5. 3. Approving via Dashboard
    6. Example: Approval Job Configuration
    7. 4. Approving via API
    8. Example: Approving a Workflow via API
    9. 5. Using Approval for Deployments
    10. Example: Approval Job Configuration
    11. 6. Restricting Approval Permissions
    12. Example: Restricting Approval Permissions
    13. 7. Implementing Multi-Stage Approvals
    14. Example: Configuring Multi-Stage Approval Workflow
    15. 8. Setting Up Approval Notifications
    16. Example: Slack Notification Configuration
    17. Example: Email Notification Configuration
    18. 9. Handling Approval Timeouts
    19. Example: Setting Approval Timeout
    20. 10. Canceling Waiting Approvals
    21. Example: Canceling Approval Job via API

  19. Working with Orbs

    1. 1. Understanding Orbs
    2. Example: Using an Orb in a Configuration
    3. Key Features of Orbs
    4. 2. Importing Orbs
    5. Example: Importing an Orb
    6. 3. Using Certified Orbs
    7. Example: Using Python Orb
    8. 4. Specifying Orb Versions
    9. Example: Using Specific Orb Version
    10. Example: Using Orb Hash
    11. 5. Finding Orbs
    12. Example: Searching for Orbs
    13. How to Find Orbs
    14. 6. Viewing Orb Documentation
    15. Example: Accessing Orb Documentation
    16. 7. Using Orb Commands
    17. Example: Using a command with parameters
    18. 8. Using Orb Jobs
    19. Example: Using a job from an orb
    20. 9. Using Orb Executors
    21. Example: Using an Orb Executor
    22. 10. Parameterizing Orb Usage
    23. Example: Using Parameters in Orb Configuration

  20. Creating Custom Orbs

    1. 1. Initializing Orb Project
    2. Example: Initialize Orb Project
    3. 2. Defining Orb Commands
    4. Example: Basic Orb Command Definition
    5. Example: Command with Parameters
    6. 3. Creating Orb Jobs
    7. Example: Basic Orb Job
    8. Example: Orb Job with Parameters
    9. 4. Defining Orb Executors
    10. Example: Basic Executor Definition
    11. Example: Machine Executor
    12. Example: Resource Class Executor
    13. 5. Adding Orb Parameters
    14. Example: Defining Parameters in an Orb
    15. 6. Using Parameter Types
    16. Example: Using Parameter Types in an Orb
    17. 7. Testing Orbs Locally
    18. Example: Validating an Orb Configuration
    19. Example: Executing a Local Job Using an Orb
    20. 8. Using Development Versions
    21. Example: Using Development Orb in Config
    22. 9. Publishing Orbs
    23. Example: Publishing an Orb
    24. Steps to Publish an Orb
    25. 10. Versioning Orbs
    26. Example: Orb Version in config.yml
    27. 11. Managing Orb Namespaces
    28. Example: Creating a Namespace

  21. Configuring Docker Operations

    1. 1. Setting Up Remote Docker
    2. Example: Basic Remote Docker Configuration
    3. 2. Enabling Docker Layer Caching
    4. Example: Using cache-from in a CircleCI config
    5. Example: Using cache-from with multiple images
    6. Key Benefits of Docker Layer Caching
    7. 3. Building Docker Images
    8. Example: Building a Docker Image
    9. 4. Tagging Docker Images
    10. Example: Using CircleCI's built-in Docker tagging
    11. 5. Pushing to Registries
    12. Example: Pushing to Docker Hub
    13. Example: Pushing to Amazon ECR
    14. 6. Authenticating with Docker Hub
    15. Example: Configuring Docker Login in CircleCI
    16. 7. Using Private Registries
    17. Example: Using a Private Docker Image from ECR
    18. 8. Using Docker Compose
    19. Example: Running a Node.js App with Docker Compose
    20. Key Points
    21. 9. Running Multi-Container Tests
    22. Example: Running Multi-Container Tests
    23. 10. Optimizing Docker Builds
    24. Example: Caching Dependencies
    25. 11. Using BuildKit Features
    26. Example: Enabling BuildKit in CircleCI
    27. 12. Debugging Docker Issues
    28. Example: Debugging a failing Docker build
    29. Debugging Steps

  22. Implementing Conditional Logic

    1. 1. Using When Conditions
    2. Example: Using
    3. Example: Using
    4. 2. Using Unless Conditions
    5. Example: Skip job based on branch
    6. Example: Skip job based on environment variable
    7. 3. Using Step Conditionals
    8. Example: Using
    9. 4. Using Workflow Conditionals
    10. Example: Branch-based conditional workflow
    11. Example: Tag-based conditional workflow
    12. 5. Using Logic Operators
    13. Example: Using
    14. Example: Using
    15. Example: Using
    16. 6. Comparing Values
    17. Example: Using comparison operators in a job condition
    18. Example: Using multiple conditions with logical operators
    19. 7. Using Pipeline Values
    20. Example: Using pipeline values in a job
    21. 8. Using Parameter-Based Conditions
    22. Example: Using Parameters in a Job Condition
    23. Example: Conditional Step Based on Parameter
    24. 9. Implementing Branch-Based Logic
    25. Example: Branch-Based Conditional Job
    26. 10. Combining Multiple Conditions
    27. Example: Combining Conditions in a Workflow
    28. Example: Complex Nested Conditions

  23. Working with Test Splitting

    1. 1. Understanding Test Splitting
    2. Example: Enabling Test Splitting in CircleCI
    3. 2. Using circleci tests split
    4. Example: Splitting tests by name
    5. Example: Splitting tests by time
    6. 3. Splitting by Filename
    7. Example: Configuring test splitting by filename
    8. 4. Splitting by Timing
    9. Example: Configuring Test Splitting by Timing
    10. 5. Splitting by Filesize
    11. Example: Configuring Test Splitting by Filesize
    12. 6. Generating File Lists
    13. Example: Splitting Tests by File Size
    14. 7. Using Parallelism (parallelism key)
    15. Example: Setting parallelism in config
    16. 8. Collecting Timing Data
    17. Example: Collecting Test Timing Data
    18. 9. Using Test Environment Variables
    19. Example: Setting Test Environment Variables
    20. 10. Balancing Test Distribution
    21. Example: Configuring Test Splitting in CircleCI

  24. Working with Matrix Jobs

    1. 1. Understanding Matrix Jobs
    2. Example: Matrix Job Configuration
    3. Key Points
    4. 2. Defining Matrix Parameters
    5. Example: Defining a Matrix with Values
    6. 3. Specifying Parameter Values
    7. Example: Matrix job configuration with parameters
    8. Example: Using matrix to run tests across multiple versions
    9. 4. Expanding Matrix Combinations
    10. Example: Expanding Matrix Combinations
    11. 5. Using Matrix with Workflows
    12. Example: Matrix Job in Workflow
    13. Example: Matrix with Exclude
    14. Example: Matrix with Include
    15. 6. Excluding Combinations
    16. Example: Excluding a specific combination
    17. 7. Testing Multiple Versions
    18. Example: Matrix Job Configuration
    19. 8. Testing Multiple Platforms
    20. Example: Matrix Job Configuration for Platforms
    21. 9. Parameterizing Executors
    22. Example: Parameterized Executor
    23. Example: Using Parameterized Executor
    24. 10. Debugging Matrix Issues
    25. Example: Matrix Job Debug Output
    26. Common Matrix Debugging Tips

  25. Implementing Dynamic Configuration

    1. 1. Understanding Dynamic Config
    2. Example: Basic Dynamic Config
    3. 2. Enabling Dynamic Config (setup: true)
    4. Example: Enabling Dynamic Config in config.yml
    5. 3. Creating Setup Workflows
    6. Example: Basic setup workflow configuration
    7. 4. Generating Config Dynamically
    8. Example: Using Environment Variables in Config
    9. Example: Conditional Job Execution
    10. Dynamic Configuration Best Practices
    11. 5. Using Continuation Orb
    12. Example: Using Continuation Orb
    13. 6. Using Path Filtering
    14. Example: Path Filtering Configuration
    15. 7. Detecting Changed Files
    16. Example: Using changed files in a job
    17. 8. Conditionally Executing Jobs
    18. Example: Using
    19. Example: Using
    20. 9. Implementing Monorepo Support
    21. Example: Configuring CircleCI for a Monorepo
    22. 10. Debugging Dynamic Config
    23. Example: Using
    24. Example: Logging Variables in Dynamic Config
    25. Common Debugging Techniques

  26. Managing SSH Keys

    1. 1. Adding SSH Keys to Project
    2. Example: Adding SSH Key via CircleCI Web UI
    3. 2. Using add_ssh_keys Step
    4. Example: Enabling SSH access
    5. 3. Specifying Key Fingerprints
    6. Example: Adding SSH Key with Fingerprint
    7. 4. Using Deploy Keys
    8. Example: Adding Deploy Key to CircleCI Project
    9. 5. Using User Keys
    10. Example: Adding an SSH User Key
    11. Example: Listing SSH User Keys
    12. 6. Configuring SSH for Git Operations
    13. Example: SSH Key Configuration
    14. 7. Using SSH for Remote Servers
    15. Example: SSH Configuration in CircleCI
    16. 8. Managing Multiple SSH Keys
    17. Example: Adding SSH Key to Project
    18. 9. Rotating SSH Keys
    19. 10. Debugging SSH Issues
    20. Example: SSH debug command in CircleCI config

  27. Working with SSH Debugging

    1. 1. Enabling SSH Access
    2. Example: Enabling SSH in a CircleCI Configuration
    3. 2. Connecting via SSH
    4. Example: Enabling SSH in a Job
    5. 3. Understanding SSH Session Limits
    6. 4. Debugging Build Failures
    7. Example: SSH into a Build Container
    8. Example: Inspecting Environment Variables
    9. Example: Running Commands in Debug Mode
    10. Common Build Failure Causes
    11. 5. Inspecting Build Environment
    12. Example: Print Environment Variables
    13. Example: List Files in Working Directory
    14. 6. Testing Commands Interactively
    15. Example: SSH into a CircleCI Job
    16. 7. Checking Environment Variables
    17. Example: Print All Environment Variables
    18. 8. Inspecting Installed Tools
    19. Example: Check Node.js version
    20. Example: List installed packages
    21. 9. Debugging Permission Issues
    22. Example: Setting SSH key permissions
    23. 10. Extending SSH Session
    24. Example: Enabling SSH in a CircleCI Job
    25. SSH Session Extension Guidelines

  28. Handling Timeouts and Retries

    1. 1. Setting No Output Timeout
    2. Example: Configuring no_output_timeout
    3. 2. Setting Step Timeout
    4. Example: Setting a 5-minute timeout for a build step
    5. 3. Understanding Default Timeouts
    6. 4. Configuring Long-Running Jobs
    7. Example: Setting a 1-hour timeout for a long-running job
    8. 5. Implementing Retry Logic
    9. Example: Retry Configuration
    10. 6. Using Retry with Backoff
    11. Example: Retry with Backoff Configuration
    12. 7. Handling Flaky Tests
    13. Example: Retry Configuration
    14. Best Practices for Flaky Tests
    15. 8. Setting API Request Timeouts
    16. Example: Configuring API timeouts in config.yml
    17. 9. Using Background Steps
    18. Example: Running a Background Service
    19. 10. Debugging Timeout Causes
    20. Example: Debugging a Timeout in CircleCI
    21. Timeout Debugging Summary

  29. Debugging Build Failures

    1. 1. Reading Build Logs
    2. Example: Filtering Logs in CircleCI Web UI
    3. 2. Validating Config Syntax
    4. Example: Validating a config file
    5. Example: Processing a config file
    6. 3. Using SSH Debugging
    7. Example: Enable SSH access to a job
    8. Steps to use SSH debugging:
    9. SSH Debugging Overview
    10. 4. Checking Environment Variables
    11. Example: Print All Environment Variables
    12. 5. Inspecting Cache Behavior
    13. Example: Cache Configuration
    14. 6. Debugging Workspace Issues
    15. Example: Saving and Restoring Workspace
    16. 7. Testing Steps Locally
    17. Example: Running a CircleCI Job Locally
    18. 8. Using on_fail Steps
    19. Example: on_fail with cleanup
    20. 9. Checking Resource Limits
    21. Example: Setting Resource Limits in Config
    22. 10. Analyzing Test Failures
    23. Example: Viewing Test Logs
    24. Example: Accessing Build Artifacts

  30. Troubleshooting Common Issues

    1. 1. Resolving Config Validation Errors
    2. Example: Valid Config Snippet
    3. 2. Fixing Checkout Failures
    4. Example: Setting Checkout Path
    5. 3. Debugging Cache Misses
    6. Example: Cache Configuration
    7. Debugging Steps for Cache Misses
    8. Common Cache Key Patterns
    9. 4. Resolving Dependency Issues
    10. Example: Install missing dependencies
    11. Example: Resolve version conflicts
    12. 5. Fixing Docker Errors
    13. Example: Fixing Docker Image Pull Issues
    14. 6. Handling Out of Memory Errors
    15. Example: Increasing Memory Limit in Node.js
    16. Memory Management Best Practices
    17. 7. Resolving Network Timeouts
    18. Example: Configuring Retry Logic
    19. 8. Fixing Flaky Tests
    20. Example: Adding retry logic to a test
    21. Common Causes of Flaky Tests
    22. Flaky Test Fix Approaches
    23. 9. Debugging Workflow Filters
    24. Example: Debugging a workflow filter
    25. Common Debugging Steps
    26. 10. Resolving Permission Errors
    27. Example: Setting SSH key permissions

  31. Managing Secrets and Security

    1. 1. Storing Secrets in Contexts
    2. Example: Defining a Context with Secrets
    3. Example: Using Context Secrets in a Job
    4. 2. Using Project Environment Variables
    5. Example: Using Environment Variables in a Script
    6. 3. Masking Secrets in Logs
    7. Example: Environment Variable Usage
    8. 4. Avoiding Hardcoded Secrets
    9. Example: Using Environment Variables
    10. Key Takeaways
    11. 5. Rotating Credentials Regularly
    12. Example: Rotating an API Token
    13. 6. Implementing Least Privilege
    14. Example: Setting up a job with minimal permissions
    15. Best Practices for Least Privilege
    16. 7. Using OIDC Tokens
    17. Example: Using OIDC Token in a Job
    18. 8. Restricting Context Access
    19. Example: Creating a Context with Restricted Access
    20. 9. Managing SSH Keys Securely
    21. 10. Auditing Secret Usage
    22. Example: Secret Usage Audit Log

  32. Implementing Security Best Practices

    1. 1. Using OIDC for Cloud Access
    2. Example: Configure OIDC for AWS Access
    3. 2. Configuring IP Ranges
    4. Example: Configuring IP Ranges in CircleCI
    5. 3. Using Signed Commits
    6. Example: Setting up GPG for Signed Commits
    7. Example: Verifying a Signed Commit
    8. 4. Scanning for Vulnerabilities
    9. Example: Dependency Scan Configuration
    10. Example: Container Scan Configuration
    11. 5. Implementing SAST
    12. Example: SAST Configuration in CircleCI
    13. 6. Implementing DAST
    14. Example: Configuring DAST in CircleCI
    15. 7. Using Container Scanning
    16. Example: Enabling Container Scanning
    17. 8. Enabling Audit Logs
    18. Example: Configuring Audit Logs in CircleCI
    19. Key Points
    20. 9. Preventing Secret Leakage
    21. Example: Using CircleCI Environment Variables
    22. Best Practices for Secret Management
    23. 10. Configuring Build Forked PRs
    24. Example: Enabling forked PR builds

  33. Optimizing Build Performance

    1. 1. Using Parallelism Effectively
    2. Example: Setting parallelism in a workflow
    3. 2. Choosing Optimal Resource Classes
    4. Example: Setting Resource Class in Config
    5. 3. Running Jobs in Parallel
    6. Example: Parallel Jobs Configuration
    7. Example: Matrix Configuration
    8. 4. Enabling Docker Layer Caching
    9. Example: Enabling Docker Layer Caching
    10. 5. Optimizing Cache Usage
    11. Example: Using CircleCI's Built-in Caching
    12. Example: Cache with Multiple Paths
    13. Best Practices for Cache Optimization
    14. 6. Using Workspaces Efficiently
    15. Example: Save and Restore Workspace
    16. 7. Splitting Tests Intelligently
    17. Example: Splitting Tests by Size
    18. Best Practices for Test Splitting
    19. 8. Optimizing Dependency Installation
    20. Example: Caching Dependencies in CircleCI
    21. 9. Reducing Checkout Time
    22. Example: Skip checkout for non-source jobs
    23. 10. Using Orbs for Common Tasks
    24. Example: Using Node.js Orb

  34. Optimizing Resource Usage and Costs

    1. 1. Choosing Resource Classes
    2. Example: Setting Resource Class
    3. 2. Using ARM Resources
    4. Example: Using ARM Resources in a Job
    5. 3. Optimizing for Cost
    6. Example: Using Smaller Instance Types
    7. Example: Caching Dependencies
    8. 4. Monitoring Credit Usage
    9. Example: Querying Credit Usage via API
    10. Credit Usage Summary
    11. 5. Implementing Concurrency Limits
    12. Example: Setting Concurrency Limits in config.yml
    13. 6. Reducing Build Minutes
    14. Example: Using CircleCI's Resource Class
    15. Best Practices for Reducing Build Minutes
    16. 7. Using Free Tier Efficiently
    17. Example: Optimizing Build Minutes
    18. Best Practices for Free Tier Efficiency
    19. 8. Analyzing Resource Bottlenecks
    20. Example: Identifying High CPU Jobs
    21. Common Resource Bottleneck Indicators
    22. 9. Balancing Speed vs Cost
    23. Example: Resource Class Configuration
    24. Speed vs Cost Trade-offs
    25. 10. Canceling Redundant Builds
    26. Example: Configuring Build Cancellation
    27. Build Cancellation Rules

  35. Managing Self-Hosted Runners

    1. 1. Understanding Self-Hosted Runners
    2. Example: Runner Registration
    3. 2. Installing Runner Agent
    4. Example: Install Runner Agent on Linux
    5. 3. Configuring Runner Agent
    6. Example: Runner Configuration File
    7. 4. Creating Custom Resource Classes
    8. Example: Define Custom Resource Class
    9. 5. Assigning Jobs to Runners
    10. Example: Assigning Jobs to Runners
    11. Example: Using Tags to Select Runners
    12. 6. Using Docker on Runners
    13. Example: Using Docker Image
    14. Example: Mounting Volumes
    15. 7. Monitoring Runner Health
    16. Example: Health Check Endpoint
    17. Key Metrics to Monitor
    18. 8. Scaling Runner Infrastructure
    19. Example: Auto-scaling Configuration
    20. Scaling Strategies
    21. 9. Implementing Runner Security
    22. Example: Configuring Runner Security Settings
    23. Security Best Practices
    24. 10. Updating Runner Agent
    25. Example: Update Runner Agent to Latest Version
    26. Example: Update Runner Agent to Specific Version

  36. Configuring Notifications

    1. 1. Using Slack Orb
    2. Example: Slack Notification Configuration
    3. 2. Sending Email Notifications
    4. Example: Email Notification Configuration
    5. 3. Using Webhook Notifications
    6. Example: Configuring Webhook Notification
    7. 4. Notifying on Failure
    8. Example: Slack Notification on Build Failure
    9. Example: Email Notification on Failure
    10. 5. Notifying on Success
    11. Example: Configuring Success Notification
    12. 6. Using Custom Notifications
    13. Example: Custom Notification Configuration
    14. Custom Notification Summary
    15. 7. Configuring Chat Integrations
    16. Example: Slack Integration
    17. Example: Microsoft Teams Integration
    18. Example: Discord Integration
    19. 8. Setting Notification Preferences
    20. Example: Configuring Notification Preferences
    21. 9. Using Status Badges
    22. Example: Adding Build Badge to README
    23. 10. Muting Notifications
    24. Example: Muting All Notifications

  37. Working with Insights and Analytics

    1. 1. Viewing Workflow Insights
    2. Example: Accessing Workflow Insights
    3. Key Metrics Provided
    4. 2. Analyzing Build Duration
    5. Example: Build Duration Query
    6. 3. Tracking Success Rates
    7. Example: Calculating Build Success Rate
    8. 4. Identifying Flaky Tests
    9. Example: Enabling Flaky Test Detection
    10. How It Works
    11. 5. Viewing Failed Job Analysis
    12. Example: Failed Job Analysis
    13. 6. Analyzing Cache Performance
    14. Example: Cache Performance Metrics
    15. Key Metrics to Monitor
    16. 7. Tracking Build Frequency
    17. Example: Build Frequency Configuration
    18. 8. Using Credits Dashboard
    19. Example: View Credit Balance
    20. Credit Usage Summary
    21. 9. Monitoring Parallelism Usage
    22. Example: Configuring parallelism in config.yml
    23. Usage Guidelines
    24. 10. Exporting Insights Data
    25. Example: Exporting Pipeline Metrics
    26. Example: Exporting Workflow Metrics
    27. Exporting Insights Data Summary

  38. Using CircleCI API

    1. 1. Authenticating with API
    2. Example: Using Personal API Token
    3. 2. Triggering Pipelines
    4. Example: Triggering a Pipeline
    5. 3. Getting Pipeline Status
    6. Example: Fetch Pipeline Status
    7. 4. Listing Workflows
    8. Example: Fetching Workflows
    9. 5. Getting Job Details
    10. Example: Fetch Job Details
    11. 6. Canceling Workflows
    12. Example: Cancel a Workflow via API
    13. 7. Rerunning Workflows
    14. Example: Rerun a Workflow via API
    15. 8. Downloading Artifacts
    16. Example: Downloading Artifacts via API
    17. 9. Managing Environment Variables
    18. Example: Setting Environment Variables via API
    19. Example: Listing Environment Variables
    20. Example: Deleting an Environment Variable
    21. 10. Using API v2
    22. Example: Triggering a Pipeline
    23. 11. Handling Rate Limits
    24. Example: Retry Logic with Exponential Backoff

  39. Implementing Deployment Strategies

    1. 1. Deploying to AWS
    2. Example: Deploying to AWS S3
    3. Example: Deploying to AWS ECS
    4. 2. Deploying to Google Cloud
    5. Example: Deploying to Google App Engine
    6. Example: Deploying to Google Kubernetes Engine
    7. 3. Deploying to Azure
    8. Example: Deploying to Azure Web App
    9. 4. Deploying to Kubernetes
    10. Example: CircleCI Kubernetes Orb Configuration
    11. Deployment Steps Overview
    12. 5. Deploying to Heroku
    13. Example: CircleCI Configuration for Heroku Deployment
    14. Deployment Workflow Summary
    15. 6. Using Deployment Gates
    16. Example: Manual Approval Gate
    17. Example: Status Check Gate
    18. 7. Implementing Blue-Green Deployments
    19. Example: Blue-Green Deployment Configuration in CircleCI
    20. Benefits of Blue-Green Deployments
    21. 8. Implementing Canary Deployments
    22. Example: Canary Deployment Configuration
    23. 9. Implementing Rolling Updates
    24. Example: Rolling Update Configuration
    25. 10. Rolling Back Deployments
    26. Example: Rollback Configuration
    27. Rollback Process Overview

  40. Working with GitHub Integration

    1. 1. Connecting GitHub Repository
    2. Example: GitHub Webhook Configuration
    3. 2. Configuring Status Checks
    4. Example: Enabling GitHub Status Checks
    5. 3. Using GitHub Checks API
    6. Example: Posting GitHub Check Run
    7. Example: Updating GitHub Check Run
    8. 4. Setting Up Branch Protection
    9. Example: GitHub Branch Protection Configuration
    10. 5. Configuring Webhooks
    11. Example: Webhook Configuration
    12. 6. Using PR-Only Workflows
    13. Example: Configuring a PR-Only Workflow
    14. 7. Triggering on PR Events
    15. Example: Configuring PR Triggers
    16. 8. Commenting on PRs
    17. Example: Comment on PR
    18. 9. Syncing Organization Settings
    19. Example: Configure Branch Sync
    20. 10. Debugging Integration Issues
    21. Example: Checking Webhook Status in GitHub

  41. Working with Bitbucket and GitLab Integration

    1. 1. Connecting Bitbucket Repository
    2. Example: Enabling a Bitbucket Project in CircleCI
    3. 2. Connecting GitLab Repository
    4. Example: GitLab Webhook Configuration
    5. 3. Configuring Webhooks (automatic triggers)
    6. Example: Webhook Configuration in CircleCI
    7. 4. Setting Up Status Checks
    8. Example: Configuring Status Checks in CircleCI
    9. 5. Using Branch Restrictions
    10. Example: Restricting Branch Access
    11. 6. Triggering on PR Events
    12. Example: Configuring PR Triggers
    13. 7. Commenting on Merge Requests
    14. Example: Post a comment on a merge request
    15. 8. Using Repository Variables
    16. Example: Using Repository Variables in a Build Script
    17. 9. Managing Multiple VCS Providers
    18. Example: Configuring Bitbucket and GitLab in the Same Project
    19. Managing Multiple VCS Providers
    20. 10. Debugging Integration Issues
    21. Common Debugging Steps
    22. Example: Checking Build Logs for Errors

  42. Managing Project Settings

    1. 1. Configuring Project Settings
    2. Example: Configuring Project Settings
    3. 2. Adding Environment Variables
    4. Example: Setting Environment Variables in CircleCI Config
    5. 3. Managing SSH Keys
    6. Example: Adding SSH Key to Project
    7. 4. Setting Up Outbound Webhooks
    8. Example: Webhook Configuration
    9. 5. Configuring Auto-Cancel
    10. Example: Enabling auto-cancel in config
    11. 6. Setting Build Forked PRs
    12. Example: Configuring build_forked_pull_requests
    13. 7. Enabling Advanced Features
    14. Example: Enabling Workflows
    15. 8. Managing Build Timeouts
    16. Example: Setting build timeout in config.yml
    17. 9. Configuring Follow Project
    18. Example: Enabling Follow Project
    19. 10. Archiving Projects
    20. Example: Archive a Project via API

  43. Migrating to CircleCI

    1. 1. Migrating from Jenkins
    2. Example: Basic Pipeline Migration
    3. Migration Considerations
    4. 2. Migrating from Travis CI
    5. Example: Basic Migration
    6. Key Differences
    7. 3. Migrating from GitHub Actions
    8. Example: Migrating a simple job
    9. Key Differences
    10. 4. Migrating from GitLab CI
    11. Example: Basic Pipeline Migration
    12. Key Differences
    13. Migration Steps
    14. 5. Converting Pipeline Syntax
    15. Example: Converting from v2 to v2.1
    16. 6. Mapping Environment Variables
    17. Example: Using Environment Variables in Config
    18. 7. Migrating Secrets
    19. Example: Setting Environment Variables
    20. 8. Adapting Build Scripts
    21. Example: Migrating a Simple Build Script
    22. 9. Using Migration Tools
    23. Example: Migrating from Travis CI to CircleCI
    24. Example: Equivalent CircleCI Configuration
    25. Migration Steps Overview
    26. 10. Testing Migration Incrementally
    27. Migration Workflow
    28. Old vs New Test Environments
    29. Example: Running Tests in Parallel