Teach on Udemy

Turn what you know into an opportunity and reach millions around the world.

Learn More

Your cart is empty.

Keep shopping

The Complete GitHub Actions & Workflows Guide

Name: The Complete GitHub Actions & Workflows Guide
Rating: 4.5 (4044 reviews)

Automate Code Testing, Deployment & Versioning using CI/CD Workflows. Create & Publish GitHub Actions to the Marketplace

Created byAli Alaa

Last updated 9/2025

English

What you'll learn

Learn about writing serialized data in the YAML format.
Learn about all the GitHub Actions concepts (Workflows, Steps, Jobs, Actions, etc..)
Discover everything you can do in a GitHub workflow (events, schedules, filtering, environment variables, context, encryption, matrix and more)
Learn how docker can be used in a GitHub workflow
Create a real-life CI/CD workflow for code testing, formatting, versioning and more.
Use caching in workflows for an improved performance.
Learn about uploading artifacts in workflows.
Learn about how to create your own custom GitHub Actions using Javascript or Docker
Create an action for opening GitHub issues using JavaScript.
Create an action for sending slack messages using PHP.
Learn how to publish GitHub actions in the GitHub marketplace.

Course content

8 sections • 87 lectures • 14h 56m total length

Before Starting the Course2:34
Adjust video quality and playback speed, access the resources menu with the lecture's GitHub repo, use the Q&A to ask or search questions, and note the code editor font guidance.
Introduction to GitHub Actions & Workflows10:15
Explore how GitHub Actions automate software workflows by responding to repository events or external triggers, with workflows built from jobs, steps, and actions running on GitHub-hosted, self-hosted, or larger runners.
Introduction to the YAML Format14:24
Explore how YAML structures GitHub workflows, compare YAML to JSON, and master core concepts like root objects, maps, sequences, quotes, indentation, and literal and folded blocks for multi-line text.
Let's Create Our First Workflow10:44
Create your first GitHub actions workflow by building a repository, placing a workflow in .github/workflows, and running a simple ubuntu job that echoes commands and checks node and npm versions.
Parallel & Dependent Jobs6:22
Learn to create multiple jobs in GitHub Actions, run them in parallel or make one depend on another using needs, with macos-latest and windows-latest runners and workflow visualization.
An Overview to Managing Our Workflow Runs through the Web UI & the GitHub CLI6:51
Learn to manage GitHub Actions workflow runs using the web UI and the GitHub CLI, view logs and visualizations, disable or enable workflows, rerun jobs, and monitor organization runners.
Debugging Our Workflow Runs6:17
Learn to debug GitHub workflow runs by inspecting logs, downloading log archives, and rerunning with step and runner debug logging via repository variables and secrets.
Skipping Workflow Runs1:37
Skip a GitHub Actions workflow for a specific commit by including keywords like skip ci, ci skip, or no ci in the commit message, without disabling the workflow.
Introduction to Workflow Commands12:04
Learn how to send shell commands from a GitHub actions workflow to the runner, echo structured messages (error, debug, warning, notice), group logs, mask secrets, and set environment variables.
Quick Note0:26
Shells & Working Directories12:36
Explore working directories and shells in GitHub Actions workflows, learn how to set defaults and override shells at workflow, job, or step level, and inspect environment variables.
Downloading Our Repository into the Runner Machine7:38
Learn why repos aren't cloned by default in GitHub actions and how to checkout by initializing a git repo, adding origin, fetching, and checking out main.
Introduction to Actions10:49
Explore actions as reusable units in GitHub Actions, including JavaScript, Docker, and composite types, learn to pass inputs and outputs, and reference actions in workflows.
The Checkout Action5:03
Apply the checkout action in a GitHub Actions workflow to check out the commit based on the triggering event, compare it with manual checkout, and learn about authentication and inputs.

Repository Events (ex. Push, Pull Request, Issues)12:21
Explore how repository events like push, pull_request, and issues trigger workflows. Learn how GITHUB_REF and GITHUB_SHA determine checkout targets and how activity types affect triggers.
Events Activity Types4:16
Learn how to specify activity types for repository events like pull requests and issues, using an object with event keys and types to control when workflows run.
Workflow Run Approval from Fork Pull Requests4:50
Learn how to handle workflow runs triggered by fork pull requests, including approval requirements for first-time and outside collaborators, and how to approve and run the checks.
Using the Pull Request Target Event10:45
Explains the pull_request_target event, which runs in the base branch to handle actions like commenting or labeling when a pull request opens, without running untrusted code from the head branch.
Running a Workflow Based on Another Workflow4:18
Trigger a workflow when another workflow completes using the workflow run event, such as after the Repository Events workflow finishes. Learn three-level nesting limits and test by pushing code.
Filtering Our Workflow Runs by Branches, Tags and Paths9:43
Understand how to filter workflow runs by branches, tags, and paths for push, pull request, and workflow run events, using patterns like feature/* and **, with exclusions and order rules.
Manually Triggering a Workflow from the GitHub Web UI, CLI and the REST API17:29
Trigger a workflow using the workflow dispatch feature from the main branch via the GitHub web UI, the CLI, or REST API, with inputs like string, number, dropdown, and environment.
Using the Repository Dispatch Event for External Events9:16
Trigger workflows from external events using the repository_dispatch event and the rest api. Send an event_type and optional client_payload to run a workflow on the default branch.
Running Workflows on a Schedule11:41
Learn to run GitHub actions on a schedule with cron expressions, automate stale checks that mark old issues and pull requests as stale, and configure days before stale or close.

Expressions & Contexts14:17
Explore expressions and contexts in GitHub actions, using the ${{ }} syntax to evaluate literals, operators, and functions, and access contexts like GitHub, inputs, steps, and secrets to customize runs.
The If Key & Expression Functions13:20
Use the if key and expressions to control when GitHub workflows run, leveraging GitHub context and functions like contains, fromJson, and join for push vs issues and PRs.
Status Check Functions11:47
Explore status check functions in GitHub actions by building a workflow with two jobs, using failure, success, always, and canceled to control when steps or jobs run.
Default & Custom Environment Variables10:27
Learn how default and custom environment variables work in GitHub Actions, and compare environment variables to context (github.ref) for runner-side versus actions-side evaluation.
Setting Environment Variables During the Execution of a Workflow10:52
Learn to dynamically set and override environment variables during a GitHub Actions workflow by writing to the GitHub env file, using Bash or PowerShell, including multi-line formats with a delimiter.
Configuration Variables & Secrets16:03
Define configuration variables and secrets at the environment, repository, or organization level to share across workflows. Access them via the vars and secrets contexts and understand precedence across environments.
Encrypting & Decrypting Large Files in a Workflow10:57
Encrypt secret.json with GPG AES256 to bypass secret size limits and decrypt it inside a GitHub actions workflow, using a repository secret for the passphrase.
The GITHUB_TOKEN Secret & Customizing its Permissions9:32
Configure the automatically generated GitHub token secret by using a permissions key at the workflow or job level to grant only needed scopes, such as pull requests write.

Timeout Minutes & Continue on Error6:58
Learn to control GitHub actions workflows with timeout-minutes and continue-on-error, enabling steps or jobs to fail gracefully or continue. Explore run-conditions like success, failure, always, and cancelled.
Running a Job Multiple Times Using a Matrix9:40
Learn to run a GitHub Actions job multiple times with a matrix, using setup-node for multiple node versions, multi-dimensional matrices, and controls like max-parallel, fail-fast, and continue-on-error.
Including & Excluding Matrix Configurations10:14
Explain how to extend a GitHub Actions matrix with includes and excludes, merging extra keys without overriding original combinations and illustrating with ubuntu-latest, Mac OS latest, and node versions.
Handling Failing Jobs in a Matrix3:40
Learn to use a dynamic continue-on-error with a matrix to let experimental jobs fail without stopping the workflow, while others still trigger fail-fast as needed.
Step and Job Outputs & Dynamic Matrices17:18
Learn how to build a dynamic GitHub Actions matrix by converting string inputs into arrays with a prepare-matrix step, using workflow_dispatch inputs, and exposing job outputs for downstream steps.
Running a Single Job or Workflow at a Time Using Concurrency12:22
Learn how to enforce concurrency in GitHub Actions, ensuring only one job or workflow runs at a time, using workflow level groups, cancel-in-progress, and environment-aware dynamic concurrency.
Reusable Workflows16:21
Learn to create reusable workflows in GitHub actions, call them from a caller workflow, pass inputs and secrets, and configure organization settings to enable cross-repo reuse.
Reusable Workflow Outputs7:23
Learn to create a reusable workflow that outputs values via github_output and call it from another workflow to access the date output.
Nesting Reusable Workflows7:53
Discover how to nest reusable workflows in GitHub Actions, passing secrets down through multiple levels, using inherit to share secrets, while understanding permission limits and the four-level nesting cap.
Caching Files in Github Actions14:22
Learn how to cache npm dependencies in GitHub Actions with the actions/cache extension, and manage cache hits and misses using a dynamic key that updates when package-lock.json changes.
Updating Cache Keys Dynamically & Adding Restore Keys9:10
Learn to dynamically update cache keys with hashFiles of package-lock.json, add restore keys, and optimize npm dependency caching in GitHub Actions workflows.
Cache Limits & Restrictions4:39
Explain how caching in GitHub actions works, including seven-day inactivity, a ten-gigabyte limit, and branch access rules, plus the limited scope of pull request caches and cleanup workflows.
Uploading & Downloading Job Artifacts10:54
Learn to upload and download artifacts in GitHub actions, save code-coverage reports produced by Jest, and share results across jobs using artifact names and paths.

Running Jobs in Docker Containers10:22
Run GitHub actions jobs inside Docker containers on Ubuntu runners using Node images from Docker Hub or ghcr.io, with env vars, ports, and volumes.
Using Docker Containers in Steps8:06
Learn to run steps in separate Docker images within a GitHub Actions workflow: override the entry point, pass arguments, and understand how container steps share networks and volumes.
Exploring Shared Networks & Volumes Between Multiple Containers8:43
Explore how multiple containers share the same network and volume mounts on the host running a GitHub workflow, with shared working directories and entry point overrides.
Creating a Custom Docker Entrypoint Script4:49
Create a custom docker entrypoint with a shell script, make it executable, and run it in a workflow container to echo arguments and display node -v.
Sending a Slack Message Using a Docker Container5:23
Send a Slack message from a GitHub Actions workflow using a Docker image and a Slack webhook. Configure environment variables and secrets to customize the title, message, and color.
An Overview to a Simple NodeJS Application9:10
Learn to run a simple node-js api with a mongo database using service containers and docker-compose in GitHub Actions, including local testing and deploying via Docker Hub images.
Using Service Containers in GitHub Actions13:47
Replicate Docker Compose in a GitHub Actions workflow using multiple service containers for app and Mongo, communicating via service names and adapting ports for host versus container runs.
Publishing Docker Images Using GitHub Actions14:27
Publish docker images with GitHub actions by building and pushing on new releases, using Docker login and metadata to tag versions like 1.2.3, 1.2, and latest, with optional ghcr.io deployment.

Actions Overview5:12
Learn to write public and private actions, reference them by commit, branch, or tag, and publish them to GitHub Marketplace. Compare Docker, JavaScript, and composite actions.
Creating a Simple JavaScript Action15:40
Create a private JavaScript action with inputs and outputs, defined in action.yaml, using node 16 and actions core and actions GitHub; learn bundling for runner execution.
Compiling The Action's JavaScript Code into One File7:30
Bundle your JavaScript action into one file with ncc, install vercel/ncc globally, and point actions.yaml to dist/index.js to run on GitHub runners.
Creating a Simple Docker Action16:40
Create a simple docker action by building a Dockerfile with an entrypoint.sh, wiring inputs, outputs, and environment variables like INPUT_WHO_TO_GREET and GITHUB_OUTPUT. Include a cleanup.sh post-step.
Bundling Steps into an Action with Composite Actions18:10
Bundle multiple steps into a reusable composite action that generates a joke via an API, saves it, and posts the joke to Slack via a webhook, optionally uploading an artifact.
Writing a Docker Action for Sending a Slack Message Using PHP (Part 1)9:28
Write a Docker-based GitHub action using PHP to send a Slack message via an incoming webhook, including building a PHP script, using Composer, and optional rich blocks.
Writing a Docker Action for Sending a Slack Message Using PHP (Part 2)13:53
Create a docker-based GitHub action in PHP to send Slack messages using a webhook, wiring inputs, secrets, and a Dockerfile with Composer dependencies (Part 2).
Using an Official GitHub Template for Writing JavaScript Actions9:08
Explore the official javascript-action template to create a public GitHub action, publish to the marketplace, and review action.yml, index.js, ESLint, Jest tests, dist with ncc, and codeql-analysis workflows.
Creating a JavaScript Action for Opening Github Issues15:28
Build a JavaScript action that opens a GitHub issue via the REST API, using npm install actions/github and octokit, with inputs for token, title, body, and assignees, outputting the issue.
Creating Releases & Publishing Our Action to the Marketplace8:23
Learn to create releases and publish your GitHub action to the marketplace, including documenting inputs/outputs, adding branding, and managing version tags to point major versions.
Automating Release Management For Our Action8:37
Automate release management for GitHub actions by using a build-and-tag action to keep major and minor version tags synchronized with the latest commit, triggered by releases.

Introduction the Application that We are Going to Automate9:36
Set up a GitHub Actions CI/CD workflow to automate testing and deployment of a React app, including unit tests, end-to-end tests with Playwright, linting, and formatting.
Let's Discuss Our Workflow Plan9:03
Explore a GitHub Actions workflow plan that protects main, uses feature branches, runs tests and code scans, deploys via isolated AWS environments on PR with feature flags and automated versioning.
Using Flagsmith to Add Feature Flags to Our Project12:43
Learn to integrate Flagsmith to toggle features across environments (development, staging, production) in a Next.js project, render server-side, manage environment keys, and mock tests.
Deploying Our App to AWS Elastic Beanstalk12:46
Deploy a node.js app to aws elastic beanstalk using the aws cli and eb cli, creating iam credentials, configuring a profile, and setting environment variables such as FLAGSMITH_KEY.
Configuring Repository Protection Rules & Environments11:55
Configure repository protections and environments by applying code owners, enforcing main branch protections, and creating staging and production environments with secrets and variables for Elastic Beanstalk deployments.
Creating a Workflow to Test Our App15:52
Create a reusable GitHub Actions test workflow that installs dependencies, checks formatting and types, builds, runs unit and end-to-end tests with Playwright, uploads artifacts, and notifies Slack on failure.
Fixing and Running Our Test Workflow & CodeQL on Pull Request15:57
Set up a pull request workflow and CodeQL analysis in GitHub Actions, manage secrets and concurrency, and enforce branch protection by requiring test and code quality checks before merging.
Caching Playwright Browsers to Make Our Workflow Faster7:09
Cache Playwright browsers in a GitHub Actions workflow to speed up test runs, using actions/cache with a dynamic key based on Playwright version and restoring from cache on subsequent runs.
Creating a Workflow to Deploy to AWS Elastic Beanstalk (Part. 1)15:35
Automate deployment to AWS Elastic Beanstalk with a reusable GitHub Actions workflow, deploying pull request branches to isolated environments and managing staging and production with protection rules.
Creating a Workflow to Deploy to AWS Elastic Beanstalk (Part. 2)21:18
Learn to automate deploying to AWS Elastic Beanstalk with GitHub Actions, including checking environment existence, creating or deploying to environments, initializing eb, handling environment variables, and notifying via Slack.
Testing Our Deploy Workflow9:41
Test the deploy workflow by manually triggering deployments to staging and production on AWS, handling environment creation, EB CLI setup, and Slack notifications, then validate URLs and environment variables.
Adding Changesets to Handle our App's Versioning10:58
Manage versioning with changesets by generating changeset files for pull requests, updating changelogs, and driving semantic version bumps for non-npm projects using the changesets workflow.
Creating a Version Pull Request on Pushing Changeset Files16:44
Automate creation or updating of a version pull request when pushing changeset files, updating changelog, deleting changesets, and publishing releases via a changesets GitHub action.
Testing & Deploying to Staging & Production when Merging Version Pull Requests17:02
Learn how to test and deploy to staging and production after merging a version pull request using changesets to generate releases, with Slack alerts, conditional tests, and sequential deployments.
Quick Note0:23
Deploying Pull Request Branches to Isolated AWS Environments (Part 1)15:03
Deploy pull request branches to isolated AWS environments using GitHub Actions, triggered by a /deploy comment on PRs. Destroy environments on PR close or merge, or via a /destroy comment.
Deploying Pull Request Branches to Isolated AWS Environments (Part 2)15:34
Learn to deploy pull request branches to isolated AWS environments by manually triggering a deploy workflow with the PR ref and posting deployment status updates to the PR.
Terminating Pull Request AWS Environments13:29
Explore the destroy-pr-env workflow that terminates a pull request environment on AWS using the EB CLI, triggered by '/destroy' comments or PR closures, with deployment status updates.
Detecting Errors Before Committing Our Code Using Git Hooks9:57
Learn to prevent errors before pushing by using git hooks with husky to run format, lint, and typecheck on staged files, aided by lint-staged for efficiency.
Quick Note0:26
Using OIDC for AWS Authorization Instead of Storing Secrets18:49
Use OpenID Connect to authorize AWS access from GitHub actions, replacing stored secrets with a trust policy and short lived JWT tokens.
Customizing the OIDC JWT Token Subject for More Granularity12:42
Customize the OIDC sub in AWS trust policies by sending a GitHub API request to include repo, environment, and job workflow ref. Enable granular access for deploy and destroy-pr-env workflows.
Quick Note0:23

Requirements

You should have basic GitHub knowledge
Some lectures will require some basic docker knowledge (it's not necessary if you want to skip it)
Creating custom actions requires JavaScript and/or docker knowledge
For some sections some stuff must be installed on your machine including: nodejs, npm, docker, composer, php.
The last section requires an AWS account if you follow actively and you might be charged.

Description

NOTE: The last section in the course requires an AWS account and you might be charged if you follow the section actively. Check the promo video for more information.

GitHub recently released GitHub Actions", a CI service competitor to services like TravisCI and CircleCI. GitHub Actions however has the edge of being natively integrated with your GitHub repository. In addition to that, thanks to GitHub's popularity; GitHub Actions has the advantage of having large ecosystem and community. Using GitHub Actions you will find a lot of official and community pre-made workflows and also the actions marketplace. In the actions marketplace you can find tons of actions which are reusable pieces of code that you can use in your workflows to perform certain tasks like deploying code, interacting with API's, sending SMS's, etc..

Learn everything you need to know in order to create GitHub workflows & Actions.

In this course we will comprehensively explore GitHub's CI service. We are going to learn what GitHub workflows & actions are. And we will discover everything we can do in a GitHub workflow including how to run commands, use actions, trigger workflows, build matrices, reuse workflows, use docker and more. We are going to learn how to write custom actions and publish them to the marketplace so that other people can use them. Finally, we will use what we learned to create a real-world example of a CI/CD workflow where we will test, build, deploy a web application to AWS.

Let's take a look at what will be discussed in each section in more detail:

Section 1

In section 1 we will have a conceptual introduction to Github Actions. We are going to learn what terms like workflows, actions, jobs, steps and other terms mean. We are also going to learn about YAML which is the format used to write workflows in GitHub. Then we will start writing our first workflow and take a look at basic things like writing commands, using different shells and using actions including the most common action which is the checkout action.

Section 2

In section 2 we will get a bit deeper and learn different ways that we can use in order to trigger a workflow to run. This includes GitHub events like push and pull_request, external events, manual events and CRON schedules. We will also see how to make a workflow only run for certain branches, tags and directory paths.

Section 3

In this section we will take a look at how to write expressing in a workflow. And how to use context information and functions in our workflows. We will also see how can we use default environment variables and also how to add custom environment variables. We will discover how to encrypt sensitive information and also how to encrypt and decrypt sensitive files that we don't won't to push to our repository. Moreover, we will take a look at the GITHUB_TOKEN environment variable and how to use it to perform certain actions and how to customize its permissions.

Section 4

In section 4 we will see how can we setup matrices, a matrix is a way to run a job multiple times but using different configurations. We will also learn about concurrency and how to reuse our workflows to avoid duplication. We are also going to take a look at caching and uploading and downloading artifacts.

Section 5

In section 5 we are going to discuss using docker in GitHub Actions. We are going to see how to use docker images in our jobs and steps. We are also going to learn about running multiple service containers together and see how to communicate between them. Finally we are going to see how can we automate publishing docker images to DockerHub and the GitHub Container Registry.

Section 6

During the course we will use some actions that are available in the marketplace. But in this section we are going to learn how to create our own actions. Actions can be created using JavaScript or using Docker. In this section we are going to learn about both ways and then we will create a JavaScript action that opens GitHub issues and a docker action that sends a slack message which we will write using PHP. We will also discover another way of writing actions which is Composite Actions.

Section 7

In section 5 we will finally use our knowledge to create a real-world CI/CD example. In this section we are going to use an Amazon service called Elastic Beanstalk to deploy our app. We are going to use feature flags to continuously integrate and deploy our app without exposing all features to the end user. We are going to automate versioning our app and generating changelogs. In addition to that, we are going to add the option to deploy pull request branches to an isolated AWS environment and also add the option to destroy that environment. We are finally going to see how to use OpenID Connect to access AWS from our workflows without having to store any credentials. This section requires an AWS account and you might be charged if you follow the section actively.

Who this course is for:

Developers/Software engineers who need to learn everything about GitHub Workflows & Actions.
Developers/Software engineers who want to create a CI/CD workflow using GitHub
Developers/Software engineers who would like to learn how to create and publish GitHub Actions.

The Complete GitHub Actions & Workflows Guide

What you'll learn

Explore related topics

Course content

Introduction & Basic Concepts14 lectures • 1hr 48min

Events that Trigger Workflows9 lectures • 1hr 25min

Expressions, Contexts, Functions, Environment Variables & Secrets8 lectures • 1hr 37min

Diving Deeper with More Advanced Github Actions Features13 lectures • 2hr 11min

Using Docker in GitHub Actions8 lectures • 1hr 15min

Creating & Publishing Our Own Actions11 lectures • 2hr 8min

Let's Create a Complete CI/CD Workflow23 lectures • 4hr 33min

Conclusion1 lecture • 1min

Requirements

Description

Who this course is for: