git Command in Linux

Introduction to Git Version Control

This hands-on lab provides a practical introduction to using the Linux git command for version control. Through real-world examples, you'll learn how to initialize a new Git repository, add and commit files, and manage Git branches. This lab covers core Git commands and concepts, offering valuable experience for systemadmin professionals managing software development projects.

You will be guided through setting up a Git repository, configuring user information, and performing essential Git operations like adding and committing files. Mastering these fundamental skills is essential for effective collaboration on code projects and meticulously tracking changes over time, crucial for any aspiring systemadmin.

Initializing a Git Repository: A Systemadmin's Guide

This section details how to initialize a new Git repository, a foundational skill for any systemadmin managing code. We'll cover setting up your local development environment.

First, navigate to the directory where you want to establish your Git repository:

cd ~/project

Next, initialize the new Git repository using the git init command. This is the first step in version controlling your project:

git init

Example output:

Initialized empty Git repository in /home/labex/project/.git/

The git init command creates a hidden .git directory within your project folder. This directory is where Git stores all version control related data and metadata. Essential for proper operation of Git.

Next, configure your Git user name and email address. These settings will be associated with every commit you make to the repository:

git config --global user.name "Your Name"
git config --global user.email "[email protected]"

This sets your user name and email globally for all Git repositories on your system. As a systemadmin, you can also set these values at the repository level for specific projects, offering granular control.

Your Git repository is now initialized and configured. The next step will involve adding and committing files to the repository, further solidifying your understanding of Git workflows.

Adding and Committing Files to the Git Repository: A Practical Example

This section demonstrates how to add files to your Git repository and commit those changes, a core competency for systemadmin tasks.

First, let's create a sample file in the project directory:

echo "This is a test file." > test.txt

Now, check the status of the Git repository to see the new file:

git status

Example output:

On branch master

No commits yet

Untracked files:
  (use "git add <file>..." to include in what will be committed)
        test.txt

nothing added to commit but untracked files present (use "git add" to track)

The output shows test.txt as an "untracked file." This means Git is aware of the file but it's not under version control yet. To add it to the Git repository, use the git add command:

git add test.txt

Check the status again to see the change:

git status

Example output:

On branch master

No commits yet

Changes to be committed:
  (use "git rm --cached <file>..." to unstage)
        new file:   test.txt

The file is now "staged," meaning it's ready to be committed. Committing saves the changes to the Git history. Use the git commit command:

git commit -m "Add test.txt file"

Example output:

[master (root-commit) 1234567] Add test.txt file
 1 file changed, 1 insertion(+)
 create mode 100644 test.txt

The -m flag lets you add a descriptive commit message, which is essential for understanding the changes in the future. Systemadmin best practice encourages clear and concise commit messages.

The file has now been successfully added and committed to the Git repository. Your changes are now tracked!

Exploring Git Branch Management for Systemadmin Efficiency

This section explores Git branches, essential for managing different versions of your project and a critical skill for any systemadmin working with codebases.

First, let's examine the current branch:

git branch

Example output:

* master

This indicates you're currently on the master branch. The asterisk denotes the active branch.

Now, let's create a new branch named feature/new-page:

git checkout -b feature/new-page

Example output:

Switched to a new branch 'feature/new-page'

The git checkout -b command creates a new branch and immediately switches to it. This allows for isolated development of new features.

Let's modify the test.txt file within the new branch:

echo "Adding a new line to the test file." >> test.txt

Check the repository status:

git status

Example output:

On branch feature/new-page
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   test.txt

no changes added to commit (use "git add" and/or "git commit -a")

The changes reside solely in the feature/new-page branch and haven't been committed yet.

Commit these changes:

git add test.txt
git commit -m "Add new line to test.txt"

Example output:

[feature/new-page 7890abc] Add new line to test.txt
 1 file changed, 1 insertion(+)

Now, switch back to the master branch:

git checkout master

Example output:

Switched to branch 'master'

Notice that the changes made in the feature/new-page branch are not present in the master branch. This isolation is a key advantage of using Git branches. You are effectively working on two separate versions of your files.

This is a basic demonstration of Git branch workflows. You can create, switch between, and eventually merge branches to manage different features and versions of your code, crucial for effective systemadmin version control.

Summary: Git Fundamentals for Systemadmins

This lab provided a foundation in essential Git operations: initializing a Git repository, configuring your Git user name and email, adding files, and committing changes. You began by navigating to the project directory and using the git init command to create a new Git repository. Next, you configured your Git identity using the git config command. You then created a test.txt file and used git add to stage it for commit. Finally, the git status command helped you understand the state of the repository and the changes ready to be committed. These are the core tools any systemadmin needs for effective code management.

400+ Linux Commands