Mastering Git & GitHub for DevOps : Day 9 A Deep Dive into Version Control

Mastering Git & GitHub for DevOps : Day 9 A Deep Dive into Version Control

Table of contents

No heading

No headings in the article.

Introduction: In the dynamic world of DevOps, efficient collaboration, seamless code management, and version control are pivotal aspects of successful software development. Git and GitHub stand out as indispensable tools that empower DevOps engineers to streamline their workflows, collaborate effectively, and maintain version control. In this blog, we will embark on a deep dive into Git and GitHub, addressing fundamental concepts and practical tasks to enhance your proficiency.

Git vs Github: What's the Difference and How to Get Started with Both

  1. What is Git and why is it important? Git is a distributed version control system (VCS) designed to track changes in source code during software development. Its significance lies in providing a systematic approach to version control, allowing multiple developers to collaborate concurrently on a project. Git ensures code integrity, facilitates easy collaboration, and empowers teams to manage changes efficiently through branching and merging.

  2. Difference Between Main Branch and Master Branch: In Git, the terms "main" and "master" are often used interchangeably. Historically, "master" was the default branch name, but in recent times, many communities have shifted towards using "main" as a more inclusive and less culturally-loaded term. Both terms refer to the primary branch where the latest stable code resides.

  3. Git vs. GitHub: Git is the version control system, while GitHub is a web-based platform that provides hosting for Git repositories. Git is primarily a command-line tool, whereas GitHub offers a graphical user interface (GUI) and additional collaboration features. Git is the engine behind version control, and GitHub acts as a platform to host, share, and collaborate on Git repositories.

  4. Creating a New Repository on GitHub: a. Set your user name and email address using the following commands:

git config --global "Your Name"
git config --global ""

b. Create a new repository named "Devops" on GitHub. c. Connect your local repository to the GitHub repository using the following commands:

git remote add origin
  1. Difference Between Local & Remote Repository, Connecting Local to Remote:

    The Basics of Version Control System Git Explained by Designing A New Car

  • Local Repository: It is the copy of the repository stored on your local machine.

  • Remote Repository: It is the version of the repository stored on a server or an online platform. To connect the local repository to the remote, use the following command:

git push -u origin main

Certainly! Let's delve into the details of Task-1 and Task-2:

Task-1: Set Your User Name and Email Address

Configuring your user name and email address is a crucial step in Git, as it associates your commits with your identity. Follow these steps to set your user information:

  1. Open your terminal or Git Bash.

  2. Execute the following command to set your user name:

     git config --global "Your Name"

    Replace "Your Name" with your actual name.

  3. Execute the following command to set your email address:

     git config --global ""

    Replace "" with your actual email address.

Setting this information globally ensures that it is associated with all your commits across different repositories on your machine.

Certainly! Let's extend the explanation to include pulling changes from the GitHub repository in the context of Task-2:

Task-2: Create a Repository, Connect Local Repository, Add File, Push, and Pull Commits

Git & GitHub: A Deep Dive Guide for DevOps Engineers

This task involves creating a new repository on GitHub, connecting your local repository to it, creating a new file with content, pushing the changes to the GitHub repository, and finally, pulling any changes from the GitHub repository. Let's break it down:

  1. Create a Repository Named "Devops" on GitHub:

    • Log in to your GitHub account.

    • Click on the "+" sign in the upper right corner and choose "New repository."

    • Name your repository "Devops."

    • Add an optional description if desired.

    • Click "Create repository."

  2. Connect Your Local Repository to the GitHub Repository:

    After creating the GitHub repository, you need to establish a connection between your local repository and the newly created GitHub repository. In your terminal, navigate to the local repository directory and execute the following commands:

     git remote add origin

    Replace "your-username" with your GitHub username. This command adds a remote named "origin," pointing to your GitHub repository.

  3. Create a New File in "Devops/Git/Day-02.txt" and Add Content:

    • In your terminal, navigate to the local repository directory.

    • Execute the following command to create a new file and open it in a text editor:

        touch Devops/Git/Day-02.txt

      This command creates a new text file named "Day-02.txt" in the specified directory.

    • Add some content to the file using your preferred text editor.

  4. Push Your Local Commits to the GitHub Repository:

    • Once the file is created and content is added, you need to commit and push your changes to GitHub.

    • In your terminal, execute the following commands:

        git add .
        git commit -m "Add Day-02.txt with content"
        git push origin main
      • git add .: Stages all changes for commit.

      • git commit -m "Add Day-02.txt with content": Commits the changes with a descriptive message.

      • git push origin main: Pushes the changes to the 'main' branch on your GitHub repository.

  5. Pull Changes from the GitHub Repository:

    • If there are changes made by others on the GitHub repository, you might want to pull those changes to keep your local repository up to date.

    • In your terminal, navigate to the local repository directory and execute the following command:

        git pull origin main

      This command fetches changes from the 'main' branch on the GitHub repository and merges them into your local branch.

These steps complete Task-2, ensuring that your local changes are reflected in the GitHub repository, and you can also pull any changes made by others. Congratulations, you have successfully set up your Git user information, created a repository on GitHub, connected your local repository, added a file, pushed your changes, and pulled any changes from the GitHub repository!