Git & GitHub 01

Deep Dive into Git & GitHub for DevOps Engineers

Today, we’re going to explore the tools that DevOps engineers rely on every day—Git and GitHub. These are essential for managing code, keeping track of changes, and collaborating with teams, especially when working with infrastructure and automation. Let’s dive into what they are, how they work, and how to get started with them.

What is Git, and Why is It Important?

Git is basically a tool that helps you manage your code, keeping track of every change you make, like a save button that logs every version of your project. It allows you to go back to a previous version of your code whenever you need to, which is super useful if something breaks. This is called version control.

It’s also great for working with others—Git lets multiple people work on the same project at the same time, and it helps merge everyone’s changes together without messing things up. In DevOps, where you’re working with code and configurations constantly, Git ensures you don’t lose track of what’s happening and who made which changes.

What’s the Difference Between the "Main" and "Master" Branch?

If you’ve used GitHub, you might have seen some projects using the "main" branch and others using "master." The truth is, they’re the same thing functionally—it’s just a naming difference.

Historically, Git and GitHub used "master" as the default name for the primary branch, but more recently, they switched to using "main" by default to adopt more inclusive terminology. So, don’t worry about the names—the main/master branch is just the default branch where the core of your project lives.

Git vs. GitHub: What’s the Difference?

This one’s easy to mix up! Here’s a simple way to look at it:

Git is the tool you use on your computer to track code changes, manage branches, and collaborate on code. You can use Git without ever touching the internet.
GitHub is a website where you store your Git repositories online. It’s like a cloud backup for your Git projects and a place where teams can collaborate remotely.

So, Git is the actual software, while GitHub is the platform that hosts your Git projects.

How to Create a New Repository on GitHub

Creating a repository (repo) on GitHub is simple:

Log in to GitHub: Head over to GitHub and sign in.
Click “New”: Go to your dashboard, find the “New” button, and click it.
Name Your Repo: Give your repo a name (let’s call it "DevOps"). You can add a description if you want, and choose whether you want it to be public or private.
Create the Repo: Hit Create repository, and you’re all set!

Now you have a brand-new GitHub repo where you can push your code.

What’s the Difference Between Local and Remote Repositories?

A local repository is the version of your project that lives on your computer, while a remote repository is a version that’s stored somewhere online, like on GitHub. Typically, you’ll work on your project locally, then push your changes to the remote repo for safekeeping or for others to collaborate with you.

To connect your local repo to GitHub, you’ll need to run a few commands in your terminal:

Create a new repo on GitHub.

Link your local project to this new repo with:

 git remote add origin https://github.com/your-username/repository-name.git
 git push -u origin main

Now, your local changes are linked to the online version, and you can push updates whenever you want.

Tasks: Hands-On with Git & GitHub

Let’s get practical with a few simple tasks that will help you understand how Git and GitHub work together.

Task 1: Set Up Your Git User Info

Before you start committing changes, Git needs to know who’s making the changes (so it can track them properly). You can set up your name and email with these commands:

git config --global user.name "Your Name"
git config --global user.email "your.email@example.com"

This info will be attached to all your commits.

Task 2: Create a Repository on GitHub and Push Changes

Here’s how you can create a new project on GitHub and push your local files:

Create a Repo on GitHub: Name it DevOps by following the steps we discussed earlier.
Set Up a Local Repo: On your computer, create a new directory for your project and initialize Git:
```
 mkdir DevOps
 cd DevOps
 git init
```
Create a File: Add a new file to the project. You can create a folder structure and add some content to a file like this:
```
 mkdir -p Git
 echo "Day 2 Git content" > Git/Day-02.txt
```
Stage and Commit the Changes: This tells Git to keep track of the changes you’ve made:
```
 git add .
 git commit -m "Added Day-02.txt with content"
```
Connect Your Repo to GitHub: Link your local project to the GitHub repo:
```
 git remote add origin https://github.com/your-username/DevOps.git
```
Push Your Changes: Finally, push your local commits to GitHub with:
```
 git push -u origin main
```

And just like that, your local changes are now uploaded to GitHub!

Thought- - -

By mastering Git and GitHub, you’re getting a grip on one of the most crucial parts of being a DevOps engineer. Whether you’re managing code, infrastructure, or automation scripts, understanding version control and collaborating through platforms like GitHub is key.

Git & GitHub 01 - Day 12