GitHub Actions with an Organizational Context

Explore the building blocks of GitHub actions in an organizational context, including triggers, jobs, steps, and actions. Practice building a workflow with hands on exercises and end of section assignment.

Learn how the on parameter triggers GitHub Actions workflows by selecting events like push, pull request, schedule, and workflow dispatch, with branches and cron timing.

Learn to configure GitHub Actions with the on parameter for push and pull request triggers, and practice simple workflows on a dedicated branch.

Master dispatch and schedule workflows in GitHub Actions. Use inputs for name and day, and a cron schedule to run tasks automatically, within an organizational context.

Learn how GitHub actions jobs form independent units in workflows, run on ubuntu runners or self-hosted environments, and use parallel or needs-based sequencing to coordinate tests, builds, and deployments.

Explore GitHub actions jobs syntax by running multiple jobs in parallel, then add needs dependencies so deploy waits for test jobs and observe failure skip behavior in pull request workflow.

Understand steps as individual tasks inside a GitHub actions job, defined by a name and either a run command or a users component, executed sequentially.

Learn how GitHub actions automate build, test, and deploy tasks by calling official, community, and custom actions from the marketplace, with inputs and secrets for workflows in organizations.

Learn to orchestrate step dependencies in GitHub Actions within an organizational context by using if conditions for success, failure, and always, with a hands-on four-step workflow.

Create a two jobs GitHub actions workflow named section two assignment, triggered by a branch push, with Ubuntu runners, code checkout, docker setup, and test and build echoes.

Demonstrate a two-job GitHub Actions workflow triggered by push to section two assignment branch, check out code, set up Docker using the build ECS action, and echo tests and build.

Concludes section two by encouraging workflow building, urging you to complete assignment without peeking at solutions, and strengthening the foundation before adding components, parameters, and functionality in the next section.

Explore secrets, environment variables, inputs, and outputs to enhance GitHub Actions workflows, learning what they are, how to use them, and practicing with an assignment.

Learn to use encrypted secrets in GitHub Actions to securely store API keys and passwords, manage repository and organization level secrets, and follow rotation and access best practices.

Learn how to store secrets in a repository or organization and call them in a GitHub Actions workflow to securely log into Docker using username and password.

Understand environment variables in GitHub actions workflows, including default and custom vars, how to access them with env and the ${{ GitHub.* }} syntax, and naming conventions and documentation.

Explore how to use GitHub's default environment variables in workflows, including actor, repository, and ref, to make dynamic, reusable workflows and inspect runtime values.

Define and use custom environment variables in GitHub workflows across root, job, and step levels. See how environment, day, and time variables render in output.

Explore inputs in GitHub actions to customize workflows, including mandatory and optional fields, defaults, descriptions, and the role of reusable workflows in organizational contexts.

Define and use custom inputs in a dispatch workflow, including boolean, choice, and string types, to gate jobs and configure actions like set up Node.js.

Explore how outputs in GitHub actions pass data between steps and across jobs, using step and job level outputs and the needs syntax. Practice clear naming and documentation.

Explore how to create and consume custom outputs in GitHub Actions, reuse outputs from actions, and pass values across jobs using needs and job-level outputs within an organizational context.

Build a GitHub Actions workflow using secrets, inputs, outputs, and environment variables. Create a two-job pipeline with docker login and run tests, controlled by a user input and environment choice.

Design and validate a section three assignment workflow in GitHub actions with manual dispatch, including docker login and test runs, using user and environment inputs and secrets to report status.

Explore how four components enhance GitHub actions workflows, boosting usability and functionality in an organizational context. Practice and experimentation will unlock deeper workflow capabilities in the next section.

Explore four useful tools for GitHub Actions workflows: matrix builds, expanded if statements, artifacts, and caching to boost functionality, speed, and reliability.

Introduce real tests in the workflow by adding simple Node.js lint and unit tests with eslint and jest, and demonstrate a basic GitHub actions setup to run them.

Learn how matrix builds in GitHub Actions run the same job across multiple configurations in parallel, enabling testing across node versions and operating systems while improving workflow efficiency.

Explore how to use matrix builds in GitHub Actions to run lint and unit tests in parallel, reducing duplication and speeding workflows through a matrix strategy.

Explore advanced if statements in GitHub actions within an organizational context, combining matrices, multiple conditions, contextual variables, and outputs to fine-tune workflow decisions.

Learn to use advanced if statements in GitHub actions to conditionally run tests, build, deploy, and failure notifications based on pull requests, pushes, and workflow outcomes.

Learn how artifacts and caching in GitHub Actions persist build outputs and dependencies, speeding workflows and enabling data sharing across jobs, archiving, and auditing across the organization.

Master artifact management in GitHub Actions by uploading and downloading build artifacts, running builds on pull requests and pushes to main, then deploying the fetched artifact in an organizational workflow.

Implement caching in GitHub Actions to skip re-running tests when the app files haven't changed, by saving test results to a cache keyed by the app hash.

Explore GitHub Actions in an organizational context by linking artifacts, cache, and tests through a pull request workflow, then build, upload artifacts, and deploy the app.

Review the section four assignment workflow, which covers matrix builds, if statements, artifacts, and caching, and modify it to test different artifact handling and a retention days parameter.

Explore the usefulness of matrix builds and if statements in GitHub Actions, and practice their syntax to improve your workflows. Dive into Docker and containerized building in the next section.

Learn how GitHub Actions rely on containerized builds, with jobs running in containers, and how to package apps with Docker for registries like Docker Hub or AWS ECR.

Learn Docker and containerization concepts and how containerized builds work inside GitHub Actions. Discover advantages like consistency, isolation, portability, scalability, and improved dependency management for workflows.

Build a docker image using a docker file on an alpine base, moving app files into an app folder, and update the workflow to run docker build with buildx.

Learn how to push a built docker image to your docker account within a GitHub Actions workflow, using separate pull request and main merge jobs, with commit sha tagging.

Pull a docker image in the deploy app job using the sha tag after the image is built and pushed. The lesson discusses public and private registries and login.

Push and pull container images with Docker in GitHub actions to enable containerized builds and experiment with your organization's container tool.

Explore a growing set of odds and ends in GitHub Actions, small but highly useful features that expand your workflows.

Explore concurrency keys in GitHub Actions to control workflow and job execution, enabling singleton runs and resource locking, with examples from Terraform and multi-repository deployments.

Explore how concurrency keys govern execution at both workflow and job levels, showing how workflows queue and how individual jobs with or without concurrency interact in GitHub Actions.

Explore how the continue on error parameter in GitHub actions lets a workflow proceed after a failing step, by assigning it to the failing step and enabling resilient error handling.

Learn how to use continue on error in a GitHub Actions workflow to run subsequent steps after a failure and still generate a test report.

Understand the timeout minutes parameter in GitHub actions, which limits workflow duration and prevents indefinite runs. Apply it to CI, resource cleanup, and scheduled jobs with practical best practices.

Demonstrate how the timeout minutes parameter in a GitHub Actions job cancels a long-running step, using sleep to illustrate and showing how to set timeouts for stuck test suites.

Discover how to extend GitHub Actions with the step summary to display per‑job information, including test results and build links, on the workflow page using markdown.

Explore creating a GitHub step summary to enhance the workflow ui, using basic formatting syntax, conditional content based on job status, and custom blocks for lint and unit test results.

Learn how the GitHub token authenticates each workflow run and how permissions are scoped and overridden across repository, organization, workflow, and job levels.

Explore how the permissions parameter in a GitHub Actions workflow controls write access, illustrated by a 403 error, then a successful run after granting repository write permissions for the organization.

Explore how repository dispatch triggers GitHub actions, enabling external events to start workflows, pass payloads, and trigger another workflow for CI/CD and external integrations.

Use Peter Evans' repository dispatch action to trigger a second workflow from the first, including event types, client payload, and cross-repo tokens, with a main-branch demo.

Explore reusable workflows in GitHub actions and learn how they streamline organization-wide automation across multiple repositories, with versioning and implementation options.

Use reusable workflows in GitHub actions to enable modular, maintainable CI/CD across repositories. Learn how they run via the workflow_call trigger, accept inputs, and centralize common tasks for consistency.

Compare configuration options for reusable workflows in GitHub Actions, between same-repository setups with relative paths and centralized repositories, weighing repository name references, simplicity, standardization, versus complexity and versioning.

Configure reusable workflows in GitHub Actions by detailing eight parameters: name, on workflow_call, inputs, secrets, outputs, concurrency, permissions, and jobs, and explain how they are invoked by other workflows.

Learn to build a reusable workflow and a caller workflow in the same repository, on the main branch, with inputs such as docker file path and docker hub secrets.

Create a centralized reusable workflows repository and configure access so other repositories owned by the same user can call reusable workflows in an organizational context.

Store a reusable workflow in a central repository and reference it from your main repo by path and branch, enabling easy maintenance across many projects in an organization.

Learn to add concurrency and define outputs in reusable GitHub Actions workflows, expose job outputs to caller workflows, and understand concurrency scope within a repository.

Learn how semantic versioning, tags, and releases enable reproducible, compatible reusable workflows and organized repositories. Discover guidelines for consistent versioning, release notes, and effective rollback strategies.

Explore versioning in github actions by releasing numbered versions of reusable workflows, referencing specific versions instead of main, and demonstrating how major changes with inputs affect caller workflows.

Create two reusable workflows in the repository: one triggers on pull request opened for lint and unit tests; the other on merge to build, push docker image, and simulate deployment.

Create and refine reusable workflows that run London unit tests and build a Docker image without pushing, then implement a push-and-deploy workflow that tags images and simulates deployment.

Learn how to implement caller workflows that invoke reusable workflows on pull requests and merges, including Docker push and production deployment to a container registry.

Create custom actions for GitHub workflows by building the same feature as JavaScript, Docker, and composite actions to compare construction. Learn what custom actions are and why to use them.

Discover why to build custom actions in GitHub Actions, how step-level actions differ from job-level reusable workflows, and guidelines for design, security, and testing.

Explore the three main types of custom GitHub actions—JavaScript, Docker, and composite actions—and how each is constructed for use in workflows.

Create a centralized repository for custom actions to illustrate organizational best practices, separate from reusable workflows, and build three actions with a shared approach and tests.

Create a custom composite action in GitHub Actions, packaging node setup, dependency installation, and optional lint and unit tests into a reusable action called from a centralized organization repository.

Call a composite action from a workflow by referencing the account/repository and folder on the main branch, pass inputs, manage defaults, and run tests with node setup and npm install.

Create a custom node.js action for GitHub actions by building the action YAML, index.js, and package.json, wiring inputs and outputs, and running npm install with lint and unit tests.

Learn to call a javascript action in GitHub actions. Set up node as a standalone step, wire the node action folder, and display lint and unit test outputs.

Create a custom Docker action by building a Docker file and entrypoint, wiring an action YAML, and passing inputs to run npm install, lint, and unit tests.

Learn how to create and call a Docker action within a GitHub Actions workflow, including writing the action YAML, building a Docker file, and mapping inputs to the entrypoint arguments.

Explore the fundamental differences between composite, Java, JavaScript, and a Docker-based custom action, their strengths and weaknesses, and how to decide which structure to use for individuals or organizations.

Explore a basic ci/cd structure using github actions to illustrate how an organizational ci/cd pipeline can be built; follow along or watch to spark your own creativity.

Learn to build a CI/CD pipeline with GitHub actions that tests, builds, and deploys a containerized app to a Kubernetes environment using Minikube and Argo CD with open source tools.

Create a fine-grained GitHub token with read access to actions, contents, and metadata, then connect Argo CD and point to a k8s folder with yaml files.

Add a required platforms input to the reusable test and build workflows, remove the deploy job, and release a major version for Argo deployment in the main repo.

Add new application files and adjust deployment yamls for a background-running Argo app. Align names across files and prepare PR tests and deployment workflows.

Create a pull request workflow that triggers on the main branch, uses a reusable workflow to run tests and builds for linux/amd64 and linux/arm64, and defines inputs and docker secrets.

Update the dockerfile at the repository root or create one in the original app folder, and ensure the working directory points to the argo app with correct folder references.

Builds and pushes docker images, then updates the Kubernetes manifest with the new GitHub sha. Commits and pushes the change to the main branch to trigger deployment with Argo.

Learn to automate releasing new versions in GitHub Actions using a create release action with tag name, release name, and release notes, triggered by a workflow dispatch and manifest updates.

Merge a pull request, trigger the release workflow, build and push a Docker image, update the manifest with the new tag, and sync ArgoCD to deploy a healthy Argo app.

Explore how GitHub actions and workflows manage docker images and Argo in an organizational context, using reusable and master workflows as a starting point for experimentation.