Getting Hands-On with Git for Version Control

Welcome to the third article in our DevOps From Scratch series! After covering the fundamentals of DevOps and CI/CD pipelines, it's time to dive into one of the most essential tools in any developer's toolkit: Git. If you're serious about DevOps, mastering Git isn't optional—it's absolutely necessary.

Why Git Matters in the DevOps World

If you've spent even a day in tech, you've probably heard someone mention Git. But what makes it so special?

Git is a distributed version control system that tracks changes to your code over time. Unlike older systems, Git gives each developer their own complete copy of the repository. This means you can work offline, commit changes locally, and sync up when you're ready.

In DevOps environments, where continuous integration and delivery are king, Git provides the foundation that makes collaboration possible without chaos. When multiple team members are working on the same codebase, Git helps prevent them from accidentally overwriting each other's work.

Git Basics: Understanding the Core Concepts

Before we get our hands dirty with commands, let's get familiar with some key Git concepts:

• Repository (Repo): The folder containing your project and the hidden .git directory that tracks all changes
• Commit: A snapshot of your files at a specific point in time
• Branch: A separate line of development that lets you work on features without affecting the main codebase
• Merge: The process of combining changes from different branches
• Clone: Creating a local copy of a remote repository
• Push/Pull: Sending your changes to or retrieving changes from a remote repository

Getting Started: Installing and Setting Up Git

Let's start by getting Git installed on your machine:

For Windows:

1. Download the installer from git-scm.com
2. Run the installer, accepting default options is usually fine
3. Look for Git Bash in your Start menu after installation

For Mac:

brew install git

Or download from the Git website if you don't use Homebrew.

For Linux (Ubuntu/Debian):

sudo apt-get update
sudo apt-get install git

Once installed, you'll need to configure Git with your identity:

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

This information will be attached to every commit you make, so your team knows who did what.

Creating Your First Git Repository

Now let's create a simple project and initialize Git:

1. Create a new folder for your project:

mkdir my-first-git-project
cd my-first-git-project

2. Initialize Git:

git init

3. Create a simple file:

echo "# My First Git Project" > README.md

4. Check the status of your repository:

git status

You should see that README.md is listed as an untracked file. This means Git sees the file but isn't tracking changes to it yet.

The Git Workflow: Add, Commit, Push

The basic Git workflow follows these steps:

1. Track files with git add

git add README.md

Or to add all files:

git add .

2. Commit your changes

git commit -m "Initial commit with README file"

The -m flag lets you add a message describing your changes. Always make these messages clear and descriptive!

3. View your commit history

git log

This shows all commits, starting with the most recent.

Branching: Git's Superpower

Branching is where Git really shines. It allows you to create separate lines of development without affecting your main codebase.

Creating a new branch:

git branch feature-login
git checkout feature-login

Or the shorthand:

git checkout -b feature-login

Now you can make changes on this branch without affecting the main branch (usually called main or master).

Switching between branches:

git checkout main

Merging changes back:

After completing work on your feature branch, you'll want to merge those changes back to the main branch:

git checkout main
git merge feature-login

Dealing with Merge Conflicts

When Git can't automatically merge changes (usually because the same lines were edited in different branches), you'll encounter a merge conflict. Don't panic! This is normal.

Git will mark the conflicts in your files, and you'll need to manually edit them to resolve the conflicts:

<<<<<<< HEAD
This is the content from the current branch
=======
This is the content from the branch you're merging in
>>>>>>> feature-branch

Edit the file to keep the changes you want, remove the conflict markers, then:

git add <file-with-resolved-conflict>
git commit -m "Resolved merge conflict"

Working with Remote Repositories

So far, we've only worked locally. Let's connect to a remote repository like GitHub, GitLab, or Bitbucket.

Adding a remote:

git remote add origin https://github.com/yourusername/your-repo-name.git

Pushing your changes:

git push -u origin main

The -u flag sets up tracking, so in the future, you can simply type git push.

Cloning an existing repository:

git clone https://github.com/someuser/some-project.git

This creates a local copy of the repository, complete with all its history.

Advanced Git Techniques

Once you're comfortable with the basics, you can explore more advanced Git features:

Stashing changes:

Need to switch branches but aren't ready to commit? Stash your changes:

git stash

And later, retrieve them:

git stash pop

Interactive rebasing:

Clean up your commit history before pushing:

git rebase -i HEAD~3

This lets you rewrite the last 3 commits – combining, reordering, or even removing them.

Git hooks:

Automate tasks by setting up scripts that run before or after Git events like commits or pushes. These live in the .git/hooks directory.

Git Best Practices for DevOps

To truly master Git in a DevOps context, follow these best practices:

1. Commit often, push regularly: Small, frequent commits are easier to manage and understand.

2. Write meaningful commit messages: "Fixed stuff" isn't helpful. "Fixed login validation bug on mobile devices" is.

3. Use branching strategies: Popular models include GitFlow (for scheduled releases) and Trunk-Based Development (for continuous deployment).

4. Protect your main branch: Require pull requests and code reviews before merging to main.

5. Automate with CI/CD: Connect your Git repositories to CI/CD pipelines (as we discussed in our previous article).

6. Tag releases: Use Git tags to mark release points in your code history.

7. Keep binaries out of Git: Use .gitignore to exclude build artifacts, dependencies, and other large files.

Common Git Pitfalls and How to Avoid Them

Even experienced developers make mistakes with Git. Here are some common ones to watch out for:

• Committing sensitive information: Once pushed, it's in your history. Use .gitignore for config files with secrets.

• Force pushing: Using git push --force can overwrite remote history. Use --force-with-lease instead if you must force push.

• Huge commits: Don't wait until you've made dozens of changes to commit. Commit logically related changes together.

• Forgetting which branch you're on: Always check with git status before making changes.

Git in the Larger DevOps Ecosystem

Git doesn't exist in isolation. In a mature DevOps environment, Git connects to:

• CI/CD systems like Jenkins, CircleCI, or GitHub Actions, which automatically build and test your code on every push
• Infrastructure as Code tools like Terraform (which we'll cover in our sixth article)
• Code review platforms integrated with Git providers
• Issue tracking systems that link commits to tickets or tasks

Wrapping Up

Git might seem complex at first, but with practice, it becomes second nature. The investment in learning Git pays off exponentially as your projects grow and you collaborate with more people.

Remember, Git is more than just a tool—it's a different way of thinking about code development. By tracking history and enabling collaboration, Git helps teams work together seamlessly, which is at the heart of DevOps culture.

Stay tuned for our next article in this series, where we'll explore Kubernetes and how it orchestrates containers (building on the Docker knowledge from our previous post).

Have questions about Git or want to share your experience? Drop a comment below or reach out on our social media. Happy coding!