Skip to main content
Mapagam

46 SECTIONS · 1288 TOPICS

Github Actions Roadmap

  1. Understanding GitHub Actions Core Concepts

    1. 1. Understanding Workflows
    2. Example: Basic Workflow Configuration
    3. 2. Understanding Jobs
    4. Example: Basic Job Definition
    5. 3. Understanding Steps
    6. Example: Using a built-in action
    7. Example: Using a custom action with inputs
    8. 4. Understanding Actions
    9. Example: Using a GitHub Action
    10. Action Types
    11. 5. Understanding Runners
    12. Example: Self-hosted runner registration
    13. 6. Understanding Events
    14. Example: Push Event Configuration
    15. Example: Scheduled Workflow
    16. 7. Understanding Contexts
    17. Example: Using GitHub Context in a Workflow
    18. Key Points About Contexts
    19. 8. Understanding YAML Syntax
    20. Example: Basic Workflow Structure
    21. 9. Understanding Workflow Execution Model
    22. Example: Basic Workflow Execution Flow
    23. Execution Lifecycle
    24. 10. Understanding Billing and Quotas
    25. Example: Billing Alert
    26. Key Billing Points

  2. Setting Up Workflow Files

    1. 1. Creating Workflow File
    2. Example: Basic workflow file structure
    3. 2. Naming Workflows
    4. Example: Setting Workflow Name
    5. 3. Defining Workflow Syntax
    6. Example: Basic Workflow Syntax
    7. 4. Using Workflow Templates
    8. Example: Using a GitHub-provided workflow template
    9. How to Use Templates
    10. 5. Organizing Multiple Workflows
    11. Workflow Organization Strategy
    12. Example: Workflow File Organization
    13. 6. Validating Workflow Syntax
    14. Example: Basic workflow syntax validation
    15. 7. Setting Workflow Defaults
    16. Example: Setting Default Shell and Working Directory
    17. 8. Disabling Workflows
    18. Example: Disabling Workflow via Configuration
    19. 9. Versioning Workflows
    20. Example: Using v3 in workflow file
    21. 10. Inheriting Workflow Settings
    22. Example: Reusing a Workflow
    23. Example: Inheriting from Reusable Workflow

  3. Working with Workflow Triggers

    1. 1. Triggering on Push Events
    2. Example: Basic Push Trigger
    3. Example: Push with Path Filtering
    4. Example: Push with Tag Filtering
    5. 2. Triggering on Pull Requests
    6. Example: Trigger on pull request
    7. Key Points
    8. 3. Triggering Manually
    9. Example: Manual Trigger with Inputs
    10. 4. Triggering on Schedule
    11. Example: Schedule Trigger
    12. Schedule Trigger Details
    13. 5. Triggering on Issues
    14. Example: Automatically assign issues to a team member
    15. Example: Comment on issue when labeled
    16. 6. Triggering on Releases
    17. Example: Release Trigger Configuration
    18. 7. Triggering on Repository Events
    19. Example: Triggering on Push to Main Branch
    20. Example: Triggering on Pull Request
    21. 8. Triggering on Forks
    22. Example: Using
    23. 9. Using Activity Types
    24. Example: Using
    25. Example: Using
    26. Example: Using
    27. 10. Combining Multiple Triggers
    28. Example: Combining push and pull_request triggers
    29. Example: Using schedule and workflow_dispatch together
    30. 11. Filtering by Branches and Tags
    31. Example: Filtering by Branches
    32. Example: Filtering by Tags
    33. 12. Using Webhook Events
    34. Example: Using push event
    35. Example: Using pull_request event

  4. Working with Path Filtering

    1. 1. Filtering by Changed Paths
    2. Example: Using path filters in a workflow
    3. 2. Ignoring Paths
    4. Example: Using paths-ignore
    5. 3. Using Glob Patterns
    6. Example: Filtering by file extension
    7. Example: Excluding directories
    8. 4. Filtering Documentation Changes
    9. Example: Using Path Filters in a Workflow
    10. 5. Filtering Source Code
    11. Example: Using path filters in a workflow
    12. 6. Filtering by File Extensions
    13. Example: Using file extension filtering in a workflow
    14. 7. Using Negation Patterns
    15. Example: Exclude JavaScript files in src directory
    16. 8. Combining Path and Branch Filters
    17. Example: Combining Path and Branch Filters
    18. 9. Detecting Modified Files
    19. Example: Check if a file was modified
    20. 10. Running Conditional Steps
    21. Example: Using
    22. Example: Complex condition with
    23. 11. Using Path Filters with Matrix
    24. Example: Path Filtered Matrix Job
    25. 12. Optimizing CI with Path Filters
    26. Example: Using path filters to optimize CI
    27. Best Practices for Path Filters

  5. Configuring Jobs

    1. 1. Defining Jobs
    2. Example: Basic job definition
    3. 2. Naming Jobs
    4. Example: Setting a Job Name
    5. 3. Setting Job Dependencies
    6. Example: Basic Job Dependencies
    7. Example: Multiple Job Dependencies
    8. 4. Running Jobs Conditionally
    9. Example: Conditional Job Execution
    10. Example: Matrix Strategy
    11. 5. Specifying Runner Type
    12. Example: Using Ubuntu 22.04 runner
    13. 6. Configuring Job Timeout
    14. Example: Setting Job Timeout
    15. 7. Setting Job Strategy
    16. Example: Matrix Strategy
    17. 8. Setting Job Outputs
    18. Example: Setting a Job Output
    19. 9. Configuring Job Environment
    20. Example: Setting Environment Variables
    21. Example: Setting Default Shell
    22. 10. Using Job Containers
    23. Example: Using a PostgreSQL container
    24. 11. Configuring Service Containers
    25. Example: Using a PostgreSQL Service Container
    26. 12. Setting Job Concurrency
    27. Example: Setting concurrency with a string
    28. Example: Setting concurrency with an object

  6. Working with Steps

    1. 1. Defining Steps
    2. 2. Naming Steps
    3. Example: Naming Steps
    4. 3. Running Shell Commands
    5. Example: Running Shell Commands
    6. 4. Using Actions
    7. 5. Setting Step Conditions
    8. 6. Setting Step Timeout
    9. Example: Setting Step Timeout
    10. 7. Setting Step Shell
    11. 8. Setting Working Directory
    12. Example: Setting Working Directory
    13. 9. Configuring Step Environment Variables
    14. Example: Setting Environment Variables
    15. 10. Handling Step Failures
    16. 11. Using Step Outputs
    17. Example: Using Step Outputs
    18. 12. Running Steps in Containers
    19. Example: Running Steps in Containers

  7. Configuring GitHub-Hosted Runners

    1. 1. Using GitHub-Hosted Runners
    2. Example: Using ubuntu-latest runner
    3. 2. Specifying Runner OS
    4. Example: Setting OS for workflow
    5. 3. Using Latest Runner Images
    6. Example: Using Latest Ubuntu Runner
    7. Example: Using Ubuntu 24.04 Runner
    8. 4. Using Specific Runner Versions
    9. Example: Specifying runner version in workflow
    10. 5. Running on Multiple OS
    11. Example: Matrix Strategy for Multiple OS
    12. 6. Using Larger Runners
    13. Example: Using larger runner in workflow
    14. 7. Using Runner Context
    15. Example: Using runner context in a job
    16. 8. Checking Runner Capabilities
    17. Example: Using runner capabilities in a workflow
    18. 9. Using Pre-installed Tools
    19. Example: Using pre-installed Node.js in a workflow
    20. 10. Accessing Runner Workspace
    21. Example: Using Workspace in a Job

  8. Managing Self-Hosted Runners

    1. 1. Installing Runner Application
    2. Example: Install GitHub Actions Runner on Linux
    3. 2. Configuring Runner
    4. Example: Runner Configuration File
    5. 3. Running as Service
    6. Example: systemd service configuration
    7. Service Management Commands
    8. 4. Using Runner Labels
    9. Example: Assigning Labels to Runners
    10. 5. Setting Up Runner Groups
    11. Example: Create a Runner Group
    12. Example: Add a Runner to a Group
    13. Runner Group Management
    14. 6. Configuring Proxy
    15. Example: Setting proxy in runner configuration
    16. 7. Using Ephemeral Runners
    17. Example: Configuring Ephemeral Runner
    18. 8. Setting Runner Work Directory
    19. Example: Configuring Work Directory
    20. 9. Managing Runner Updates
    21. Example: Update Runner
    22. 10. Removing Runners
    23. Example: Remove a Self-Hosted Runner via API
    24. 11. Monitoring Runner Status
    25. Example: Check runner status via API
    26. Workflow: Monitor runner health
    27. 12. Cleaning Up After Jobs
    28. Example: Using cleanup scripts in workflow

  9. Using Built-in Actions

    1. 1. Checking Out Code
    2. Example: Basic checkout
    3. Example: Checkout specific branch
    4. Example: Checkout with custom path
    5. 2. Setting Up Node.js
    6. Example: Setting up Node.js with caching
    7. 3. Setting Up Python
    8. Example: Setting up Python with pip caching
    9. 4. Setting Up Java
    10. Example: Setting up Java 17 with Maven caching
    11. 5. Setting Up Go
    12. Example: Setting up Go in a workflow
    13. 6. Setting Up .NET
    14. Example: Setting up .NET Core 8.0
    15. 7. Setting Up Ruby
    16. Example: Setting up Ruby with Bundler caching
    17. 8. Caching Dependencies
    18. Example: Caching npm dependencies
    19. Example: Caching Gradle dependencies
    20. 9. Uploading Artifacts
    21. Example: Upload a build artifact
    22. 10. Downloading Artifacts
    23. Example: Downloading a Single Artifact
    24. Example: Download All Artifacts
    25. 11. Using GitHub Script
    26. Example: Basic Script Usage
    27. Example: Using Context Variables
    28. 12. Setting Up Docker Buildx
    29. Example: Setting up Docker Buildx

  10. Working with Expressions and Contexts

    1. 1. Evaluating Expressions
    2. Example: Using Expressions in Conditions
    3. Example: Combining Expressions
    4. 2. Using GitHub Context
    5. Example: Accessing GitHub Context in a Job
    6. 3. Using Env Context
    7. Example: Setting and Using Environment Variables
    8. 4. Using Job Context
    9. Example: Using job context in a condition
    10. 5. Using Steps Context
    11. Example: Accessing Step Outputs
    12. 6. Using Runner Context
    13. Example: Using runner context in a job
    14. 7. Using Secrets Context
    15. Example: Using a Secret in a Workflow
    16. 8. Using Strategy Context
    17. Example: Using strategy.fail-fast
    18. Example: Using strategy.max-parallel
    19. Example: Using strategy.matrix
    20. 9. Using Needs Context
    21. Example: Accessing outputs from a previous job
    22. 10. Using Inputs Context
    23. Example: Accessing input value
    24. 11. Using Boolean Expressions
    25. Example: Using Boolean Expressions in Conditions
    26. 12. Using Comparison Operators
    27. Example: Using
    28. Example: Using

  11. Working with Expression Functions

    1. 1. Using contains() Function
    2. 2. Using startsWith() Function
    3. Example: Using startsWith() in a GitHub Actions Workflow
    4. 3. Using endsWith() Function
    5. Example: Using endsWith() in a Condition
    6. 4. Using format() Function
    7. Example: Using format() in a GitHub Action
    8. 5. Using join() Function
    9. Example: Joining Array Elements
    10. Example: Joining with Custom Separator
    11. 6. Using toJSON() Function
    12. Example: Converting Object to JSON String
    13. 7. Using fromJSON() Function
    14. Example: Parsing JSON String
    15. 8. Using hashFiles() Function
    16. Example: Caching Dependencies Based on Lock File Changes
    17. 9. Using success() Function
    18. Example: Using success() in a conditional
    19. 10. Using failure() Function
    20. Example: Using failure() in a conditional
    21. 11. Using always() Function
    22. Example: Using always() in a job
    23. 12. Using cancelled() Function
    24. Example: Using cancelled() in a conditional

  12. Working with Conditional Execution

    1. 1. Using If Conditions
    2. Example: Conditional Step Based on Event
    3. Example: Conditional Step Based on Branch
    4. Common If Conditions
    5. 2. Checking Job Status
    6. Example: Using
    7. 3. Checking Step Status
    8. Example: Using step outcome in a conditional
    9. 4. Using Always Condition
    10. Example: Using always() condition
    11. 5. Using Cancelled Condition
    12. Example: Cancelled Condition in a Job
    13. 6. Combining Conditions
    14. Example: Combining Conditions in a Job
    15. Example: Combining Conditions in a Step
    16. 7. Checking Event Type
    17. Example: Using event type in conditions
    18. 8. Checking Branch
    19. Example: Check if on main branch
    20. Example: Check if on feature branch
    21. 9. Checking Actor
    22. Example: Using
    23. 10. Using Ternary Expressions
    24. Example: Setting Job Matrix Based on Event
    25. Example: Conditional Environment Variable
    26. 11. Handling Default Values
    27. Example: Setting Default Values in Workflow
    28. 12. Using Environment Conditions
    29. Example: Environment Condition in a Job
    30. Example: Using Environment Variables in Conditions

  13. Managing Secrets and Variables

    1. 1. Creating Repository Secrets
    2. Example: Creating a Repository Secret via GitHub UI
    3. 2. Creating Organization Secrets
    4. Example: Creating an Organization Secret via API
    5. 3. Creating Environment Secrets
    6. Example: Creating an Environment Secret via GitHub UI
    7. Example: Creating an Environment Secret via API
    8. 4. Using Secrets in Workflows
    9. Example: Using a secret in a job
    10. 5. Creating Variables
    11. Example: Setting a Repository Variable
    12. Key Points
    13. 6. Using Environment Variables
    14. Example: Setting an environment variable in a job
    15. Example: Using environment variable in a step
    16. 7. Setting Default Environment Variables
    17. Example: Using Default Environment Variables in a Job
    18. 8. Masking Secret Values
    19. Example: Setting a Secret
    20. 9. Using Encrypted Secrets
    21. Example: Using Encrypted Secrets in Workflow
    22. 10. Accessing Secrets in Actions
    23. Example: Using a Secret in a Job
    24. 11. Managing Secret Scope
    25. Example: Using Repository Secret in Workflow
    26. 12. Rotating Secrets
    27. Example: Rotating a Secret in GitHub Actions

  14. Implementing Matrix Strategies

    1. 1. Defining Matrix Strategy
    2. Example: Basic Matrix Strategy
    3. Example: Matrix Strategy with Include
    4. 2. Using Matrix Variables
    5. Example: Using Matrix Variables in a Workflow
    6. 3. Including Matrix Combinations
    7. Example: Matrix with Include
    8. 4. Excluding Matrix Combinations
    9. Example: Using exclude to filter matrix combinations
    10. 5. Setting Fail-Fast Behavior
    11. Example: Configuring fail-fast in a matrix job
    12. 6. Setting Max Parallel Jobs
    13. Example: Configuring max-parallel
    14. 7. Using Dynamic Matrix
    15. Example: Dynamic matrix with environment variables
    16. Example: Using
    17. Example: Using
    18. 8. Accessing Matrix Values
    19. Example: Using matrix values in a job
    20. 9. Naming Matrix Jobs
    21. Example: Naming Matrix Jobs
    22. 10. Combining Multiple Matrices
    23. Example: Combining Multiple Matrices
    24. 11. Using Matrix with Outputs
    25. Example: Matrix with Outputs
    26. 12. Testing Across OS and Versions
    27. Example: Matrix Strategy for OS and Node.js Versions

  15. Implementing Caching Strategies

    1. 1. Caching Dependencies
    2. Example: Caching Node.js Dependencies
    3. Example: Caching Multiple Paths
    4. 2. Defining Cache Keys
    5. Example: Defining Cache Keys
    6. 3. Using Restore Keys
    7. Example: Using restore-keys in a job
    8. 4. Caching Node Modules
    9. Example: Caching Node Modules
    10. 5. Caching Python Packages
    11. Example: Caching Python Dependencies
    12. 6. Caching Maven Dependencies
    13. Example: Caching Maven Dependencies
    14. 7. Caching Gradle Dependencies
    15. Example: Caching Gradle Dependencies
    16. 8. Caching Go Modules
    17. Example: Caching Go Modules in GitHub Actions
    18. 9. Setting Cache Paths
    19. Example: Caching Node.js Dependencies
    20. 10. Handling Cache Misses
    21. Example: Cache Miss Detection and Fallback
    22. 11. Invalidating Cache
    23. Example: Invalidating Cache with Key
    24. 12. Managing Cache Size
    25. Example: Configuring Cache Size in Workflow
    26. 13. Using Cache Across Branches
    27. Example: Caching Across Branches

  16. Managing Workflow Artifacts

    1. 1. Uploading Artifacts
    2. Example: Upload a single file
    3. Example: Upload multiple files
    4. 2. Downloading Artifacts
    5. Example: Download a Single Artifact
    6. Example: Download All Artifacts
    7. 3. Setting Artifact Retention
    8. Example: Configure artifact retention in workflow
    9. 4. Naming Artifacts
    10. Example: Upload Artifact with Custom Name
    11. 5. Including Multiple Files
    12. Example: Uploading multiple files with wildcard
    13. 6. Excluding Files
    14. Example: Using exclude to filter files
    15. 7. Downloading Specific Artifacts
    16. Example: Downloading Artifact by Name
    17. 8. Using Artifacts Between Jobs
    18. Example: Using Artifacts Between Jobs
    19. 9. Downloading Artifacts from UI
    20. Example: Downloading Artifact via GitHub UI
    21. 10. Using Artifacts with Matrix
    22. Example: Matrix Artifact Upload
    23. 11. Compressing Artifacts
    24. Example: Compressing Artifacts with ZIP
    25. 12. Managing Artifact Storage
    26. Example: Upload Artifact
    27. Example: Download Artifact
    28. 13. Deleting Artifacts
    29. Example: Delete Artifact by ID

  17. Working with Job Outputs

    1. 1. Setting Job Outputs
    2. Example: Setting a job output
    3. Example: Using job outputs in downstream jobs
    4. 2. Setting Output from Step
    5. Example: Setting a Step Output
    6. 3. Accessing Outputs in Dependent Jobs
    7. Example: Accessing Job Outputs
    8. 4. Using Multiline Outputs
    9. Example: Setting Multiline Output
    10. Example: Using Multiline Output in Another Job
    11. 5. Passing Outputs Between Jobs
    12. Example: Passing Outputs Between Jobs
    13. 6. Using Outputs in Conditions
    14. Example: Using job outputs in conditions
    15. 7. Setting Multiple Outputs
    16. Example: Setting Multiple Job Outputs
    17. 8. Using Outputs in Matrix
    18. Example: Using Matrix Outputs in a Subsequent Job
    19. 9. Debugging Output Values
    20. Example: Using
    21. 10. Handling Empty Outputs
    22. Example: Setting Empty Outputs
    23. 11. Using Outputs Across Workflows
    24. Example: Defining job outputs in a workflow
    25. Example: Using outputs in a downstream workflow
    26. 12. Type Casting Outputs
    27. Example: Casting to String
    28. Example: Casting to Number
    29. Example: Casting to Boolean
    30. Example: Casting to Array
    31. Example: Casting to Object

  18. Implementing Concurrency Control

    1. 1. Setting Workflow Concurrency
    2. Example: Basic Concurrency Configuration
    3. 2. Defining Concurrency Group
    4. Example: Defining Concurrency Group
    5. 3. Canceling In-Progress Runs
    6. Example: Canceling in-progress runs
    7. 4. Using Branch-Based Concurrency
    8. Example: Branch Protection Rules
    9. Summary of Branch-Based Concurrency
    10. 5. Using PR-Based Concurrency
    11. Example: PR-Based Concurrency Configuration
    12. 6. Setting Job-Level Concurrency
    13. Example: Basic concurrency configuration
    14. Example: Using variables in concurrency group
    15. 7. Using Dynamic Concurrency Groups
    16. Example: Setting up a Dynamic Concurrency Group
    17. 8. Preventing Parallel Deployments
    18. Example: Using Concurrency to Prevent Parallel Deployments
    19. Best Practices for Concurrency Control
    20. 9. Queuing Workflow Runs
    21. Example: Configuring Concurrency
    22. 10. Using Actor in Concurrency
    23. Example: Actor Configuration
    24. Actor Concurrency Best Practices
    25. 11. Handling Concurrency with Matrix
    26. Example: Matrix Strategy Configuration
    27. 12. Monitoring Concurrent Runs
    28. Example: Configuring Concurrency Control
    29. Key Points

  19. Managing Workflow Permissions

    1. 1. Setting Workflow Permissions
    2. Example: Setting Workflow Permissions
    3. 2. Using Read-Only Permissions
    4. Example: Using Read-Only Permissions
    5. 3. Using Write Permissions
    6. Example: Setting Write Permissions
    7. 4. Disabling All Permissions
    8. Example: Disabling all permissions
    9. 5. Setting Token Permissions
    10. Example: Setting permissions in a workflow
    11. 6. Configuring Contents Permission
    12. Example: Setting Contents Permission
    13. 7. Configuring Pull Request Permission
    14. Example: Setting PR Permissions
    15. 8. Configuring Issues Permission
    16. Example: Setting Issues Permission in Workflow
    17. 9. Configuring Packages Permission
    18. Example: Setting Package Permissions in Workflow
    19. 10. Configuring Deployments Permission
    20. Example: Setting Deployments Permission
    21. 11. Setting Job-Level Permissions
    22. Example: Setting job-level permissions
    23. 12. Using Minimal Permissions
    24. Example: Setting minimal permissions in a workflow

  20. Working with GitHub Token

    1. 1. Using GITHUB_TOKEN
    2. Example: Using GITHUB_TOKEN to push changes
    3. 2. Authenticating API Requests
    4. Example: Using GITHUB_TOKEN to access GitHub API
    5. 3. Cloning Private Repositories
    6. Example: Cloning a Private Repo
    7. 4. Pushing Changes
    8. Example: Pushing Changes with GitHub CLI
    9. 5. Creating Pull Requests
    10. Example: Create a Pull Request
    11. 6. Creating Issues
    12. Example: Create an issue with labels and assignees
    13. 7. Commenting on PRs
    14. Example: Comment on PR
    15. 8. Creating Releases
    16. Example: Create Release with GitHub Actions
    17. 9. Managing Packages
    18. Example: Publishing to npm
    19. Managing Packages Summary
    20. 10. Using Token in Actions
    21. Example: Using GITHUB_TOKEN to authenticate with GitHub API
    22. 11. Understanding Token Scope
    23. Example: Using repo scope in workflow
    24. 12. Token Expiration

  21. Working with Environments

    1. 1. Defining Environments
    2. Example: Environment Definition
    3. 2. Setting Environment Variables
    4. Example: Setting Environment Variables in a Job
    5. Example: Using Environment Variables in a Workflow
    6. 3. Configuring Protection Rules
    7. Example: Protection Rules Configuration
    8. 4. Setting Environment Secrets
    9. Example: Setting an Environment Secret
    10. 5. Using Environment URLs
    11. Example: Accessing Environment URL in a Workflow
    12. 6. Configuring Branch Restrictions
    13. Example: Branch Protection Rule
    14. 7. Waiting for Deployment
    15. Example: Waiting for a deployment to environment
    16. 8. Approving Deployments
    17. Example: Approving Deployments to Production
    18. Example: Configuring Approval with Conditions
    19. 9. Tracking Deployment Status
    20. Example: Using GitHub Actions to Track Deployment Status
    21. 10. Using Environment in Conditions
    22. Example: Using environment in conditions
    23. 11. Reviewing Deployment History
    24. Example: Fetch Deployment History
    25. 12. Deleting Environments
    26. Example: Delete Environment by Name

  22. Working with Deployment Workflows

    1. 1. Defining Deployment Jobs
    2. Example: Basic Deployment Job
    3. 2. Using Deployment Environment
    4. Example: Environment Configuration
    5. 3. Requiring Manual Approval
    6. Example: Manual Approval Workflow
    7. 4. Setting Deployment URL
    8. Example: Set Deployment URL in Environment
    9. 5. Tracking Deployment Status
    10. Example: Using GitHub API to Check Deployment Status
    11. Example: Updating Deployment Status in GitHub Actions
    12. 6. Using Blue-Green Deployments
    13. Example: GitHub Actions Workflow for Blue-Green Deployment
    14. Blue-Green Deployment Benefits
    15. 7. Implementing Canary Deployments
    16. Example: Using GitHub Actions for Canary Deployment
    17. Key Benefits of Canary Deployments
    18. 8. Rolling Back Deployments
    19. Example: Rolling Back to Previous Commit
    20. 9. Using Deployment Gates
    21. Example: Manual Approval Gate
    22. Example: Environment Protection Rule
    23. 10. Configuring Auto-Deployments
    24. Example: Basic Auto-Deployment Workflow
    25. Example: Conditional Deployment Based on Branch
    26. 11. Using Deployment Notifications
    27. Example: Slack Notification
    28. 12. Monitoring Deployment History
    29. Example: Retrieve Deployment History

  23. Working with Container Services

    1. 1. Defining Service Containers
    2. Example: Defining a Redis Service Container
    3. 2. Using PostgreSQL Service
    4. Example: Using PostgreSQL in a Job
    5. 3. Using MySQL Service
    6. Example: Setting up MySQL Service
    7. 4. Using Redis Service
    8. Example: Using Redis in a Workflow
    9. 5. Using MongoDB Service
    10. Example: Using MongoDB in a Workflow
    11. 6. Configuring Service Ports
    12. Example: Mapping Service Ports
    13. 7. Setting Service Environment Variables
    14. Example: Setting Environment Variables in a Service Container
    15. 8. Configuring Health Checks
    16. Example: Health Check in Dockerfile
    17. Example: Health Check in Compose File
    18. 9. Using Service Volumes
    19. Example: Mounting a volume to a service container
    20. 10. Accessing Service Containers
    21. Example: Accessing a Database Service
    22. 11. Using Multiple Services
    23. Example: Using Multiple Services in a Workflow
    24. 12. Waiting for Service Ready
    25. Example: Using wait-for-service in a workflow
    26. 13. Debugging Service Containers
    27. Example: Using debug logs in service containers
    28. Example: Inspecting container environment
    29. Debugging Workflow
    30. Debugging Methods

  24. Creating Reusable Workflows

    1. 1. Defining Reusable Workflow
    2. Example: Defining a reusable workflow
    3. 2. Calling Reusable Workflows
    4. Example: Calling a Reusable Workflow
    5. 3. Passing Inputs
    6. Example: Using Inputs in a Workflow
    7. 4. Defining Input Types
    8. Example: Defining Inputs in a Reusable Workflow
    9. 5. Setting Required Inputs
    10. Example: Defining Required Inputs
    11. 6. Setting Default Input Values
    12. Example: Using Default Values in Workflow
    13. 7. Using Secrets in Reusable Workflows
    14. Example: Using a Secret in a Reusable Workflow
    15. 8. Returning Outputs
    16. Example: Defining Outputs in a Reusable Workflow
    17. Example: Using Outputs in a Calling Workflow
    18. 9. Accessing Caller Context
    19. Example: Using caller context in a reusable workflow
    20. 10. Nesting Reusable Workflows
    21. Example: Nesting Reusable Workflows
    22. 11. Versioning Reusable Workflows
    23. Example: Using Tagged Version
    24. 12. Sharing Across Repositories
    25. Example: Reusable Workflow Definition
    26. Example: Using the Reusable Workflow
    27. 13. Testing Reusable Workflows
    28. Example: Testing a Reusable Workflow

  25. Building Composite Actions

    1. 1. Creating Composite Action
    2. Example: Basic Composite Action
    3. 2. Defining Action Inputs
    4. Example: Defining Inputs in action.yml
    5. 3. Defining Action Outputs
    6. Example: Defining Outputs in action.yml
    7. 4. Using Runs Composite
    8. Example: Using Runs Composite
    9. 5. Executing Multiple Steps
    10. Example: Executing Multiple Steps
    11. Key Points
    12. 6. Setting Shell for Steps
    13. Example: Using PowerShell on Windows
    14. Example: Using Python Shell
    15. 7. Passing Inputs to Steps
    16. Example: Using Inputs in a Composite Action
    17. 8. Setting Output Values
    18. Example: Setting Output Values in a Composite Action
    19. 9. Using Environment Variables
    20. Example: Setting an environment variable in a composite action
    21. Example: Reading an environment variable in a composite action
    22. 10. Handling Errors
    23. Example: Using continue-on-error
    24. Example: Handling failure with on-failure
    25. Error Handling Best Practices
    26. 11. Using Pre and Post Steps
    27. Example: Using pre and post steps in a composite action
    28. 12. Sharing Composite Actions
    29. Example: Using a Shared Composite Action
    30. 13. Versioning Composite Actions
    31. Example: Using a specific version in a workflow

  26. Creating JavaScript Actions

    1. 1. Creating Node.js Action
    2. Example: Node.js Action Structure
    3. Example: Action Manifest (action.yml)
    4. 2. Defining Action Entry Point
    5. Example: Defining Action Entry Point
    6. 3. Using Actions Toolkit
    7. Example: Reading Inputs
    8. Example: Setting Outputs
    9. Example: Logging Messages
    10. Example: Using GitHub API
    11. 4. Getting Action Inputs
    12. Example: Using Inputs in a JavaScript Action
    13. 5. Setting Action Outputs
    14. Example: Setting an Output in JavaScript Action
    15. 6. Setting Failed Status
    16. Example: Setting Failed Status
    17. 7. Logging Messages
    18. Example: Using console.log in a JavaScript Action
    19. Example: Logging with context
    20. 8. Grouping Logs
    21. Example: Grouping Logs in a Workflow
    22. 9. Masking Values
    23. Example: Masking a Secret Value
    24. 10. Using GitHub API
    25. Example: Create a new issue using GitHub API
    26. 11. Compiling TypeScript
    27. Example: Compiling TypeScript Action
    28. 12. Handling Async Operations
    29. Example: Using async/await in a GitHub Action
    30. 13. Publishing to Marketplace
    31. Example: Publishing to Marketplace

  27. Creating Docker Container Actions

    1. 1. Creating Dockerfile Action
    2. Example: Dockerfile Action
    3. Example: Dockerfile
    4. 2. Defining Container Image
    5. Example: Dockerfile for Container Action
    6. Example: action.yml for Container Action
    7. 3. Using Pre-built Images
    8. Example: Using a Pre-built Python Image
    9. 4. Building from Dockerfile
    10. Example: Building a Docker Action
    11. 5. Passing Arguments
    12. Example: Passing Arguments to a Docker Container Action
    13. 6. Setting Environment Variables
    14. Example: Setting environment variables in a Docker container action
    15. 7. Mounting Workspace
    16. Example: Mounting workspace to container
    17. 8. Using ENTRYPOINT Script
    18. Example: Dockerfile with ENTRYPOINT
    19. Example: entrypoint.sh script
    20. 9. Handling Action Inputs
    21. Example: Using Inputs in a Docker Action
    22. Example: Accessing Inputs in the Dockerfile
    23. 10. Setting Action Outputs
    24. Example: Setting an Output in a Docker Action
    25. Example: Setting Multiple Outputs
    26. 11. Using Docker Build Arguments
    27. Example: Setting Docker Build Arguments
    28. 12. Publishing Container Actions
    29. Example: Publishing a Docker Action to GitHub Container Registry

  28. Implementing OIDC Authentication

    1. 1. Understanding OIDC
    2. Example: OIDC Token Flow
    3. 2. Configuring OIDC Provider
    4. 3. Setting ID Token Permissions
    5. 4. Requesting ID Token
    6. Example: Requesting ID Token
    7. 5. Configuring Trust Relationship
    8. 6. Using Subject Claim
    9. Example: Subject Claim in Token
    10. 7. Using Audience Claim
    11. Example: Audience Claim in Token
    12. 8. Accessing AWS with OIDC
    13. Example: AWS Access via OIDC
    14. 9. Accessing Azure with OIDC
    15. Example: Azure Access via OIDC
    16. 10. Accessing GCP with OIDC
    17. Example: GCP Access via OIDC
    18. 11. Customizing Token Claims
    19. 12. Validating Token
    20. Example: Token Validation in Node.js
    21. 13. Troubleshooting OIDC
    22. Common Issues and Solutions
    23. Debugging Steps

  29. Integrating with Cloud Providers

    1. 1. Deploying to AWS
    2. Example: Deploy to AWS Lambda
    3. Example: Deploy to AWS ECS
    4. 2. Using AWS CLI
    5. Example: Configure AWS CLI in GitHub Actions
    6. Example: Upload to S3 using CLI
    7. 3. Deploying to Azure
    8. Example: Deploying a Node.js App to Azure
    9. 4. Using Azure CLI
    10. Example: Deploying a Web App
    11. 5. Deploying to GCP
    12. Example: Deploying a Docker image to GCP Cloud Run
    13. 6. Using GCP CLI
    14. Example: Authenticate and deploy to GCP
    15. 7. Deploying to Vercel
    16. Example: Basic Vercel Deployment
    17. Deployment Workflow Summary
    18. 8. Deploying to Netlify
    19. Example: Deploying to Netlify
    20. 9. Deploying to Heroku
    21. Example: Deploying to Heroku
    22. 10. Using DigitalOcean
    23. Example: Deploy to DigitalOcean
    24. 11. Using Cloudflare
    25. Example: Deploy to Cloudflare Workers
    26. Key Features
    27. 12. Managing Cloud Resources
    28. Example: Deploying to AWS EC2
    29. Example: Deploying to GCP Compute Engine
    30. Example: Deploying to Azure Virtual Machines

  30. Working with Docker Workflows

    1. 1. Building Docker Images
    2. Example: Building and pushing a Docker image
    3. 2. Tagging Docker Images
    4. Example: Using GitHub Actions to tag Docker images with version
    5. 3. Pushing to Docker Hub
    6. Example: Pushing Docker Image to Docker Hub
    7. 4. Pushing to GHCR
    8. Example: Pushing Docker Image to GHCR
    9. 5. Using Docker Buildx
    10. Example: Setting up Buildx
    11. Example: Building and pushing multi-platform image
    12. 6. Using Multi-Stage Builds
    13. Example: Multi-stage Docker Build in GitHub Actions
    14. 7. Caching Docker Layers
    15. Example: Using cache action for Docker layers
    16. 8. Using Docker Compose
    17. Example: Basic docker-compose.yml
    18. Example: GitHub Actions workflow using Docker Compose
    19. 9. Running Docker Containers
    20. Example: Running a Docker Container
    21. Example: Using Custom Image with Arguments
    22. 10. Scanning Images for Vulnerabilities
    23. Example: Using Trivy to Scan Docker Images
    24. 11. Using Build Arguments
    25. Example: Setting Build Arguments in Workflow
    26. 12. Publishing to Multiple Registries
    27. Example: Publishing to Docker Hub and GHCR

  31. Managing GitHub Packages

    1. 1. Publishing npm Packages
    2. Example: Publishing to GitHub Packages
    3. Example: GitHub Actions Workflow for Publishing
    4. 2. Publishing Docker Images
    5. Example: Publishing Docker Image to GHCR
    6. 3. Publishing Maven Packages
    7. Example: Publishing to GitHub Packages
    8. Key Steps
    9. 4. Publishing NuGet Packages
    10. Example: Publishing NuGet Package
    11. 5. Publishing RubyGems
    12. Example: Publishing a RubyGem
    13. 6. Authenticating to GitHub Packages
    14. Example: Using a Personal Access Token
    15. 7. Configuring Package Scope
    16. Example: Setting Package Scope in Workflow
    17. 8. Setting Package Visibility
    18. Example: Setting Package Visibility in Workflow
    19. 9. Linking Packages to Repository
    20. Example: Linking Package to GitHub Repository
    21. 10. Versioning Packages
    22. Example: Publishing a New Package Version
    23. 11. Managing Package Retention
    24. Example: Setting retention policy via API
    25. 12. Using Package Restore
    26. Example: Restore a package in a workflow

  32. Implementing Testing Workflows

    1. 1. Running Unit Tests
    2. Example: Running Unit Tests with Jest
    3. 2. Running Integration Tests
    4. Example: Running Integration Tests in a Workflow
    5. 3. Running E2E Tests
    6. Example: E2E Test Workflow
    7. 4. Generating Test Coverage
    8. Example: Setting up coverage reporting with Jest
    9. Example: Configuring coverage thresholds
    10. Test Coverage Tools Comparison
    11. 5. Uploading Coverage Reports
    12. Example: Upload coverage report to Codecov
    13. 6. Running Linters
    14. Example: ESLint Configuration
    15. Example: Prettier Configuration
    16. Workflow Steps for Linting
    17. 7. Running Code Formatters
    18. Example: Prettier in GitHub Actions
    19. 8. Running Type Checkers
    20. Example: Running TypeScript Checks in GitHub Actions
    21. 9. Using Test Reporters
    22. Example: Using JUnit Reporter
    23. 10. Failing on Low Coverage
    24. Example: Configuring Coverage Failures
    25. 11. Running Tests in Parallel
    26. Example: Parallel Test Jobs
    27. Best Practices for Parallel Testing
    28. 12. Using Test Fixtures
    29. Example: Setting Up a Test Fixture

  33. Implementing Code Quality Workflows

    1. 1. Running CodeQL Analysis
    2. Example: Running CodeQL Analysis
    3. Key Points
    4. 2. Using SonarCloud
    5. Example: SonarCloud Analysis
    6. Key Features
    7. 3. Using ESLint
    8. Example: ESLint Configuration
    9. Example: GitHub Action Workflow
    10. 4. Using Prettier
    11. Example: Format JavaScript files with Prettier
    12. Example: GitHub Actions workflow using Prettier
    13. 5. Using Dependency Scanning
    14. Example: Snyk Dependency Scan
    15. Example: OWASP Dependency Check
    16. 6. Scanning for Secrets
    17. Example: Secret Scanning Workflow
    18. 7. Running Security Audits
    19. Example: Security Audit Workflow
    20. 8. Using License Checkers
    21. Example: Using licensee in GitHub Actions
    22. 9. Generating Code Metrics
    23. Example: Setting up Code Coverage with Jest
    24. Example: Using Codecov to Upload Coverage Reports
    25. 10. Creating Quality Gates
    26. Example: Basic Quality Gate Workflow
    27. Quality Gate vs. Continuous Integration
    28. 11. Commenting on PRs
    29. Example: Comment on PR with linting results
    30. 12. Using Pre-commit Hooks
    31. Example: Setting up pre-commit hooks in GitHub Actions

  34. Implementing Security Best Practices

    1. 1. Pinning Action Versions
    2. Example: Using SHA for Pinning
    3. 2. Using Verified Actions
    4. Example: Using a Verified Action
    5. 3. Reviewing Third-Party Actions
    6. Example: Pinning Action Version
    7. Best Practices for Action Review
    8. 4. Limiting Workflow Permissions
    9. Example: Setting minimal permissions for a workflow
    10. 5. Using Environment Secrets
    11. Example: Using Environment Secrets in a Workflow
    12. 6. Preventing Script Injection
    13. Example: Secure Command Execution
    14. Example: Input Validation in Workflow
    15. 7. Using CodeQL Analysis
    16. Example: Basic CodeQL workflow configuration
    17. CodeQL Analysis Workflow Steps
    18. CodeQL vs Other Static Analysis Tools
    19. 8. Scanning Dependencies
    20. Example: GitHub Dependabot Configuration
    21. Example: Snyk Configuration
    22. 9. Using Secret Scanning
    23. Example: Enabling Secret Scanning in a Workflow
    24. 10. Implementing Branch Protection
    25. Example: GitHub Actions Workflow with Branch Protection
    26. 11. Restricting Workflow Triggers
    27. Example: Restricting Push Triggers
    28. Example: Restricting Pull Request Triggers
    29. 12. Using Audit Logs
    30. Example: Enabling audit logging for GitHub Actions
    31. Key Points About Audit Logs
    32. 13. Rotating Credentials
    33. Example: Rotating GitHub PAT in Workflow

  35. Handling Errors and Debugging

    1. 1. Enabling Debug Logging
    2. Example: Setting debug environment variables
    3. 2. Enabling Runner Diagnostics
    4. Example: Enabling debug logging in a workflow
    5. Summary of Diagnostic Logging
    6. 3. Using Continue on Error
    7. Example: Using continue-on-error in a job step
    8. 4. Checking Step Outcome
    9. Example: Using step outcome in conditional logic
    10. 5. Using Failure Conditions
    11. Example: Using
    12. 6. Logging Debug Messages
    13. Example: Using debug logging in a job
    14. 7. Logging Warning Messages
    15. Example: Using Warning Messages in a Workflow
    16. 8. Logging Error Messages
    17. 9. Creating Annotations
    18. Example: Creating a Warning Annotation
    19. 10. Using SSH Debugging
    20. Example: SSH into a GitHub Actions Runner
    21. SSH Debugging Workflow
    22. 11. Inspecting Workflow Files
    23. Example: Basic Workflow File Structure
    24. 12. Validating Workflow Syntax
    25. Example: Using act to validate workflow syntax
    26. 13. Testing Workflows Locally
    27. Example: Using act to test workflows locally

  36. Working with Workflow Annotations

    1. 1. Creating Error Annotations
    2. Example: Using GitHub Actions Error Annotations
    3. Example: Annotating with Custom Message
    4. 2. Creating Warning Annotations
    5. Example: Creating a Warning Annotation
    6. 3. Creating Notice Annotations
    7. Example: Creating a Notice Annotation
    8. 4. Setting Annotation File
    9. Example: Setting Annotation File
    10. 5. Setting Annotation Line
    11. Example: Setting Line Numbers in Annotations
    12. 6. Setting Annotation Column
    13. Example: Setting Annotation Column
    14. 7. Setting Annotation Title
    15. Example: Setting Annotation Title
    16. 8. Using Problem Matchers
    17. Example: Using Problem Matchers in a Workflow
    18. 9. Defining Custom Problem Matchers
    19. Example: Defining a Custom Problem Matcher
    20. 10. Registering Problem Matchers
    21. Example: Registering a Problem Matcher
    22. 11. Removing Problem Matchers
    23. Example: Removing a Problem Matcher
    24. 12. Viewing Annotations
    25. Example: Using Annotations in a Workflow
    26. Key Points

  37. Optimizing Workflow Performance

    1. 1. Using Caching Effectively
    2. Example: Caching Node.js Dependencies
    3. Example: Caching with Multiple Paths
    4. Best Practices for Caching
    5. 2. Parallelizing Jobs
    6. Example: Running Jobs in Parallel
    7. Best Practices for Parallel Jobs
    8. 3. Reducing Checkout Depth
    9. Example: Fetch only the last 1 commit
    10. 4. Using Sparse Checkout
    11. Example: Setting up sparse checkout
    12. 5. Minimizing Docker Layers
    13. Example: Optimized Dockerfile Layering
    14. 6. Using Matrix Efficiently
    15. Example: Efficient Matrix Usage
    16. Best Practices for Matrix Usage
    17. 7. Skipping CI
    18. Example: Skip CI with commit message
    19. How It Works
    20. 8. Using Conditionals
    21. Example: Conditional Step Execution
    22. Example: Conditional on Event Type
    23. 9. Caching Docker Layers
    24. Example: Caching Docker layers in a workflow
    25. 10. Using Prebuilt Actions
    26. Example: Using a prebuilt action to checkout code
    27. Example: Using a prebuilt action with inputs
    28. Benefits of Using Prebuilt Actions
    29. 11. Optimizing Runner Selection
    30. Example: Using specific runner
    31. Best Practices
    32. 12. Monitoring Workflow Duration
    33. Example: Using GitHub Actions API to fetch workflow duration
    34. 13. Using Workflow Templates
    35. Example: Reusing a workflow template

  38. Working with Workflow Summaries

    1. 1. Creating Job Summaries
    2. Example: Basic Job Summary
    3. Key Points
    4. 2. Using Markdown in Summaries
    5. Example: Basic Markdown in Workflow Summary
    6. 3. Adding Tables to Summaries
    7. Example: Creating a Table in Workflow Summary
    8. 4. Adding Images to Summaries
    9. Example: Embedding Image in Workflow Summary
    10. 5. Adding Code Blocks to Summaries
    11. Example: Using
    12. 6. Adding Collapsible Sections
    13. Example: Using HTML in Workflow Summary
    14. 7. Adding Links to Summaries
    15. Example: Adding a Link to Summary
    16. 8. Formatting with Emojis
    17. Example: Using Emojis in Job Logs
    18. 9. Appending Multiple Summaries
    19. Example: Appending Multiple Summaries
    20. 10. Using Summary Actions
    21. Example: Writing a Summary
    22. 11. Generating Test Result Summaries
    23. Example: Publishing Test Results
    24. Key Features
    25. 12. Creating Build Status Summaries
    26. Example: Basic Build Status Summary

  39. Using Advanced Workflow Features

    1. 1. Creating Workflow Templates
    2. Example: Basic workflow template structure
    3. Template Best Practices
    4. 2. Implementing Workflow Dispatch Inputs
    5. Example: Workflow Dispatch with Inputs
    6. 3. Using Repository Dispatch
    7. Example: Triggering a Workflow via Repository Dispatch
    8. Example: Sending a Repository Dispatch Event via API
    9. 4. Integrating with GitHub Apps
    10. Example: Using GitHub App for CI/CD
    11. Key Points
    12. 5. Using Workflow Run API
    13. Example: Fetching Workflow Run Details
    14. Example: Triggering a Workflow Run
    15. 6. Monitoring Workflow Quotas
    16. Example: Checking Workflow Quotas via API
    17. 7. Using Workflow Visualization
    18. Example: Viewing Workflow Graph
    19. Key Features
    20. 8. Creating Rerun Logic
    21. Example: Basic rerun logic with manual trigger
    22. Example: Conditional rerun based on job status
    23. Key Concepts for Rerun Logic
    24. 9. Implementing Approval Gates
    25. Example: Manual Approval for Production Deployment
    26. Key Points
    27. 10. Using Required Workflows
    28. Example: Requiring Workflows in a GitHub Action
    29. 11. Handling Workflow Timeouts
    30. Example: Setting a Custom Timeout
    31. 12. Implementing Retry Mechanisms
    32. Example: Retry Configuration

  40. Working with Workflow Status Badges

    1. 1. Creating Status Badges
    2. Example: Adding a Build Status Badge to README.md
    3. 2. Using Branch Specific Badges
    4. Example: Branch-specific Badge URL
    5. 3. Using Event Specific Badges
    6. Example: Embedding a Push-Specific Badge
    7. 4. Embedding in README
    8. Example: Embedding Workflow Badge
    9. 5. Customizing Badge Style
    10. Example: Custom Badge Style
    11. 6. Using Multiple Badges
    12. Example: Displaying Multiple Workflow Status Badges
    13. 7. Creating Dynamic Badges
    14. Example: Using a Dynamic Badge in README
    15. 8. Showing Build Status
    16. Example: Adding a workflow status badge to README
    17. Badge Configuration Options
    18. 9. Using Coverage Badges
    19. Example: Setting up a coverage badge
    20. 10. Creating Custom Badges
    21. Example: Basic Badge Configuration
    22. Badge Configuration Summary
    23. 11. Adding Badge Tooltips
    24. Example: Adding Tooltip to Badge
    25. 12. Linking Badges to Workflows
    26. Example: Linking Badge to Workflow

  41. Using GitHub CLI in Workflows

    1. 1. Using gh auth
    2. Example: Authenticating with gh auth login
    3. Example: Retrieving the authentication token
    4. 2. Using gh pr Commands
    5. 3. Using gh issue Commands
    6. 4. Using gh release Commands
    7. Example: Create a Release
    8. Example: Upload Assets to Release
    9. 5. Using gh repo Commands
    10. Example: Clone a repository
    11. Example: Create a new repository
    12. 6. Using gh run Commands
    13. Example: List recent workflow runs
    14. Example: View a specific run
    15. Example: Cancel a running run
    16. 7. Using gh workflow Commands
    17. 8. Using gh api Commands
    18. Example: Fetching Issues from a Repository
    19. Example: Creating a New Issue
    20. 9. Formatting gh Output
    21. Example: Using JSON format to parse output
    22. Example: Using table format for readable output
    23. 10. Using gh Extensions
    24. Example: Installing and Using a GitHub CLI Extension
    25. 11. Automating with gh Scripts
    26. Example: Running a Script
    27. Example: Creating a Script
    28. 12. Authenticating gh
    29. Example: Using a Personal Access Token

  42. Configuring Dependabot Integration

    1. 1. Enabling Dependabot Updates
    2. Example: Enabling Dependabot in GitHub Actions
    3. 2. Configuring Update Schedule
    4. Example: Daily Updates
    5. Example: Weekly Updates on Monday
    6. 3. Setting Target Branch
    7. Example: Setting Target Branch in Workflow
    8. 4. Limiting Open PRs
    9. Example: Configuring Open PR Limit
    10. 5. Grouping Updates
    11. Example: Grouping Updates in Dependabot Configuration
    12. 6. Ignoring Dependencies
    13. Example: dependabot.yml configuration
    14. 7. Using Version Constraints
    15. Example: Setting Version Constraints in Dependabot Configuration
    16. 8. Configuring PR Reviewers
    17. Example: Basic PR Reviewer Configuration
    18. 9. Setting Commit Message Format
    19. Example: Configuring Commit Message Format
    20. 10. Handling Security Updates
    21. Example: Enable Security Updates
    22. 11. Auto-Merging Dependabot PRs
    23. Example: Enabling Auto-Merge for Dependabot
    24. 12. Managing Dependabot Secrets
    25. Example: Using Dependabot Secrets in a Workflow

  43. Managing Organization Workflows

    1. 1. Creating Organization Starter Workflows
    2. Example: Creating a Starter Workflow
    3. 2. Sharing Reusable Workflows
    4. Example: Using a Reusable Workflow
    5. Key Points
    6. 3. Setting Required Workflows
    7. Example: Configuring Required Workflows
    8. 4. Using Organization Secrets
    9. Example: Using Organization Secret in a Workflow
    10. 5. Managing Runner Groups
    11. Example: Create a Runner Group
    12. Example: Update Runner Group
    13. 6. Configuring Organization Policies
    14. Example: Setting workflow permissions
    15. 7. Setting Allowed Actions
    16. Example: Configure allowed actions in organization settings
    17. 8. Using Private Actions
    18. Example: Using a Private Action
    19. 9. Auditing Workflow Usage
    20. Example: Viewing Workflow Audit Logs
    21. 10. Managing Billing
    22. Example: Setting up Billing for Organization
    23. 11. Configuring Default Permissions
    24. Example: Setting Default Permissions in a Workflow
    25. 12. Using Enterprise Features
    26. Example: Using Custom Actions in Enterprise
    27. Enterprise Features Overview

  44. Integrating with External Services

    1. 1. Using Slack Notifications
    2. Example: Slack Notification Configuration
    3. Summary of Slack Integration
    4. 2. Using Email Notifications
    5. Example: Configure Email Notification
    6. 3. Using Discord Webhooks
    7. Example: Sending a Discord Webhook
    8. 4. Using Microsoft Teams
    9. Example: Send a message to Microsoft Teams
    10. 5. Integrating with Jira
    11. Example: Create Jira Issue
    12. Jira Integration Capabilities
    13. 6. Using Kubernetes
    14. Example: Deploying to Kubernetes
    15. Key Concepts
    16. 7. Using Terraform
    17. Example: Setup Terraform
    18. Example: Run Terraform Plan
    19. 8. Using Ansible
    20. Example: Running an Ansible Playbook
    21. 9. Using Datadog
    22. Example: Setting up Datadog tracing in a workflow
    23. 10. Using New Relic
    24. Example: Using New Relic Action
    25. 11. Posting to Twitter
    26. Example: Posting a Status Update
    27. 12. Integrating with PagerDuty
    28. Example: Send Alert to PagerDuty

  45. Monitoring and Analytics

    1. 1. Viewing Workflow Runs
    2. Example: Fetching workflow run details via API
    3. 2. Checking Job Status
    4. Example: Using job status in a workflow
    5. 3. Viewing Job Logs
    6. Example: Accessing Job Logs
    7. 4. Downloading Workflow Logs
    8. Example: Downloading Logs via CLI
    9. 5. Using Workflow Insights
    10. Example: Accessing Workflow Insights
    11. Key Features of Workflow Insights
    12. 6. Monitoring Runner Usage
    13. Example: Using runner labels in workflow
    14. 7. Tracking Workflow Duration
    15. Example: Calculate Workflow Duration
    16. 8. Viewing Workflow Dependencies
    17. Example: Reusable Workflow Call
    18. Key Points
    19. 9. Using Workflow API
    20. Example: Fetching Workflow Runs
    21. Example: Getting Workflow Run Details
    22. 10. Setting Up Alerts
    23. Example: Basic Alert Configuration
    24. 11. Analyzing Billing Usage
    25. Example: Billing Usage Query
    26. 12. Creating Custom Dashboards
    27. Example: Setting up a custom dashboard with GitHub Actions metrics
    28. Comparison: GitHub Actions vs External Dashboard Tools

  46. Migrating from Other CI/CD

    1. 1. Migrating from Jenkins
    2. Example: Migrating a Jenkins Pipeline Stage to GitHub Actions
    3. Migration Steps Overview
    4. Jenkins vs GitHub Actions
    5. 2. Migrating from Travis CI
    6. Example: Migrating a Travis CI job to GitHub Actions
    7. Travis CI vs GitHub Actions
    8. 3. Migrating from CircleCI
    9. CircleCI vs GitHub Actions
    10. Example: Migrating a CircleCI Job to GitHub Actions
    11. Migration Steps
    12. 4. Migrating from GitLab CI
    13. Key Differences: GitHub Actions vs GitLab CI
    14. Example: Migrating a Simple Build Job
    15. Migration Steps Overview
    16. 5. Migrating from Azure Pipelines
    17. Example: Migrating a Simple Pipeline
    18. Key Differences
    19. 6. Converting Pipeline Stages
    20. Example: Converting a Build Stage
    21. Example: Converting a Test Stage
    22. Example: Converting a Deploy Stage
    23. 7. Converting Build Steps
    24. Example: Converting npm install and build steps
    25. 8. Migrating Environment Variables
    26. Example: Setting Environment Variables in GitHub Actions
    27. 9. Converting Caching Logic
    28. Example: CircleCI to GitHub Actions Caching
    29. 10. Migrating Artifacts
    30. Example: Upload Build Artifacts
    31. Example: Download Artifacts
    32. 11. Converting Matrix Builds
    33. Example: Matrix Build Configuration
    34. Example: Including Custom Matrix Entry
    35. 12. Migrating Deployment Scripts
    36. Example: Migrating a Deployment Script
    37. 13. Testing Migrated Workflows
    38. Example: Basic workflow test
    39. Testing Migration Steps
    40. Migration Testing vs Manual Testing