Managing Multiple Git User Profiles on a Single System

Git is a vital tool for version control in software development, but things may get tricky when a developer wants to use several Git profiles for different projects or when working on a single system with multiple users. Managing multiple Git users can be done in several ways, ensuring each commit has the correct user information and credentials. This article covers various methods to manage and use multiple Git users on a single machine.

Table of contents

Show table of contents

Why Manage Multiple Git Users?

There are several scenarios where managing multiple Git profiles is necessary:

  • Personal and Work Projects: A developer might contribute to both personal and professional repositories, requiring different email addresses and SSH keys for each.

  • Multiple Organizations: Some developers work with different companies or organizations, each needing separate authentication credentials.

  • Shared Systems: In environments like shared servers, multiple users may need to collaborate while keeping their identities and access distinct.

Methods for Managing Multiple Git Users

1. Global and Local Git Configuration

Git configurations can be set at two levels:

  • Global configuration: Applies system-wide to all Git repositories for the current user.

  • Local configuration: Overrides the global configuration for a specific repository.

Setting Up Global Git Configuration

To configure Git globally, use the following commands:

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

This configuration will be used for all repositories unless overridden locally. You can check your global configuration by running:

git config --global --list

Setting Up Local Git Configuration

If you need a different identity for a particular repository, you can configure it locally. For example, if you want to use a work email for a project, navigate to the project’s directory and run:

cd /path/to/your/repository
git config user.name "Work Name"
git config user.email "workname@company.com"

Now, commits made in this repository will use the local settings rather than the global ones.

Example Scenario

# Global configuration for personal GitHub account
git config --global user.name "John Doe"
git config --global user.email "johndoe@gmail.com"

# Local configuration for work project
cd /path/to/work/repo
git config user.name "John Doe (Work)"
git config user.email "johndoe@company.com"

In this case, commits made in the personal repositories will use the global email, while commits made in the work repository will use the work-specific email address.

2. Using Multiple SSH Keys

When working with multiple Git profiles, especially across different services (e.g., GitHub, GitLab, Bitbucket), SSH keys provide secure authentication. You can create and manage multiple SSH keys for different Git accounts.

Step-by-Step Guide for Multiple SSH Keys

  1. Generate SSH Keys for different accounts:
# For personal account
ssh-keygen -t rsa -b 4096 -C "personal@example.com"
# Name it id_rsa_personal when prompted to save the key

# For work account
ssh-keygen -t rsa -b 4096 -C "work@example.com"
# Name it id_rsa_work when prompted to save the key
  1. Add the SSH keys to the SSH agent:

First, start the SSH agent:

eval "$(ssh-agent -s)"

Then add your SSH keys:

ssh-add ~/.ssh/id_rsa_personal
ssh-add ~/.ssh/id_rsa_work
  1. Create or edit the SSH config file (~/.ssh/config) to specify which key should be used for each Git service:
# Personal GitHub account
Host github.com-personal
    HostName github.com
    User git
    IdentityFile ~/.ssh/id_rsa_personal

# Work GitHub account
Host github.com-work
    HostName github.com
    User git
    IdentityFile ~/.ssh/id_rsa_work
  1. Use the correct SSH host when cloning repositories:

When cloning repositories, use the alias defined in your SSH config file. For example:

# For personal account
git clone git@github.com-personal:username/repository.git

# For work account
git clone git@github.com-work:workusername/work-repo.git

Now Git will use the appropriate SSH key for each account.

3. Using Git Credential Manager

Another method to manage multiple users on a single system is using the Git Credential Manager. This tool securely stores credentials for each remote Git repository you access.

Installing Git Credential Manager

Git Credential Manager comes pre-installed with Git on many systems. You can verify its installation or install it via the following commands:

# For macOS and Linux:
brew install git-credential-manager-core

# For Windows:
git-credential-manager-core configure

Setting Up Different Credentials for Different Repositories

Once installed, you can configure Git Credential Manager to manage different credentials automatically for each repository.

  1. Clone the repository as usual:
git clone https://github.com/username/repository.git

  1. When prompted for credentials, Git Credential Manager will store them securely for future use.

  2. Configure different credentials for different repositories by providing the relevant username and password when prompted. Git will remember these credentials for each repository.

4. Using Git Aliases and Scripts for User Switching

A more advanced approach for managing multiple Git users is by setting up custom Git aliases or writing shell scripts to switch between profiles.

Git Alias Method

You can create Git aliases to simplify switching between different user profiles.

git config --global alias.workconfig 'config user.name "Work Name" && git config user.email "work@company.com"'
git config --global alias.personalconfig 'config user.name "Personal Name" && git config user.email "personal@example.com"'

Now, you can switch profiles with a single command:

git workconfig  # Switch to work profile
git personalconfig  # Switch to personal profile

Shell Script for Profile Switching

Another option is to create a shell script to automate user switching:

#!/bin/bash

if [ "$1" == "work" ]; then
    git config user.name "Work Name"
    git config user.email "work@company.com"
elif [ "$1" == "personal" ]; then
    git config user.name "Personal Name"
    git config user.email "personal@example.com"
else
    echo "Usage: switch-profile [work|personal]"
fi

Save this script, make it executable, and place it in your path. You can now switch profiles by running:

switch-profile work  # Switch to work profile
switch-profile personal  # Switch to personal profile

Conclusion

Managing multiple Git users on a single system can be accomplished using a combination of global and local configurations, SSH key management, Git Credential Manager, and automation with Git aliases or shell scripts. Each method has its specific use case, allowing you to tailor the solution based on your needs—whether you’re working on personal and work projects or contributing to repositories across different organizations.

By properly managing Git users, you can ensure that commits are always attributed correctly and that authentication to multiple Git services remains smooth and secure.