Automate Your GitHub Setup: Managing Your Account with Infrastructure as Code

If you’re like me and have been coding for a while, this article is for you. Work can sometimes become repetitive, with tasks performed repeatedly. Having spent nearly a decade in software engineering, I’ve explored various roles?—?from Hybrid App Development and Frontend to Backend Development, and more recently, DevOps, SRE, and Platform Engineering. In web development, I’ve collaborated with everyone from small startups to large corporations.

The years have been both rewarding and challenging, constantly shifting from one tech stack to another. With the ever-growing tech space, you might sometimes stop and wonder, “What do I even know about web development?” (Yes, lol!). Therefore, I’ve started a journey to master the craft by diving deep into each field of technology?—?like Alice going down the rabbit hole.

On this journey, I plan to document extensively?—?because what developer doesn’t love to document their craft? I’ve also become a fan of open-sourcing, so I’ll be building everything in the open, writing articles for those interested in learning. I’ll share everything I know, and together, we’ll explore the wonders of the web. Be warned, it’s going to be a lot.

What better way to start this journey than with Git? In this article, we’ll explore how to maintain your GitHub projects with Infrastructure as Code (IaC). Fancy, right? Not only will your account stay organized, but you’ll also learn to use a crucial tool in the world of DevOps and cloud computing: Terraform. With Terraform, you can manage and maintain your cloud infrastructure?—?from GitHub to AWS?—?by writing declarative code blocks for the resources you want to create.

Prerequisites

Before we dive in, a little disclaimer: this is not an endorsement of any specific tools nor a statement of industry standards. These are simply my personal recommendations for managing a GitHub account effectively. Ensure you have the following tools installed:

• Homebrew: A package manager for macOS (or Linux) that simplifies the installation of software. If you’re using a different operating system, find the equivalent package manager for your system. Install Homebrew.
• Terraform: An open-source tool that lets you define and provision infrastructure through a high-level configuration language. We will use Terraform to automate the management of our GitHub account. Install Terraform.
• GitHub CLI: This command-line tool lets you manage your GitHub repositories, issues, and pull requests. It’s essential for integrating GitHub operations with our Terraform configurations. Install GitHub CLI.
• GitHub Account: To manage your GitHub account using IaC, you obviously need to have one. If you do not have a GitHub account yet, create one now.
• Git-Crypt: Useful for encrypting data within a Git repository. This is especially useful for securing sensitive configuration files managed through your IaC scripts. Install Git-Crypt. We’ll use this to secure our Terraform state and variables because I’m economical and prefer not to pay for other options.

Additionally, you might find the following handy:

• VS Code: As a warning, this is highly opinionated, but choose a code editor that supports Git and Terraform, such as Visual Studio Code. Notepad can work, but VS Code will assist you in managing your configuration files more effectively.
• Personal Access Token for GitHub: Generate a GitHub personal access token with the necessary permissions to manage repositories, actions, and workflows via the GitHub CLI and Terraform. If in doubt, select all permissions.
• Basic Understanding of Git: Familiarity with basic Git commands is crucial. If you need a refresher, consider a quick tutorial on Git fundamentals.

Setting up the GitHub Manager Repository

We’ll kick things off by creating a private GitHub repository. Following that, we’ll set up a Terraform project with local state management, write some tests, and finally, create some repositories. This process will help you automate your GitHub account management effectively using Infrastructure as Code.

Creating the GitHub Repository

To begin, navigate to the GitHub interface and create a new repository:

• Owner: Select your username as the owner from the dropdown menu.
• Repository Name: Enter github-manager as the repository name or whatever you prefer. This name should be descriptive and memorable.
• Description: Provide a meaningful description for your repository, such as “Repository for managing GitHub with Terraform.”
• Privacy Settings: Choose Private to keep your repository away from public eye.
• Initialize the Repository: Check the Add a README file box. This file will serve as the initial documentation and introduction to your repository. Select the Terraform?.gitignore template to automatically ignore unnecessary files in Terraform projects. Leave the license option as None unless you decide to add one later.
• Create the Repository: Click on the Create repository button. Your repository should be created momentarily.

Setting Up Your Local Development Environment

To get started with your local development, first ensure that you have the GitHub CLI installed and authenticated on your machine. This tool allows you to interact with your GitHub account directly from your command line. Follow these steps to clone the newly created repository:

• Open your Terminal or Command Prompt.
• Authenticate GitHub CLI: Before cloning, make sure you’ve set up and authenticated your GitHub CLI. If you haven’t already done so, you can authenticate by running:

gh auth login        

• Follow the prompts to complete the authentication.
• Clone the Repository: Use the GitHub CLI to clone the repository to your local machine:

gh repo clone username/github-manager        

• Replace username with your actual GitHub username.

This will download the github-manager repository to your local environment, allowing you to begin working on it directly.

Setting Up Your Terraform Project

Now, let’s begin setting up our Terraform project by creating the necessary folders and files. This structure will help organize our project efficiently and ensure that our Terraform code is easy to maintain and scale. Here’s how to set up the directory structure:

.
├── CODEOWNERS
├── Makefile
├── README.md
├── examples
│   ├── complete
│   │   └── main.tf
│   └── simple
│       └── main.tf
├── main.tf
├── modules
│   ├── branch
│   │   ├── README.md
│   │   ├── main.tf
│   │   ├── outputs.tf
│   │   ├── terraform.tf
│   │   └── variables.tf
│   └── repository
│       ├── README.md
│       ├── main.tf
│       ├── outputs.tf
│       ├── terraform.tf
│       └── variables.tf
├── outputs.tf
├── scripts
│   ├── gen-docs.sh
│   ├── import.sh
│   └── test.sh
├── terraform.tf
├── terraform.tfvars
├── tests
│   ├── github-manager.tftest.hcl
│   └── setup
│       └── main.tf
└── variables.tf        

Key Components:

• CODEOWNERS: Specifies the users who are responsible for the code in the repository.
• Makefile: Contains scripts to automate common tasks.
• README.md: Provides an overview of the project, setup instructions, and other essential information.
• Modules: Contains reusable pieces of Terraform code.
• Scripts:? gen-docs.sh: Generates documentation for the project. import.sh: Imports existing infrastructure into Terraform. test.sh: Runs Terraform linting, validation and project tests.
• Tests: Contains Terraform configuration files used for testing the configurations.

Each file and directory has a specific role in managing the Terraform configurations effectively. For instance, main.tf in the root directory will serve as the entry point for Terraform commands, while the modules directory will contain reusable pieces of Terraform code for creating GitHub branches and repositories.

Ensure you have a clear understanding of each component’s purpose as you proceed with setting up your Terraform project. This organization not only aids in development but also in future project maintenance. To help you further, I have graciously provided an example repository that you can refer to at https://github.com/hibeekaey/example-github-manager.

Unpacking the github-manager: What You Need to?Know

Now that we have set up the folders and files, it’s time to dive deep into some important components, including the Makefile, the Terraform code, and some tests.

Main Module Components

The core of our Terraform setup includes several critical files:

• main.tf: Contains the primary configuration where resources are defined.

• variables.tf: Defines variables used throughout the Terraform configurations.

• terraform.tf: Sets up the Terraform settings and backend.

• terraform.tfvars: Specifies values for the variables we’ve defined.

Using the Makefile

The Makefile simplifies running common commands. Here’s a look at the essential commands:

• Initialize your Terraform project:

make        

• Plan your Terraform project:

make plan        

• Apply your changes:

make apply        

Executing these commands will generate a terraform.tfstate file and create your repository and branch resources on GitHub. Note that the state file can contain sensitive information and should not be pushed to Git.

Securing Your Configuration

To secure sensitive files like terraform.tfstate and terraform.tfvars, use git-crypt:

• Initialize git-crypt: Refer to the official documentation for instructions on how to initialize git-crypt, and how to create and safely store the GPG key. I do not have specific recommendations for storage solutions. This integration is crucial for maintaining the security of your sensitive files.
• Configure?.gitattributes: Specify which files to encrypt using the?.gitattributes file. This step ensures that before committing to Git and pushing to GitHub, your sensitive files are encrypted.

Testing Your Setup

To ensure your github-manager is functioning correctly, write tests in the tests folder. Create a file called github-manager.tftest.hcl:

• Test Content: This test attempts to create two GitHub repositories, one private and one public. After successful creation, it changes the visibility of each repository to test the robustness of your configurations.

• Run the Test:

make test        

Consider adding this test command to your git pre-commit hook. This ensures that before any commit and push to GitHub, the test runs to prevent undesired changes or behaviors in your setup.

As we conclude this guide on setting up your GitHub account with Infrastructure as Code, we not only lay the groundwork for more organized development practices but also step into the broader landscape of web development. This is just the beginning of a series where we will delve into cloud infrastructure, web design, microservice architecture, and AI/ML technologies. Each piece is designed to build upon the last, starting with the foundational practices we’ve established here.

Don’t forget to engage with this journey?—?follow and star the repositories, like and share on social media, applaud the posts if you find them on platforms like Medium, and reshare with your networks. Your support motivates further content and deeper exploration, so join me as we continue to explore the technological wonderland.