sittch / write-docker-actions Goto Github PK
View Code? Open in Web Editor NEWHome Page: https://lab.github.com/githubtraining/github-actions:-write-docker-container-actions
License: MIT License
Home Page: https://lab.github.com/githubtraining/github-actions:-write-docker-container-actions
License: MIT License
Hello @Sittch, I'm so excited to teach you how to create your own custom Docker based action ๐
GitHub Actions are enabled on your repository by default, but we still have to tell our repository to use them. We do this by creating a workflow file in our repository.
A workflow file can be thought of as the recipe for automating a task. They house the start-to-finish instructions, in the form of jobs
and steps
, for what should happen based on specific triggers.
Your repository can contain multiple workflow files that carry out a wide variety of tasks. It is important to consider this when deciding on a name for your workflow. The name you choose should reflect the tasks being performed.
In our case, we will use this one workflow file for many things, which leads us to break this convention for teaching purposes.
๐ Read more about workflows
@Sittch we are going to start with the typical "Hello World" example and build something more complex after, but first let's decide if a Docker based action is the right action for us!
That's a super great question to ask. Before we talk about the components that make up Docker based actions, we should understand the good and the bad of Docker based actions.
Advantages | Disadvantages |
---|---|
Docker actions package the source code that will be executed right alongside any dependencies that source code has. | Slower execution time because the image containing your source code and dependencies gets built with every workflow run. |
Docker containers package the environment with the GitHub Actions code. This creates a more consistent and reliable unit of work because the consumer of the action does not need to worry about the tools or dependencies. | Docker container actions can only execute in the GitHub-hosted Linux environment. |
Ideal for running in environments with very specific configurations and tools. | Debugging can be difficult with containers. |
Actions can be written in any language you choose. | More files to maintain when changes to the action occur. |
Let's begin by exploring the components of a Docker based action and discuss how they fit together!
The next action we write is going to reach out to an external API and fetch data for consumption. Although your action is bound to a step, which is bound to a workflow within your repository it is NOT bound to an isolated network. This means that we can leverage APIs from our favorite cloud providers, favorite pizza shops, social media or whatever API our developers need.
If you ask this question to anyone in the industry you'll likely get the obvious answer of "Application Programming Interface", which although true, doesn't exactly explain what one is or does.
Let's do a thought experiment to help understand the concept of an API.
I think most people are familiar with a car ๐ either through personal experience or some form of media. I also think it's safe to say that most people understand the concepts behind driving a car. By examining how we drive a car we can understand how APIs work in a fun way.
Car Components
When driving a car there are a few components of the car that the driver interacts with directly. This wont be an all inclusive list, and each car varies to some degree, but so does each API. We will use the following components for our example:
As the driver of the car when we push one of the pedals, move the gear shift position or turn the steering wheel the car responds. Most of us don't know exactly how it responds though. We actually don't even think about the system that is in place to amplify the force applied to the steering wheel when we make a turn. We probably don't know if our vehicle has a hydraulic, electro-hydraulic or fully electric power steering system. What we do know is that when we turn the steering wheel the car responds by turning.
The steering wheel has become an API between the driver and the inner workings of the power steering system and the systems that it communicates with. You see, steering the car eventually turns the wheels of the car and that takes place through further interconnected systems that are abstracted away from the driver.
The same is true with the gear shift. When we move our car into a different state using the gear shift a series of events take place throughout the car to reflect that change. This could be going from a stopped position to driving forward. It could be going from forward motion to reverse. It could even be cycling through gears in the case of a manual transmission. Ultimately, by moving the gear shift we tell the car what to do when we apply the gas pedal.
Very simply the gas pedal changes the speed of our car. We press it down to go faster or lift pressure off of it to stop going faster. What about if we want to fully stop? The gas pedal, gear shift and steering wheel wont exactly help us do that, hence the need for a brake pedal.
All of these systems, these APIs designed to help a human drive a car, are constantly communicating with one another to produce a moving vehicle. The driver didn't have to concern themselves with the implementation, platform, architecture, complex queries or manufacturer differences of each car. No, the driver just needed to concern themselves with how a steering wheel, gas pedal, brake pedal and gear shift work.
What gets even better is that the API for a car is pretty standard from one car to the next. Once you learn one steering wheel you pretty much know them all!
Standard API Types:
This concept is also prevalent in real world APIs. There are many standard types of APIs and if you understand each standard then you ultimately understand how to use that API to your advantage.
The most common types of API at the time this course was written are:
Going into detail about each standard is beyond the scope of this course, however it's important to understand that there are many standards out there. Although there are many standards the purpose of each API is to give your program or service the ability to communicate easily with another program or service without the need to know the implementation details.
APIs also give you, the developer, the ability to give others access to specific functionality or resources within your own program or service.
๐บ Watch this 30 second video on APIs
We are now going to write an action that reaches out to a service through its REST API to get us a random cat fact. We will then display that fact on the Actions tab.
For our purposes the API we use will not require authentication, however that is a limitation of the course content and not the GitHub Actions platform. If you need to store secrets, like API keys, for your workflow to use you will need to configure secrets as inputs.
What are we waiting for, let's get started ๐
Two actions down, one more to go! Before we move on with building our final action let's take a second to do a quick recap since this lesson has thrown a lot of information at you.
The workflow
We started out by explaining what a workflow is and how it pertains to the GitHub Actions platform. You learned about how a defined event sets your workflow orchestra in motion.
You learned about runners, jobs, steps and have dabbled in the syntax of a workflow file at every step in this course. I don't want to spoil too much here, but you'll be doing it again in this one as well ๐.
Action metadata
You learned that every action is accompanied by an action.yml
file which contains a series of metadata for how the action behaves. This file defines all of an actions inputs, outputs, runtime environment, name, description and even branding.
Hello action
Your first Docker action took the traditional path of a "Hello World" introduction. You ended up expanding that action to accept inputs
to help make it a little more dynamic. Ultimately, the key takeaway was to understand that you can pass input that is defined in the workflow to an action as long as the action's metadata supports it.
When consuming or creating actions it is incredibly helpful to take care to understand that actions metadata file.
Cat fact action
You second Docker action demonstrated that your workflow environment is capable of communicating outside of it's own network. We reached out to an external API and used that information to set outputs
for another action to consume. As with inputs
your actions metadata must support the ability to set outputs
if you want to use this option.
What next?
Your third, and final, Docker action of this course is going to do quite a bit to tie everything together. Let's take a look at what we will build:
outputs
of your cat action and use them to help create issues in your repository.We need to make some edits to the my-workflow.yml
file to get it configured to use this final action.
my-workflow.yml
Edit your .github/workflows/my-workflow.yml
file to contain the following contents:
name: Docker Actions
on:
pull_request:
types: [labeled]
jobs:
action:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v1
- name: hello-action
uses: ./.github/actions/hello-world
- name: meow
uses: ./.github/actions/cat-facts
id: cat
- name: create-issue
uses: ./.github/actions/issue-maker
with:
repoToken: ${{secrets.GITHUB_TOKEN}}
catFact: ${{steps.cat.outputs.fact}}
issueTitle: "a cat fact for you"
Commit the changes to a new branch and name it action-three
.
Create a pull request named Use outputs
I'll respond when you create a new pull request.
You did it ๐
You have successfully written three different Docker actions.
Let's take a quick look at all the things you learned in this course:
Workflows
Along the way you learned a little about workflows and how to configure them. You managed to accomplish all these things:
That's quite a bit for a course that doesn't cover workflows!
Action metadata
action.yml
fileinputs:
and outputs:
allowed you to create more dynamic and reusable metadata files for your actions.Docker actions
Wow, what a series of tasks! You started with the traditional hello world
in the console, which was then expanded to use the input:
parameters specified in the actions metadata. Through the use of that metadata you were able to be flexible with your greeting.
You learned how GitHub Actions behave when consuming external APIs and you also used the response from an external API as an output:
parameter for a later step in the workflow.
Lastly you saw how to use actions to interact with a repository by creating an issue containing a joke.
You used multiple languages to write your action source code.
At this point you are armed with everything you need to know to go out there and begin creating your own custom Docker actions.
I also want to take a few minutes to point you to the information you need to place your own custom actions on the GitHub Marketplace for others to use.
A declarative, efficient, and flexible JavaScript library for building user interfaces.
๐ Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
An Open Source Machine Learning Framework for Everyone
The Web framework for perfectionists with deadlines.
A PHP framework for web artisans
Bring data to life with SVG, Canvas and HTML. ๐๐๐
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
Some thing interesting about web. New door for the world.
A server is a program made to process requests and deliver data to clients.
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Some thing interesting about visualization, use data art
Some thing interesting about game, make everyone happy.
We are working to build community through open source technology. NB: members must have two-factor auth.
Open source projects and samples from Microsoft.
Google โค๏ธ Open Source for everyone.
Alibaba Open Source for everyone
Data-Driven Documents codes.
China tencent open source team.