#1 Git Actions - Micro Tutorials

Getting Started with Git Actions: Automate Your Workflow!

Git Actions are a powerful way to automate tasks within your software development lifecycle directly from your GitHub repository. From continuous integration (CI) and continuous delivery (CD) to running tests, building documentation, or deploying your application, Git Actions can streamline almost any workflow.

This tutorial will guide you through the basics of setting up and using Git Actions in 5 easy-to-understand modules. Let's dive in!

---

Module 1: Understanding the Basics - What are Git Actions?

At its core, a Git Action is an event-driven automation framework. This means that when a specific event occurs in your repository (like a push to a branch, a pull request being opened, or even a scheduled time), a predefined workflow will automatically execute.

Key Concepts:

• Workflows: These are configurable automated processes defined by a YAML file (.yml) in your repository's .github/workflows directory. They consist of one or more jobs.
• Events: Specific activities that trigger a workflow run. Examples include push, pull_request, issue_comment, schedule, and workflow_dispatch (manual trigger).
• Jobs: A set of steps that execute on the same runner. Jobs run in parallel by default, but you can configure them to run sequentially.
• Steps: An individual task within a job. A step can be a script that you write or an action that you use.
• Actions: Reusable units of work that you can combine into steps. These can be custom actions you write, or actions shared by the GitHub community.
• Runners: Virtual machines hosted by GitHub that execute your workflows. You can also host your own self-hosted runners.

Visualizing the Workflow:

Imagine a typical development cycle: you write code, commit it, push it to GitHub, and then you want to ensure it builds correctly and passes tests. Git Actions can automate this entire sequence.

YAML Workflow Example

name: CI/CD Pipeline

on: [push, pull_request]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Install dependencies
        run: npm install
      - name: Build project
        run: npm run build
      - name: Run tests
        run: npm test
            

---

Module 2: Your First Workflow - "Hello World"

Let's create a simple workflow that prints "Hello, Git Actions!" to the console every time there's a push to your repository.

Steps:

1. Create the Workflow Directory: In your repository, create a directory named .github/workflows.
2. Create the Workflow File: Inside .github/workflows, create a new file named hello-world.yml.
3. Add Workflow Content: Paste the following YAML into hello-world.yml:

hello-world.yml

name: Hello World Workflow

on: [push] # This workflow runs on every push to any branch

jobs:
  greet:
    runs-on: ubuntu-latest # Specify the operating system for the runner
    steps:
      - name: Say Hello
        run: echo "Hello, Git Actions!" # Execute a simple shell command
            

4. Commit and Push: Commit this file to your repository and push it to GitHub.

Expected Outcome:

Once you push the hello-world.yml file, navigate to the "Actions" tab in your GitHub repository. You should see a new workflow run triggered by your push. Clicking on it will show you the "greet" job and the "Say Hello" step, which will have "Hello, Git Actions!" in its logs.

---

Module 3: Using Pre-built Actions and Checkout

While you can write your own shell commands, a core strength of Git Actions is the ability to use pre-built actions from the GitHub Marketplace. One of the most common actions is actions/checkout, which checks out your repository's code so your workflow can access it.

Let's modify our "Hello World" to first check out the repository.

Steps:

1. Edit hello-world.yml: Open hello-world.yml and modify it as follows:

Modified hello-world.yml

name: Hello World Workflow with Checkout

on: [push]

jobs:
  greet:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3 # Use the checkout action to get your code
      - name: Say Hello
        run: echo "Hello, Git Actions from your repo!"
            

2. Commit and Push: Commit and push this change to your repository.

Explanation of uses: actions/checkout@v3:

• uses:: This keyword indicates that you're using a pre-built action.
• actions/checkout@v3: This specifies the action (checkout) from the actions organization and the version (v3). Using a specific version is crucial for workflow stability.

Why Checkout?

Many workflows, especially CI/CD pipelines, need access to your repository's files to compile code, run tests, or deploy applications. The checkout action provides this essential first step.

---

Module 4: Working with Multiple Jobs and Environments

Workflows can have multiple jobs, and jobs can be configured to run in different environments or with different settings. Let's create a workflow with two jobs: one to build the project and another to run tests, ensuring they run sequentially.

Steps:

1. Create build-and-test.yml: In .github/workflows, create build-and-test.yml with the following content:

build-and-test.yml

name: Build and Test Workflow

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Install dependencies and build
        run: |
              echo "Simulating build process..."
              # In a real scenario, this would be `npm install` and `npm run build`
      - name: Archive production artifacts
        uses: actions/upload-artifact@v3
        with:
          name: my-app-build
          path: . # Assuming your build artifacts are in the root for this example

  test:
    runs-on: ubuntu-latest
    needs: build # This job will only run after the 'build' job completes successfully
    steps:
      - uses: actions/checkout@v3
      - name: Download build artifacts
        uses: actions/download-artifact@v3
        with:
          name: my-app-build
      - name: Run tests
        run: |
              echo "Simulating test process..."
              # In a real scenario, this would be `npm test`
            

2. Commit and Push: Commit and push this file.

Key Features Introduced:

• jobs: Contains build and test jobs.
• needs: build: The test job will only start after the build job has successfully completed. This creates a dependency.
• actions/upload-artifact@v3 and actions/download-artifact@v3: These actions allow you to share files (artifacts) between different jobs within the same workflow run, which is crucial for multi-stage pipelines (e.g., build in one job, test that build in another, then deploy the same build).

Expected Outcome:

You'll see two jobs running in sequence under the "Actions" tab. The test job will wait for the build job to finish before starting. You'll also see "Artifacts" listed for the workflow run, which you can download.

---

Module 5: Event Triggers and Context

Git Actions can be triggered by a multitude of events. You can also access information about the event and the repository using the github context.

Common Event Triggers:

• on: push: Runs when a push is made to any branch (or specific branches: on: push: branches: [main, develop]).
• on: pull_request: Runs when a pull request is opened, synchronized, or reopened.
• on: schedule: Runs at specified UTC times using cron syntax (on: schedule: ['0 0 * * *'] for daily at midnight).
• on: workflow_dispatch: Allows you to manually trigger a workflow from the GitHub UI or API.
• on: issue_comment: Triggers when a comment is made on an issue.

Using Context Information:

The github context provides information about the event that triggered the workflow, the repository, and the runner. You can access this information using expression syntax ${{ github.<property> }}.

Let's create a workflow that uses workflow_dispatch and prints information about the trigger.

Steps:

1. Create manual-trigger-info.yml: In .github/workflows, create manual-trigger-info.yml:

manual-trigger-info.yml

name: Manual Trigger Info

on:
  workflow_dispatch: # Allows manual triggering from the Actions tab

jobs:
  display-info:
    runs-on: ubuntu-latest
    steps:
      - name: Print Trigger Info
        run: |
              echo "Workflow triggered by: ${{ github.event_name }}"
              echo "Ref: ${{ github.ref }}"
              echo "Actor: ${{ github.actor }}"
              echo "Repository: ${{ github.repository }}"
              echo "Commit SHA: ${{ github.sha }}"
            

2. Commit and Push: Commit and push this file.

Expected Outcome:

Go to the "Actions" tab. You'll now see "Run workflow" button next to "Manual Trigger Info" workflow. Click it, select a branch (e.g., main), and run the workflow. The output will show details about the manual trigger.

---

You've now completed a foundational journey into Git Actions! You've learned how to create basic workflows, use pre-built actions, manage multiple jobs, share artifacts, and respond to different event triggers. This is just the beginning of what you can automate with Git Actions. Explore the GitHub Marketplace for more actions and start automating your development workflows today!

Git Repository👈👈👈👈Click