The Complete GitHub Actions & Workflows Guide

In this lecture we will learn about different github events that can trigger a workflow to run like push, pull_request and issues. We will also see what are activity types and how to use them.

In github actions, we can run workflows at certain scheduled times using the crontab schedule expression. Let's take a look at that in this lecture.

Play around with crontab.guru and then come back here and try to complete this quiz without using the tool.

We can choose to run our workflows only if we push to certain branches, tags. We can also exclude branches and tags. And we can also filter by certain paths or file types. Let's see about that in this lecture.

Now it's time to make sure we correctly understand filtering and patterns. Take a look at this cheat sheet before/while solving this quiz: https://help.github.com/en/actions/automating-your-workflow-with-github-actions/workflow-syntax-for-github-actions#filter-pattern-cheat-sheet

In this lecture we will learn how to set our own environment variables. And also how to scope environment variable to a workflow, a job or a step. We will also see what default environment variables does github provide us.

Sometimes we might need to use some sensitive information in our workflow. For example, we might need to call some third-party API which required a secret to authenticate. In this case we should encrypt our key in order not to be exposed in the workflow file.

Using the GITHUB_TOKEN secret we can do some interesting stuff in our workflow. For instance we can call Github's REST API to perform some operation in our repository.

Sometimes simple secrets are not enough. In some cases we might need to encrypt large files and decrypt and use them in our workflow. This is possible in github using the gpg cli tool.

Similar to contexts, Github also provides us with some functions that we can use in our expressions. Let's take a look at these in the next lecture.

In addition to the utility functions that we saw in the last lecture, Github also provides us with additional functions that can help us check the status of our job.

In this quick lecture we will just take a look at a couple of options that you should know about in your workflows. And these are: continue-on-error and timeout-minutes.

Before creating our first matrix, let's see how we can use the setup-node action in order to change the node version in our environment.

Let's know see how to use the strategy option in order to create multiple runs of the same job but using different environments.

In matrices we can exclude some configurations from running or we can add extra information to a specific configuration.

Instead of running our jobs directly on our vitual machines, we can run them in a docker container. Let's see how can we specify a docker container in our jobs.

In some cases we might need to use docker-compose to run an application that needs multiple services. Let's take a look on a simple example of that so that we can try to run it on our workflow in the next lecture.

Let's now see how can we run the application that we ran using docker in the last lecture but this time inside of our workflow.

In addition to using docker containers in our whole jobs, we can also specify different containers to run inside of each of our steps.

In addition to using executables that we have on our system, we can also write our own scripts and run them as entrypoints to a docker container in our steps.

Let's Create a simple application that our workflow will run on. We will use create-react-app to bootstrap this application.

Let's see what commands we will have to use when writing our workflow.

Let's see how can we use surge to deploy our application locally. Later we will automate this process in our workflow.

Let's install a tool that will help us enforce some code formatting rules in our workflow. And this tool is called prettier.

Before getting into the code, let's first discuss the flow of our workflow!

Let's create a new repository and setup our protected branches and our codeowners file.

Let's create a workflow that will run when someone opens a pull request to merge into the develop branch.

Let's now create the workflow that will run whenever a pull request is merged into develop.

Every-time we run our workflow, we install out npm dependencies. These dependencies might be very large and it would be ideal to cache them in order to reuse our cache every-time we run the workflow.

Let's see how can we upload folders that our workflow generates as artifacts

Let's use the semantic-release library in order to implement our semantic versioning releases.

Now that we have semantic-release configured, let's try and run it in our workflow.

Now that we are generating automatic releases, let's also see how can we upload assets to our releases.

In our current workflow; when we push to master, the code will be deployed to our assumed staging URL. However, as we planned we need master to be deployed to production.

Let's use a service called codecov to upload our test coverage reports online.

In this lecture we will do an extra step that is not necessary for our workflow; however it can be very helpful. We will install some packages that can help us create and validate conventional commits commit message.

Let's as planned create the part in our workflow where we send a slack message when a release is published.

Let's see how can we run a step that opens an automated issue when the workflow fails.

Let's start by creating a simple JavaScript action that will just log a simple string.

In order for our JavaScript code to run without problems, we will have to bundle it into 1 file. Let's use a package called ncc to do this.

Using the core package we can do more than just setting outputs and getting inputs. We can also log debug messages, set environment variables, set secrets and more.

Let's now create a more useful action. For this one we will call the GitHub Api to open a new issue.

Now that we know all about JavaScript Actions, let's now create a docker action.

Let's now move our PHP script that we've written into a docker action.

We have a couple of ways in order to get inputs and github context in docker actions. Let's discover these ways in this lecture.

Let's finally publish our action into the marketplace.