Mastering GitHub API Integration with Shell Scripting

This blog post provides a comprehensive guide on using shell scripting for GitHub API integration, focusing on listing repository collaborators. It covers the basics of APIs, the importance of automation in DevOps, and a step-by-step walkthrough of a shell script that retrieves user access information from GitHub repositories.

In the world of DevOps, automation is key to efficiency and productivity. This blog post is a take two of a previous video in the DevOps Zero to Hero series, focusing on a shell scripting project that integrates with the GitHub API. The goal is to help you understand how to automate the process of listing users who have access to a GitHub repository, a common task for DevOps engineers.

Why a Take Two?

The original video on this topic received significant attention, with over 37,000 views. While many viewers found it helpful, some expressed difficulties in following along. To ensure that no one is left behind, this updated video aims to provide clearer explanations and a complete code script available on GitHub.

Understanding the Basics

Before diving into the script, let's clarify some fundamental concepts:

What is an API?

An API, or Application Programming Interface, allows different software applications to communicate with each other. In this context, the GitHub API enables developers to interact programmatically with GitHub repositories, bypassing the need for a graphical user interface (GUI).

Why Use Shell Scripting?

Shell scripting is a powerful tool for automating tasks in a Unix/Linux environment. By writing scripts, DevOps engineers can streamline repetitive tasks, such as checking user access to repositories, which can save time and reduce errors.

The Use Case

As a DevOps engineer, you may need to monitor user access to various GitHub repositories. For instance, if an employee resigns, you need to quickly check if they have access to any repositories and revoke it if necessary. Instead of manually navigating through the GitHub UI, you can automate this process with a shell script.

Setting Up GitHub API Integration

To interact with the GitHub API, you need to set up a few things:

Create a Personal Access Token: This token will authenticate your API requests. You can generate it in your GitHub account settings under Developer settings > Personal access tokens.
Export Your Username and Token: In your terminal, you will need to export your GitHub username and the generated token as environment variables.

Writing the Shell Script

The shell script will perform the following tasks:

Formulate the API request to list collaborators for a specified repository.
Execute the request and parse the JSON response to extract relevant user information.
Print the list of users who have access to the repository.

Sample Script Walkthrough

Here’s a simplified version of the script:

#!/bin/bash


export GITHUB_USERNAME="your_username"
export GITHUB_TOKEN="your_token"


list_users() {
    local repo_owner=$1
    local repo_name=$2
    local api_url="https://api.github.com/repos/$repo_owner/$repo_name/collaborators"

    # Make the API call and filter the output using jq
    curl -s -u "$GITHUB_USERNAME:$GITHUB_TOKEN" "$api_url" | jq -r '.[] | select(.permissions.pull == true) | .login'
}


if [ $# -ne 2 ]; then
    echo "Usage: $0 <repo_owner> <repo_name>"
    exit 1
fi


list_users "$1" "$2"

Explanation of the Script

Shebang: The first line indicates that the script should be run in the Bash shell.
Environment Variables: The script uses the exported username and token for authentication.
Function Definition: The list_users function constructs the API URL and makes a request to GitHub to retrieve the list of collaborators.
JSON Parsing: The script uses jq, a command-line JSON processor, to filter and display only those users who have read access.
Argument Checking: The script checks if the correct number of arguments (repository owner and name) is provided before executing the main function.

Running the Script

To run the script, follow these steps:

Clone the repository containing the script to your local machine or an EC2 instance.
Ensure you have jq installed on your system.
Execute the script with the repository owner and name as arguments:
```
 ./list_users.sh <repo_owner> <repo_name>
```

Conclusion

This blog post has provided a comprehensive overview of how to integrate GitHub API with shell scripting to automate the process of listing repository collaborators. By leveraging APIs and shell scripts, DevOps engineers can enhance their productivity and streamline their workflows.

If you found this information helpful, consider subscribing to the channel for more insights and tutorials on DevOps practices. Happy scripting!

Day-8-devops