Skip to content

Git and GitHub: Empowering Collaborative Software Development

In the fast-paced world of software development, effective version control and collaboration are paramount. Enter Git and GitHub, the dynamic duo that has revolutionized how teams manage, track, and collaborate on code. In this blog, we'll explore the fundamentals of Git, the power of GitHub, and how they work together to empower collaborative software development.

Understanding Git

Git, created by Linus Torvalds in 2005, is a distributed version control system. It allows developers to track changes in their codebase, collaborate seamlessly, and easily manage different versions of their software.

Key Concepts

Repository (Repo): A Git repository is like a project's folder, containing all the files, history, and configurations related to the project. It can exist locally on your machine or remotely on a server.

Commit : A commit is a snapshot of your code at a specific point in time. It represents a set of changes that you want to save.

Branch: Branches are parallel lines of development. They allow you to work on different features or bug fixes independently.

Merge: Merging combines the changes from one branch into another. It's often used to integrate completed features or fixes back into the main codebase.

Pull Request (PR): A pull request is a request to merge changes from one branch into another. It's a common practice for code review and collaboration in open source and team projects.

Basic Git Workflow

Here's a simplified Git workflow:

  1. Initialize a Repository: Start a Git repository in your project folder with git init.

  2. Stage Changes: Use git add to stage changes you want to commit.

  3. Commit Changes: Commit your staged changes with git commit -m "Your commit message".

  4. Create Branches: Create branches with git branch branch-name.

  5. Switch Branches: Move between branches with git checkout branch-name.

  6. Merge Branches: Merge branches with git merge branch-name.

  7. Collaborate: Push your changes to a remote repository and collaborate with others.

Git Command Reference

While we've covered the basics of Git here, you can dive deeper by referring to the Atlassian Git Cheatsheet. This resource provides a comprehensive list of Git commands and their usage.

Securely Adding SSH Keys to GitHub 🛡️

Adding SSH Keys to Your GitHub Account🌐

  • Description: GitHub allows SSH key authentication for secure repository access. Adding your public key to your GitHub account grants you secure access to repositories.

  • Steps:

  • Generate an SSH key pair using ssh-keygen if you haven't already.
  • Copy your public key to the clipboard: 
    cat ~/.ssh/id_rsa.pub | xclip -selection clipboard   # On Linux
  • Log in to your GitHub account.
  • Go to Settings > SSH and GPG keys.
  • Click New SSH key.
  • Paste your public key into the Key field and give it a meaningful title.

  • Click Add SSH key.

  • Use Case: Adding SSH keys to GitHub simplifies secure access to your repositories without the need for a password.

Continuous Integration and Continuous Deployment (CI/CD) with GitHub Actions 🚀

GitHub Actions is a powerful automation and CI/CD platform integrated with GitHub repositories. It allows you to build, test, and deploy your code directly from your GitHub repository.

Components of GitHub Actions:

  • Workflows 🔄
  • Jobs 🛠️
  • Runners 🏃
  • Actions 🤖
  • Artifacts 📦

Real-Time Use Case:

GitHub Actions is best suited for developers and teams using GitHub for version control. It seamlessly integrates with your repositories and is an excellent choice for projects hosted on GitHub.

Mostly Used For:

  • Continuous Integration (CI)
  • Continuous Deployment (CD)
  • Automated Testing
  • Workflow Automation

Understanding GitHub Actions Workflows

Workflows in GitHub Actions are defined YAML files that specify the automation process for your project. A workflow can include one or more jobs, each consisting of a series of steps and actions to execute.

GitHub Actions Runner Types

GitHub Actions allows you to use different types of runners to execute your workflows:

  • GitHub-hosted runners are provided by GitHub and offer a variety of pre-configured environments.
  • Self-hosted runners are runners you can set up and maintain in your own infrastructure, giving you more control over the execution environment.

Installation Process:

  1. Access your GitHub repository.
  2. Navigate to the "Actions" tab.
  3. Create a new workflow or choose from existing templates.
  4. Define your workflow steps, including build and deployment tasks.
  5. Save your workflow configuration in a YAML file.
  6. Trigger your workflow manually or automatically based on events like code pushes or pull requests.

Creating a Basic GitHub Actions Workflow 🚀

YAML Method:

name: CI/CD with GitHub Actions

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - name: Checkout Repository
      uses: actions/checkout@v2

    - name: Print Hello World
      run: echo 'Hello, World!'

To create a basic GitHub Actions workflow using YAML configuration:

  1. Access your GitHub repository.
  2. Navigate to the "Actions" tab.
  3. Click on "Set up a workflow yourself" to create a new YAML file.
  4. Copy and paste the provided YAML configuration.
  5. Save the file as .github/workflows/main.yml.
  6. Trigger your workflow manually or by pushing code changes.

This workflow will execute and print "Hello, World!" when triggered by a code push.

More Workflows

This GitHub Actions workflow is designed to automate the process of pushing changes to a GitHub repository's main branch

name: Push Changes to GitHub

# Define the trigger for this workflow: it runs when there are pushes to the specified branch (main).
on:
  push:
    branches:
      - main  # Replace with the branch you want to trigger this on

jobs:
  build:
    # Specify that this job runs on a self-hosted runner.
    runs-on: self-hosted

    steps:
    - uses: actions/checkout@v2
      with:
        # Disable persisting credentials to use a personal access token (PAC) instead of the GITHUB_TOKEN.
        persist-credentials: false

        # Set the fetch depth to 0 to ensure the full history is fetched, avoiding errors when pushing refs.
        fetch-depth: 0

    - name: Create local changes
      run: |
        # Execute the 'free -m' command and redirect the output to a file named 'memory.txt'.
        free -m > memory.txt

    - name: Commit files
      run: |
        # Add all changes to the Git staging area.
        git add .

        # Configure the user email and name for this local Git session.
        git config --local user.email "41898282+github-actions[bot]@users.noreply.github.com"
        git config --local user.name "github-actions[bot]"

        # Commit all changes with the message "Add changes [skip ci]".
        git commit -a -m "Add changes [skip ci]"

    - name: Push changes
      uses: ad-m/github-push-action@master
      with:
        # Provide the GitHub token (PAC) stored in GitHub secrets for authentication.
        github_token: ${{ secrets.PAC }}

        # Specify the target branch for pushing the changes (main).
        branch: main

Automated GitHub Website Deployment

This script automates the process of setting up a website by downloading and extracting files from a URL, adding them to a Git repository, committing the changes, and pushing them to a remote Git repository. It also includes package installation and cleanup steps in a Linux Ubuntu OS.

#!/bin/bash
# Website setup script

# Define variables for URLs, file names, and repository information.
URL=https://www.tooplate.com/zip-templates/2118_chilling_cafe.zip
FILE=2118_chilling_cafe
GIT_URL=git@github.com:username/username.github.io.git
GIT_REPO=username.github.io #use your github username 
PKG=apt
EMAIL=admin123@gmail.com
USER=admin

# Install necessary packages (e.g., git, wget, unzip) using the package manager specified in PKG.
sudo $PKG install git wget unzip -y

# Create a directory structure for Git and navigate to it.
mkdir -p ~/git
cd ~/git

# Clone the specified Git repository.
git clone $GIT_URL

# Remove the contents of the Git repository directory.
rm -rf $GIT_REPO/*

# Download a file from the specified URL and unzip it.
wget $URL
unzip $FILE.zip

# Copy the unzipped files to the Git repository directory.
cp -r $FILE/* $GIT_REPO/

# Navigate to the Git repository directory.
cd $GIT_REPO

# Configure Git user email and name globally.
git config --global user.email "$EMAIL"
git config --global user.name "$USER"

# Add all changes, commit with the current date, and push to the remote repository.
git add .
git commit -m "$(date)"
git push

# Remove the temporary git directory.
rm -rf ~/git