Learn How to Master Shell Scripting with GitHub API, Git Essentials, and AWS EC2 Deployment

Hey Dev Community! In this article, you'll explore how to integrate shell scripts with the GitHub API, understand the core concepts of Git and GitHub, get acquainted with essential Git commands, learn about effective branching strategies, and follow a step-by-step guide for deploying a website using AWS EC2.

Table of Contents

1. Integrating Shell Scripts with GitHub API


2. 
   Git and GitHub: Version Control and Collaboration Simplified
   
   
   
   
   • Before Git: The Evolution of Version Control Systems
   
   
   • Centralized vs Distributed Version Control
   
   
   • Git vs GitHub: Key Differences
   
   
   • Fork vs Clone: What’s the Difference?
   
   
   
   


3. Essential Git Commands Explained


4. Git Branching Strategy: Best Practices for Teams


5. Deploying a Website on AWS EC2: Step-by-Step Guide

1. Integrating Shell Scripts with GitHub API

Shell scripts can streamline interactions with GitHub via the GitHub API. The curl command is a handy tool for sending API requests directly from the terminal.

Steps to Integrate:

1. Create a Personal Access Token (PAT):
   
   To interact with GitHub securely, generate a PAT by navigating to GitHub’s settings.




2. Use curl to Access the GitHub API:
   
   For instance, to list all repositories in an organization, you will need to use a command similar to:
   
   

   curl -H "Authorization: token YOUR_TOKEN" https://api.github.com/orgs/YOUR_ORG/repos

Creating a GitHub Organization (Optional)

While managing repositories with a personal account is usually sufficient for individuals, creating an organization becomes useful if you:

• Work with larger teams.


• Need structured role assignments and permission control.


• Want centralized management of multiple repositories.

Creating an organization can streamline access and collaboration, though it’s entirely optional for smaller projects.

By combining shell scripting with the GitHub API, you can automate tasks like creating repositories, managing branches, and controlling access permissions efficiently.

2. Git and GitHub: Version Control and Collaboration Simplified

2.1 Before Git: The Evolution of Version Control Systems

Before Git became the standard for version control, industry solutions like CVS, SVN, and GT were used to manage source code. These older systems operated primarily as centralized solutions.

2.2 Centralized vs Distributed Version Control

• 
  Centralized Version Control: All project versions are stored on a central server, and developers check in and out (e.g., CVS, SVN).


• 
  Distributed Version Control: Developers work with a complete copy of the project’s history on their local machines, making it easier to collaborate without a central bottleneck (e.g., Git).

2.3 Git vs GitHub: Key Differences

2.4 Fork vs Clone: What’s the Difference?

In short, forking creates a new remote copy on your GitHub account, while cloning makes a local copy on your machine.

3. Essential Git Commands Explained

Here’s a breakdown of some key Git commands every developer should know:

• 
  git add: Stages changes for the next commit.


• 
  git commit: Saves the changes to the local repository.


• 
  git push: Sends the local commits to a remote repository.


• 
  git diff: Shows the differences between working directory and staging area.


• 
  git log: Displays a list of all previous commits.


• 
  git reset: Unstages files or moves the HEAD pointer to an earlier commit.


• 
  git status: Shows the current status of your working directory.


• 
  git clone: Creates a local copy of a remote repository.


• 
  git remote: Manages connections to remote repositories.


• 
  git branch: Lists, creates, or deletes branches.


• 
  git checkout: Switches between branches or restores files.


• 
  git merge: Combines two branches, preserving their commit histories.


• 
  git rebase: Reapplies commits on top of another base commit for a cleaner history.


• 
  git cherry-pick: Applies specific commits from one branch onto another.

Differences Between Git Merge, Git Rebase, and Git Cherry-pick

• 
  Git Merge: Combines branches while retaining all commits from both.


• 
  Git Rebase: Moves or re-applies commits on top of another base commit, creating a cleaner, linear history.


• 
  Git Cherry-pick: Lets you apply specific commits from one branch to another, without merging the entire branch.

For a cleaner project history, Git Rebase is often considered the best practice.

4. Git Branching Strategy: Best Practices for Teams

A clear branching strategy is essential for smooth collaboration. One popular approach is Gitflow, which uses:

• 
  master/main: The stable production branch.


• 
  develop: The branch for integrating new features.


• 
  feature branches: Dedicated branches for individual features.


• 
  hotfix branches: Quick fixes for production bugs.

Following a branching strategy helps teams stay organized and reduces conflicts when merging code.

5. Deploying a Website on AWS EC2: Step-by-Step Guide

Deploying a website on AWS EC2 involves a few essential steps:

1. 
   Create an IAM User: Set up an IAM user with the necessary permissions to manage EC2 instances.


2. 
   Launch an EC2 Instance: Choose the appropriate Amazon Machine Image (AMI) and instance type to create a virtual machine.


3. 
   Access the EC2 Instance: Use SSH to connect to your EC2 instance with the key pair generated during the setup.


4. 
   Modify Security Groups: Update your EC2 instance’s security group to allow incoming traffic. For example, if your application runs on port 3000, configure the security group to allow TCP access on that port. Use 0.0.0.0/0 as the source IP for public access.

Once everything is configured, your website will be accessible via the public IP address of your EC2 instance.

This article covers a range of essential topics, from automating GitHub with shell scripts to deploying a website using AWS EC2. By following these steps, you’ll build practical knowledge of version control, automation, and cloud deployment.

Conclusion

Getting hands-on with AWS, Linux, and shell scripting has provided valuable insights into managing and automating infrastructure. These tools and commands form a solid foundation for anyone in DevOps.

Let’s Connect! 🔗 For more updates and insights:

• Connect with me on LinkedIn!


• Follow me on Twitter!

#DevOps #AWS #Linux #ShellScripting #TechBlog

Happy learning! 😊