Easy Way to Configure Git on Linux Server

Himanshu Joshi Knowledgebase

Git is a distributed version control system that allows multiple developers to work on a project at the same time without interfering with each other’s work. To manage your workflow effectively, you can configure Git for optimal source code management, making it one of the most widely used version control systems.

Git on a Linux Server

Configuring Git on a Linux server allows you to create and manage repositories, collaborate with other developers, and track changes to your code efficiently.

In this guide, we will walk you through the steps to install and configure Git on a Linux server.

Prerequisites

Before you start configuring Git on your Linux server, ensure the following:

  • Linux Distribution: Git can be installed on most Linux distributions like Ubuntu, CentOS, Debian, and RHEL.
  • Root Access: You will need root or sudo privileges to install Git and configure system settings.
  • Basic Knowledge of Linux Commands: Familiarity with the terminal and basic Linux commands will help you navigate the system and configure Git effectively.

Once you have these prerequisites, you’re ready to install and configure Git on your Linux server.

Configure Git on a Linux Server

To effectively manage code on your Linux server, you need to configure Git properly. This setup enables version control, collaborative development, and efficient tracking of code changes, ensuring smooth project management across distributed teams.

Step 1: Install Git

Git is available in the default package repositories of most Linux distributions. You can install Git using the package manager for your Linux distribution.

Install Git on Ubuntu/Debian

  • Update your system:
sudo apt update
  • Install Git:
sudo apt install git
  • Verify Installation:

After installation, you can verify that Git has been successfully installed by checking its version:

git --version
  • You should see output similar to:
git version 2.25.1

Install Git on CentOS/RHEL

  • Install Git using YUM:
sudo yum install git
  • Verify Installation: Check the installed version of Git:
git --version

Step 2: Configure Git User Information

Before using Git, you need to configure your user information. This includes your name and email address, which will be associated with your commits.

  • Set Your Username:
git config --global user.name "Your Name"
  • Set Your Email Address:
git config --global user.email "your.email@example.com"

These configurations will be used for all repositories on your system. You can always override these settings on a per-repository basis if needed.

  • Verify Your Configuration:

To verify that Git has been configured with the correct user information, run:

git config --list

This will display all Git configurations, including the user.name and user.email you just set.

Step 3: Set Up SSH Keys

Using SSH keys is a secure way to authenticate with remote Git repositories, such as GitHub, GitLab, or Bitbucket. Setting up SSH keys allows you to push and pull from repositories without needing to enter your username and password each time.

Generate an SSH Key Pair

  • Generate the SSH key:

Run the following command and follow the prompts:

ssh-keygen -t rsa -b 4096 -C "your.email@example.com"

You will be prompted to enter a file in which to save the key. Press Enter to use the default location (~/.ssh/id_rsa).

  • Add the SSH Key to the SSH Agent:

Start the SSH agent:

eval "$(ssh-agent -s)"

Add the SSH private key to the agent:

ssh-add ~/.ssh/id_rsa
  • Add SSH Public Key to Git Server:

Copy the public key to your clipboard:

cat ~/.ssh/id_rsa.pub

Then, go to the SSH Keys section of your Git hosting service (such as GitHub, GitLab, or Bitbucket) and add your SSH public key there.

Test SSH Connection

To test if your SSH setup is working, run:

ssh -T git@github.com

Replace github.com with the Git server you are using (e.g., gitlab.com or bitbucket.org). You should see a message confirming a successful SSH connection.

Step 4: Create and Clone Git Repositories

Now that Git is installed and configured, you can create new repositories or clone existing ones.

Create a New Local Repository

To create a new Git repository locally, navigate to the directory where you want to store your project and run:

mkdir my_project
cd my_project
git init

This initializes a new empty Git repository in the my_project directory. You can now start adding files and making commits.

Clone an Existing Repository

To clone an existing Git repository from a remote server (e.g., GitHub, GitLab), use the following command:

git clone git@github.com:username/repository.git

Replace username/repository.git with the actual URL of the repository you want to clone.

Add Files to Your Repository

Once inside the repository, add files to it:

touch README.md
git add README.md

This stages the README.md file for commit. You can add multiple files by using git add . to add all files in the current directory.

Commit Changes

To commit changes to your local repository, use:

git commit -m "Initial commit"

This saves the changes to the repository with the message “Initial commit.”

Step 5: Push Changes to Remote Repository

Once you have committed your changes locally, you can push them to a remote Git server (such as GitHub, GitLab, or Bitbucket).

  • Add Remote Repository:

If you cloned the repository initially, this step is already done. If you created a new repository and need to link it to a remote server, use:

git remote add origin git@github.com:username/repository.git
  • Push Changes:

To push your changes to the remote repository, run:

git push -u origin master

This will upload your local commits to the master branch of the remote repository. For other branches, replace master with the name of the branch.

Step 6: Pull Updates from Remote Repository

If you want to fetch and integrate updates from a remote repository, you can use git pull:

git pull origin master

This will fetch the latest changes from the master branch of the remote repository and merge them with your local branch.

Step 7: Configure Git Aliases

Git allows you to configure shortcuts, called aliases, for frequently used commands. To create an alias, run:

git config --global alias.st status
git config --global alias.co checkout
git config --global alias.ci commit

With these aliases, you can use shorter commands such as:

  • git st instead of git status
  • git co instead of git checkout
  • git ci instead of git commit

To list all your aliases, run:

git config --get-regexp alias

Step 8: Backup and Restore Git Repositories

It is essential to regularly back up your Git repositories, especially if you are managing critical code.

  • Backup a Git Repository:

To back up a repository, you can simply copy the entire directory or use a tool like rsync to create a backup:

rsync -av --progress /path/to/repo /path/to/backup
  • Restore from Backup:

To restore a repository from a backup, copy the files back into place and navigate to the repository directory:

rsync -av /path/to/backup/repo /path/to/repo
cd /path/to/repo
git fsck

Conclusion

In this guide, we’ve walked through how to configure Git on a Linux server, from installation and basic setup to creating repositories, pushing changes, and configuring SSH keys for secure authentication. Git is a powerful tool for version control, and with the steps outlined here, you can set up and manage repositories, collaborate with others, and maintain your code efficiently.

By setting up Git on your Linux server, you’re now equipped to manage software development projects, track changes, and ensure that your team can collaborate effectively. Whether you’re working alone or in a team, Git provides the tools you need to manage your codebase with ease.

Tags:
Leave A Comment