Course Duration

2 Days | 16 Hours

Format: Instructor-Led Training + Hands-on Labs + Real-World CI/CD Project

Offered By

DevOpsSchool

Website: DevOpsSchool

GitHub Actions — CI/CD Automation & DevOps Engineering

Duration: 2 Days
Level: Beginner to Advanced
Format: Instructor-Led + Hands-on
Mode: Online / Classroom

Learn how to design, implement, secure and troubleshoot CI/CD pipelines using GitHub Actions.

You Will Learn

• GitHub Actions fundamentals
• Workflow YAML
• Events & triggers
• Jobs & dependencies
• Runners
• Variables & contexts
• Expressions
• Secrets & GITHUB_TOKEN
• Matrix builds
• Caching & artifacts
• Reusable workflows
• Environments & approvals
• Docker CI/CD
• GitHub Actions security
• AWS OIDC
• Kubernetes deployments
• Terraform automation
• CI/CD troubleshooting
• Performance & cost optimization
• Production CI/CD best practices

Hands-on Project

Build a production-style:

GitHub → Actions → Test → Security → Docker → Registry → Staging → Approval → Production → Verification

pipeline.

Ideal for: DevOps Engineers, SREs, Cloud Engineers, Platform Engineers, Developers, Automation Engineers and CI/CD professionals.

This structure gives DevOpsSchool a credible 2-day commercial course offering while preserving the breadth of your original GitHub Actions curriculum and concentrating the actual classroom time on skills participants can implement immedia

1. Course Overview

GitHub Actions is a GitHub-native automation and CI/CD platform that enables development and DevOps teams to automate software build, test, security, packaging and deployment workflows.

This 2-day practical course is designed to take participants from GitHub Actions fundamentals to production-grade CI/CD implementation.

The course focuses on:

• Workflow creation
• YAML configuration
• Events and triggers
• Jobs and steps
• GitHub-hosted runners
• Environment variables and secrets
• Expressions and contexts
• Matrix builds
• Caching
• Artifacts
• Reusable workflows
• CI/CD pipeline design
• Docker-based CI/CD
• Security hardening
• GitHub environments
• AWS OIDC authentication
• Kubernetes deployment concepts
• Terraform automation
• Troubleshooting
• Production CI/CD best practices

The underlying topic structure is derived from the supplied GitHub Actions reference curriculum, which covers workflow syntax, triggers, jobs, steps, runners, variables, contexts, expressions, secrets, tokens, matrices, caching, artifacts and concurrency.

2. Who Should Attend

This course is suitable for:

• DevOps Engineers
• SRE Engineers
• Cloud Engineers
• Platform Engineers
• Software Developers
• Software Engineers
• Build & Release Engineers
• CI/CD Engineers
• Automation Engineers
• System Administrators
• Kubernetes Engineers
• Cloud Architects
• Technical Leads
• Engineering Managers

3. Prerequisites

Participants should have basic knowledge of:

Required

• Git fundamentals
• GitHub repositories
• Basic Linux commands
• Basic YAML
• Basic scripting
• Basic software development lifecycle

Recommended

Knowledge of:

• Docker
• Kubernetes
• AWS/Azure/GCP
• Terraform
• CI/CD concepts

Participants do not need prior GitHub Actions experience.

4. Learning Objectives

By the end of the course, participants will be able to:

1. Understand GitHub Actions architecture and execution model.
2. Create GitHub Actions workflows from scratch.
3. Configure workflow triggers and filters.
4. Design multi-job CI/CD pipelines.
5. Use variables, secrets, contexts and expressions.
6. Implement conditional workflow execution.
7. Build matrix-based pipelines.
8. Implement dependency caching.
9. Publish and consume workflow artifacts.
10. Configure GitHub environments.
11. Implement deployment approval controls.
12. Create reusable workflows.
13. Work with GitHub-hosted and self-hosted runners.
14. Build Docker images using GitHub Actions.
15. Publish container images to a registry.
16. Implement secure GITHUB_TOKEN permissions.
17. Understand GitHub Actions security risks.
18. Implement OIDC-based cloud authentication.
19. Integrate GitHub Actions with AWS.
20. Understand Kubernetes deployment automation.
21. Automate Terraform workflows.
22. Troubleshoot failed workflows.
23. Optimize workflow performance and cost.
24. Design production-ready CI/CD pipelines.

5. Day 1 — GitHub Actions Foundations & CI

Module 1 — GitHub Actions Fundamentals

Topics

• What is GitHub Actions?
• CI vs Continuous Delivery vs Continuous Deployment
• GitHub Actions use cases
• Event-driven automation
• Repository automation
• DevOps automation
• GitHub Actions architecture
• Execution model
• Workflow lifecycle
• Workflow run lifecycle

Core Components

• Workflows
• Workflow runs
• Events
• Triggers
• Jobs
• Steps
• Actions
• Runners
• Commands
• Scripts
• Artifacts
• Caches
• Variables
• Secrets
• Contexts
• Expressions
• Environments

These core concepts are explicitly included in the supplied curriculum.

Hands-on Lab

Create Your First GitHub Actions Workflow

Participants will:

1. Create a GitHub repository.
2. Create .github/workflows/.
3. Create a YAML workflow.
4. Trigger it on push.
5. Execute shell commands.
6. Inspect workflow logs.
7. Re-run a workflow.

Module 2 — Workflow YAML & Syntax

Topics

• YAML fundamentals
• Workflow structure
• name
• run-name
• on
• permissions
• env
• defaults
• concurrency
• jobs
• runs-on
• steps
• uses
• run
• with

Job Configuration

• Job IDs
• needs
• if
• runs-on
• environment
• outputs
• timeout-minutes
• continue-on-error
• container
• services
• strategy

Step Configuration

• Step IDs
• uses
• run
• shell
• with
• env
• Working directories
• Conditions

The supplied curriculum specifically separates workflow-, job-, and step-level syntax, making this a natural foundation for the first day.

Hands-on Lab

Build:

Build → Test → Package

Checkout Code
     ↓
Install Dependencies
     ↓
Run Lint
     ↓
Run Tests
     ↓
Build Application
     ↓
Upload Artifact

Module 3 — Events & Workflow Triggers

Topics

• GitHub events
• push
• pull_request
• workflow_dispatch
• schedule
• workflow_call
• workflow_run
• repository_dispatch
• Release events
• Issue events
• Tag events

Trigger Filters

• Branch filters
• Tag filters
• Path filters
• Activity types
• branches
• branches-ignore
• tags
• tags-ignore
• paths
• paths-ignore
• Glob patterns
• Combined filters

Manual Workflows

• workflow_dispatch
• Workflow inputs
• String inputs
• Boolean inputs
• Choice inputs
• Required inputs
• Default values

Hands-on Lab

Create a workflow that:

• Runs on Pull Request
• Runs on main
• Runs only when application files change
• Supports manual execution
• Accepts deployment environment as an input

The source curriculum includes the full event and filtering model, including manual, scheduled and external triggers.

Module 4 — Jobs, Dependencies & Conditions

Topics

• Sequential jobs
• Parallel jobs
• Job dependencies
• needs
• Fan-out
• Fan-in
• Job outputs
• Step outputs
• Conditional jobs
• Conditional steps

Status Functions

• success()
• failure()
• cancelled()
• always()

Hands-on Lab

Build:

          ┌── Unit Tests ──┐
Code ─────┤                ├── Package
          └── Security ────┘

Then implement:

Build
  ↓
Test
  ↓
Security Scan
  ↓
Package

with conditional execution.

Module 5 — Runners

Topics

• GitHub Actions runner architecture
• GitHub-hosted runners
• Ubuntu runners
• Windows runners
• macOS runners
• ARM runners
• Runner labels
• Runner workspace
• Temporary directories
• Tool cache
• Runner lifecycle

Self-Hosted Runners

• Architecture
• Installation
• Registration
• Labels
• Runner groups
• Repository-level runners
• Organization-level runners
• Security considerations

The supplied material includes both GitHub-hosted and self-hosted runner architecture, networking, security and lifecycle management.

Hands-on Lab

Configure a Self-Hosted Runner

Participants:

1. Provision a Linux VM.
2. Register the runner.
3. Add labels.
4. Execute a workflow.
5. Verify runner logs.
6. Remove the runner safely.

Module 6 — Variables, Contexts & Expressions

Variables

• Workflow variables
• Job variables
• Step variables
• Repository variables
• Organization variables
• Environment variables
• Variable precedence

Contexts

• github
• env
• vars
• job
• jobs
• steps
• runner
• secrets
• strategy
• matrix
• needs
• inputs

Expressions

${{ }}

Operators:

• ==
• !=
• >
• <
• >=
• <=
• &&
• ||
• !

Functions:

• contains()
• startsWith()
• endsWith()
• format()
• join()
• toJSON()
• fromJSON()
• hashFiles()

These contexts and expression capabilities are directly represented in the source curriculum.

Hands-on Lab

Create branch-specific behavior:

feature/* → test only
develop   → test + build
main      → test + build + deploy

Module 7 — Secrets & GITHUB_TOKEN

Topics

• Repository secrets
• Organization secrets
• Environment secrets
• Secret access policies
• Secret masking
• Secret rotation
• Least privilege
• secrets context

GITHUB_TOKEN

• Automatic token generation
• Token lifecycle
• Permissions
• permissions
• Read vs write access
• contents
• actions
• packages
• deployments
• id-token
• Security best practices

The source curriculum specifically covers GITHUB_TOKEN, permission scopes and least-privilege design.

Hands-on Lab

Implement:

Secure CI workflow

with:

• Repository secret
• Environment secret
• Restricted GITHUB_TOKEN
• Secret masking
• No secrets committed to Git

Day 1 Capstone

Build a Production-Style CI Pipeline

Participants create:

Developer
   │
   ▼
GitHub Pull Request
   │
   ▼
GitHub Actions
   │
   ├── Lint
   ├── Unit Test
   ├── Security Scan
   ├── Build
   └── Package
          │
          ▼
      Artifact

Day 1 Outcome

Participants finish Day 1 with a working CI pipeline.

Day 2 — Advanced CI/CD, Security & Cloud Deployment

Module 8 — Matrix Builds

Topics

• strategy.matrix
• OS matrix
• Runtime matrix
• Multi-dimensional matrix
• include
• exclude
• Dynamic matrices
• JSON-based matrices
• max-parallel
• fail-fast
• Matrix outputs

Hands-on Lab

Test an application against:

Ubuntu + Node 20
Ubuntu + Node 22
Windows + Node 20
Windows + Node 22

The source material specifically covers multidimensional matrices, dynamic matrices, parallelism and failure controls.

Module 9 — Caching & Artifacts

Dependency Caching

• actions/cache
• Cache keys
• Restore keys
• Cache hits
• Cache misses
• Package-manager caching
• npm
• Maven
• Gradle
• pip
• Cache security
• Cache poisoning

Artifacts

• Upload artifacts
• Download artifacts
• Artifact naming
• Retention
• Artifact sharing
• Build artifacts
• Test artifacts
• Deployment artifacts
• Artifact digests

Hands-on Lab

Build:

Build
  ↓
Create Artifact
  ↓
Upload
  ↓
Download
  ↓
Deploy

The source distinguishes dependency caching from workflow artifacts and includes their security, retention and sharing models.

Module 10 — Reusable Workflows

Topics

• workflow_call
• Caller workflow
• Called workflow
• Inputs
• Secrets
• Outputs
• secrets: inherit
• Nested workflows
• Cross-repository workflows
• Workflow versioning
• Workflow permissions
• Workflow templates

Hands-on Lab

Create:

Central CI Workflow
        ↑
 ┌──────┼──────┐
 │      │      │
App A  App B  App C

This introduces participants to enterprise-style centralized CI/CD architecture.

Module 11 — Environments & Deployment Protection

Topics

• Development environment
• Staging environment
• UAT environment
• Production environment
• Environment variables
• Environment secrets
• Required reviewers
• Deployment approvals
• Wait timers
• Branch restrictions
• Deployment history
• Environment concurrency

Hands-on Lab

Create:

DEV
 ↓
STAGING
 ↓
[Approval]
 ↓
PRODUCTIONCode language: CSS (css)

The source curriculum includes environment protection, reviewers, deployment restrictions, wait timers and deployment history.

Module 12 — Docker CI/CD

Topics

• Docker builds
• Buildx
• BuildKit
• Multi-platform builds
• Docker layer caching
• Registry authentication
• GitHub Container Registry
• Image tagging
• Image metadata
• Image publishing
• Image scanning
• Image signing
• Image attestations

Hands-on Lab

Build:

GitHub
   ↓
GitHub Actions
   ↓
Docker Build
   ↓
Security Scan
   ↓
GHCR

The supplied curriculum includes Docker Buildx/BuildKit, registry publishing, image scanning, signing and attestations.

Module 13 — GitHub Actions Security

This is an important DevOpsSchool differentiator for the course.

Topics

• Least privilege
• Workflow permissions
• Job permissions
• Secret management
• Untrusted input
• Script injection
• Command injection
• Expression injection
• Shell injection
• Fork PR security
• pull_request
• pull_request_target
• Third-party action security
• Action provenance
• SHA pinning
• Supply-chain security
• Self-hosted runner security

Anti-Patterns

Participants will identify risks such as:

❌ Secrets in workflow files
❌ Overprivileged GITHUB_TOKEN
❌ Unpinned actions
❌ Mutable action references
❌ Long-lived cloud credentials
❌ Unsafe pull_request_target
❌ Persistent public self-hosted runnersCode language: PHP (php)

The supplied curriculum contains a dedicated security-hardening section covering these risks and production controls.

Module 14 — OIDC & Cloud Authentication

Topics

• What is OIDC?
• Federated authentication
• Short-lived credentials
• GitHub OIDC tokens
• id-token: write
• Token claims
• Repository claims
• Branch claims
• Environment claims
• Cloud trust policies

AWS

• AWS IAM
• AWS STS
• AssumeRole
• GitHub OIDC provider
• IAM trust policy
• Credential-less deployments

Hands-on Lab

Implement:

GitHub Actions
      │
      │ OIDC
      ▼
AWS IAM
      │
      ▼
STS AssumeRole
      │
      ▼
AWS Resource

OIDC, AWS authentication, IAM roles, STS and credential-less cloud deployment are specifically covered in the source curriculum.

Module 15 — Kubernetes & GitHub Actions

Topics

• Kubernetes authentication
• kubeconfig
• Kubernetes manifests
• kubectl
• Helm
• Kustomize
• Namespace deployment
• Rollout verification
• Rollback
• EKS
• AKS
• GKE
• GitOps integration

Hands-on Lab

Implement:

Developer
   ↓
GitHub
   ↓
GitHub Actions
   ↓
Docker Build
   ↓
Container Registry
   ↓
Kubernetes
   ↓
Deployment

The supplied curriculum explicitly includes Kubernetes authentication, Helm, Kustomize, kubectl, rollout verification, rollback and managed Kubernetes platforms.

Module 16 — Terraform with GitHub Actions

Topics

• Terraform formatting
• Terraform validation
• Terraform plan
• Terraform apply
• Terraform state
• Terraform Cloud
• Plan artifacts
• Approval workflows
• IaC security scanning
• Drift detection

Recommended Pipeline

Pull Request
     ↓
terraform fmt
     ↓
terraform validate
     ↓
terraform plan
     ↓
PR Review
     ↓
Approval
     ↓
terraform apply

These Terraform automation topics are part of the supplied advanced curriculum.

Module 17 — Troubleshooting & Debugging

Topics

• YAML errors
• Workflow syntax errors
• Trigger problems
• Context debugging
• Expression debugging
• Runner problems
• Action failures
• Permission errors
• Authentication errors
• Secret problems
• Cache problems
• Artifact problems
• Matrix failures
• Deployment failures
• Network problems
• DNS problems
• Timeout issues

Debugging Techniques

• Workflow logs
• Job logs
• Step logs
• Debug logging
• Re-running workflows
• Re-running failed jobs
• Annotations
• Job summaries

These troubleshooting areas are explicitly included in the source reference.

Module 18 — Performance & Cost Optimization

Topics

• Workflow runtime optimization
• Parallel jobs
• Matrix optimization
• Dependency caching
• Docker caching
• Artifact optimization
• Shallow checkout
• Sparse checkout
• Path filtering
• Runner selection
• Larger runners
• Self-hosted runners

Cost Management

• GitHub Actions minutes
• Runner billing
• Artifact storage
• Cache storage
• Matrix cost
• Retention optimization
• Usage monitoring

The supplied curriculum includes both workflow performance and Actions cost optimization.

Day 2 Capstone Project

Production CI/CD Pipeline

Participants build an end-to-end pipeline:

                    GitHub Repository
                           │
                           ▼
                    Pull Request
                           │
                           ▼
                  GitHub Actions CI
                           │
             ┌─────────────┼─────────────┐
             ▼             ▼             ▼
           Lint          Tests        Security
             │             │             │
             └─────────────┼─────────────┘
                           ▼
                         Build
                           │
                           ▼
                    Docker Image
                           │
                           ▼
                    Container Registry
                           │
                           ▼
                       Staging
                           │
                     Approval Gate
                           │
                           ▼
                     Production
                           │
                           ▼
                    Verification
                           │
                           ▼
                       Rollback

Optional Cloud Extension

For participants with AWS access:

GitHub Actions
      │
      ▼
     OIDC
      │
      ▼
AWS IAM
      │
      ▼
    ECR
      │
      ▼
    EKS

6. Practical Labs

The course should be marketed as hands-on, rather than simply a theoretical GitHub Actions course.

Lab 1

Create first GitHub Actions workflow.

Lab 2

Build a CI pipeline.

Lab 3

Configure PR and branch triggers.

Lab 4

Use variables, contexts and expressions.

Lab 5

Configure secrets and GITHUB_TOKEN.

Lab 6

Implement matrix testing.

Lab 7

Implement dependency caching.

Lab 8

Create and consume artifacts.

Lab 9

Create reusable workflows.

Lab 10

Configure environments and approvals.

Lab 11

Build and publish Docker images.

Lab 12

Implement GitHub Actions security controls.

Lab 13

Configure AWS OIDC.

Lab 14

Deploy to Kubernetes.

Lab 15

Automate Terraform plan/apply.

Lab 16

Troubleshoot intentionally broken workflows.

7. Recommended Day-wise Schedule

8. Course Deliverables

Participants receive:

• Instructor-led training
• Presentation material
• GitHub Actions YAML examples
• Hands-on lab exercises
• Sample repositories
• CI/CD pipeline templates
• Docker workflow examples
• Reusable workflow examples
• Security checklist
• AWS OIDC example
• Kubernetes deployment workflow
• Terraform workflow example
• Troubleshooting guide
• Production best-practices checklist
• Capstone project

9. Skills Participants Gain

After completing the program, participants should be able to work with:

GitHub

→ Repositories
→ Pull Requests
→ Branches
→ Releases
→ Environments

GitHub Actions

→ Workflows
→ Events
→ Jobs
→ Steps
→ Actions
→ Runners
→ Secrets
→ Contexts
→ Expressions

CI/CD

→ Build
→ Test
→ Package
→ Artifact
→ Deploy
→ Approve
→ Verify
→ Rollback

Cloud/DevOps

→ Docker
→ Container Registry
→ AWS OIDC
→ IAM
→ Kubernetes
→ Helm
→ Terraform

10. Advanced Topics — Awareness / Take-Home

Because this is only a 2-day course, I would not attempt to teach every advanced topic in the supplied 1,800-line reference in depth.

Instead, these can be presented as advanced awareness topics / optional extensions:

• Custom JavaScript Actions
• Docker Actions
• Composite Actions
• Artifact Attestations
• Package Publishing
• Advanced Release Automation
• Self-hosted runner architecture
• Actions Runner Controller
• Monorepo workflows
• Multi-repository orchestration
• Workflow chaining
• GitHub API automation
• Repository governance
• Organization governance
• Enterprise governance
• GitHub Actions Importer
• act
• Advanced deployment strategies
• Canary deployment
• Blue/green deployment
• Progressive delivery

The source material contains dedicated sections for custom actions, runner architecture, ARC, monorepos, multi-repository workflows, API integration, governance, testing, maintenance and migration.

11. Course Positioning for DevOpsSchool

I would market this as:

A practical 2-day GitHub Actions CI/CD course that takes DevOps and engineering professionals from workflow fundamentals to production-ready CI/CD automation, including Docker, security, AWS OIDC, Kubernetes and Terraform integration.

The key differentiator should be “Learn GitHub Actions by building production-style pipelines”, rather than presenting it as a GitHub Actions syntax course.

Rajesh Kumar

I’m Rajesh Kumar, a DevOps, SRE, DevSecOps, Cloud, and Platform Engineering expert passionate about sharing practical knowledge, real-world experiences, and industry best practices. I have worked at Cotocus and regularly write about technology, travel, investing, health, product reviews, and digital marketing through my various platforms.

I publish technical articles at DevOps School, travel stories at Holiday Landmark, stock market insights at Stocks Mantra, health and fitness guidance at My Medic Plus, product reviews at TrueReviewNow, and SEO and digital marketing strategies at Wizbrand.