GitHub Actions Exercise: Your First Workflow

👋 Hey there! Welcome to your Skills exercise! This guide will walk you through creating and running your first GitHub Actions workflow. GitHub Actions are a powerful tool for automating tasks within your software development lifecycle, right in your GitHub repository.

---

✨ This is an interactive, hands-on GitHub Skills exercise! You'll learn by doing, and we'll be here to guide you every step of the way.

As you complete each step, I’ll leave updates in the comments:

• ✅ Check your work and guide you forward
• 💡 Share helpful tips and resources
• 🚀 Celebrate your progress and completion

Let’s get started - good luck and have fun!

_{— Mona}

_{If you encounter any issues along the way please report them here.}

Why Use GitHub Actions?

GitHub Actions are a game-changer for developers. They allow you to automate nearly any aspect of your development workflow, from building and testing your code to deploying it to production. Think of it as your personal robotic assistant for your repository, diligently performing tasks so you can focus on writing great code.

• Automation is Key: In today's fast-paced software development world, automation is no longer a luxury, it's a necessity. GitHub Actions enable you to automate repetitive tasks, saving you time and reducing the risk of errors.
• Seamless Integration: Because GitHub Actions are built directly into GitHub, they seamlessly integrate with your existing workflow. There's no need to juggle multiple tools or services; everything you need is right at your fingertips.
• Customizable Workflows: GitHub Actions are incredibly flexible. You can create workflows tailored to your specific needs, whether you're building a simple website or a complex application.
• Community-Powered: The GitHub Actions ecosystem is thriving, with a vast library of pre-built actions created by the community. This means you can often find an action that does exactly what you need, without having to write it from scratch.

Understanding the Basics of GitHub Actions

Before we dive into the exercise, let's cover some fundamental concepts of GitHub Actions. Think of these as the building blocks for your automated workflows.

• Workflows: A workflow is a configurable automated process that you can set up in your repository. Workflows are defined by YAML files in your repository's .github/workflows directory. This file outlines the steps your action will take.
• Events: Events are triggers that initiate a workflow. These can be anything from a code push or pull request to a scheduled time or a manual trigger. Events are like the starting pistol for your automation race.
• Jobs: A job is a set of steps in a workflow that executes on the same runner. Think of it as a mini-workflow within your larger workflow. Jobs can run sequentially or in parallel, depending on your needs.
• Steps: A step is an individual task that can run commands, execute setup tasks, or run an action. Steps are the individual actions your runner takes, like building code, running tests, or deploying to a server.
• Actions: Actions are reusable units of code that automate tasks. You can use actions created by the GitHub community or create your own custom actions. Actions are the building blocks of your steps, handling specific tasks efficiently.
• Runners: A runner is a server that runs your workflows. GitHub provides runners, or you can host your own. Runners are the workhorses of your workflow, executing the steps you define.

Setting Up Your First Workflow

Now, let's get practical and create your first GitHub Actions workflow. This exercise is designed to be hands-on, so you'll be actively building and testing your workflow.

1. Create a Repository: If you don't already have one, start by creating a new repository on GitHub. This will be the home for your workflow.
2. Navigate to the .github/workflows Directory: Inside your repository, create a directory named .github if it doesn't already exist. Within .github, create another directory named workflows. This is where your workflow files will live.
3. Create a Workflow File: Inside the workflows directory, create a new file with a .yml extension (e.g., main.yml). This file will define your workflow.

Writing Your Workflow YAML

YAML (YAML Ain't Markup Language) is a human-readable data serialization format commonly used for configuration files. It's essential for defining your GitHub Actions workflows.

Let's break down a basic workflow YAML structure:

name: My First Workflow

on:
  push:
    branches:
      - main

jobs:
  my_job:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v3
      - name: Run a simple command
        run: echo "Hello, GitHub Actions!"

• name: This is the name of your workflow, which will be displayed in the GitHub Actions UI. Make it descriptive and easy to understand.
• on: This section defines the events that trigger the workflow. In this example, the workflow is triggered when code is pushed to the main branch.
• jobs: This section defines the jobs that make up the workflow. Each job runs in its own environment.
• runs-on: This specifies the type of runner the job will use. ubuntu-latest is a common choice for Linux-based workflows.
• steps: This section defines the individual steps within the job. Each step can run a command or use an action.
• uses: This specifies an action to use. actions/checkout@v3 is a standard action that checks out your repository's code.
• run: This runs a command in the runner's shell. In this example, it echoes a simple message.

Hands-On: Building a Simple Workflow

Now, let's put this knowledge into practice. We'll create a simple workflow that prints "Hello, GitHub Actions!" when code is pushed to the main branch.

1. Open your main.yml file in the .github/workflows directory.

2. Paste the following code into the file:

   name: Hello GitHub Actions
   
   on:
     push:
       branches:
         - main
   
   jobs:
     say_hello:
       runs-on: ubuntu-latest
       steps:
         - name: Print greeting
           run: echo "Hello, GitHub Actions!"
   

3. Commit and push the changes to your main branch.

Monitoring Your Workflow

Once you've pushed your changes, GitHub Actions will automatically trigger your workflow. You can monitor its progress in the "Actions" tab of your repository.

1. Navigate to the "Actions" tab in your repository.
2. You should see your workflow listed. Click on it to view the details.
3. You can see the status of each job and step. If everything went well, you should see a green checkmark next to each step.
4. Click on the "Print greeting" step to view the output. You should see the "Hello, GitHub Actions!" message.

Congratulations! You've Run Your First Workflow

🎉 You've successfully created and run your first GitHub Actions workflow! This is a significant step towards automating your development processes. By automating tasks, you can save time, reduce errors, and focus on what you do best: writing code.

Expanding Your GitHub Actions Knowledge

This exercise is just the beginning. GitHub Actions offer a wide range of possibilities, from continuous integration and continuous deployment (CI/CD) to automating code reviews and much more. Let's explore some next steps you can take to expand your knowledge:

• Explore the GitHub Actions Documentation: GitHub's official documentation is a treasure trove of information. It covers everything from the basics to advanced topics. You can find it here.
• Browse the GitHub Marketplace: The GitHub Marketplace is filled with actions created by the community. You can find actions for virtually any task you can imagine. Explore the marketplace to discover actions that can help you automate your workflows.
• Experiment with Different Triggers: Try triggering your workflow on different events, such as pull requests, scheduled times, or manual triggers. This will give you a better understanding of the flexibility of GitHub Actions.
• Create Your Own Actions: Once you're comfortable using existing actions, try creating your own. This is a great way to learn more about how actions work and how to automate complex tasks.

Conclusion: The Power of Automation

GitHub Actions are a powerful tool for automating your software development workflow. By automating tasks, you can save time, reduce errors, and focus on what you do best: writing code. This exercise has provided you with a solid foundation for using GitHub Actions. Now, it's time to explore, experiment, and unlock the full potential of automation in your development process.

Remember to check out the official GitHub Actions Documentation for more in-depth information and advanced features.