A Step-by-Step Guide on How to Create an SSH Key for GitLab

Creating an SSH key for GitLab is a crucial step in ensuring secure and efficient interactions with your repositories. This guide will walk you through the process of generating, configuring, and managing SSH keys for GitLab, tailored for users on Windows, macOS, and Linux.

Key Takeaways

  • Learn the importance of SSH keys and how they enhance security for GitLab repositories.
  • Understand the differences between public and private keys, and how they work together.
  • Get step-by-step instructions on generating a new SSH key pair using the ssh-keygen command.
  • Discover how to add your SSH key to the SSH agent and configure it for custom key locations.
  • Find out how to manage your SSH keys, including updating and removing old or compromised keys.

Understanding SSH Keys and Their Importance

What is an SSH Key?

SSH uses two keys, a public key and a private key.

  • The public key can be distributed.
  • The private key should be protected.

It is not possible to reveal confidential data by uploading your public key. When you need to copy or upload your SSH public key, make sure you do not accidentally copy or upload your private key instead.

Why Use SSH Keys for GitLab?

Use SSH keys when you want to:

  • Check out internal submodules.
  • Download private packages using your package manager. For example, Bundler.
  • Deploy your application to your own server or, for example, Heroku.
  • Execute SSH commands from the build environment to a remote server.
  • Rsync files from the build environment to a remote server.

If anything of the above rings a bell, then you most likely need an SSH key.

Public vs. Private Keys

The SSH stands for Secure Shell or Secure Socket Shell used for managing the networks, operating systems and configurations and also authenticates to the GitLab server without using username and password each time. You can set the SSH keys to provide a reliable connection between the computer and GitLab. Before generating ssh keygen, you need to have Git installed in your system.

SSH keys are a comprehensive guide on adding GitLab SSH keys, including generating, locating, adding, verifying, and troubleshooting. Emphasizes security, best practices, and common issues.

Preparing Your System for SSH Key Generation

Before you can generate an SSH key for GitLab, it’s essential to ensure your system is properly set up. This section will guide you through the necessary preparations for different operating systems.

Installing Git Bash on Windows

For Windows users, Git Bash provides a Unix-like terminal that is crucial for generating SSH keys. Follow these steps to install Git Bash:

  1. Download the Git Bash installer from the official Git website.
  2. Run the installer and follow the on-screen instructions.
  3. Once installed, open Git Bash from the Start menu.

Setting Up a Terminal on macOS and Linux

macOS and Linux systems come with built-in terminals, making it easier to generate SSH keys. Simply open the Terminal application from your Applications folder or use a shortcut like Ctrl + Alt + T on Linux.

Verifying Existing SSH Keys

Before generating a new SSH key, it’s a good idea to check if you already have one. Open a terminal and run the following command:

ls -al ~/.ssh

This command lists the files in your .ssh directory. Look for files named id_rsa or id_ed25519, which indicate existing SSH keys.

Ensuring your system is ready for SSH key generation is a crucial first step in this hands-on guide. Follow these steps to avoid any issues later on.

Generating a New SSH Key Pair

To create and use an SSH key in GitLab CI/CD, follow these steps to generate a new SSH key pair locally.

Using ssh-keygen Command

Open a terminal and run the ssh-keygen command followed by the key type and an optional comment. This comment is included in the .pub file that’s created. For example:

ssh-keygen -t ed25519 -C "<comment>"

For a 2048-bit RSA key:

ssh-keygen -t rsa -b 2048 -C "<comment>"

Choosing Between RSA and ED25519

When generating a new SSH key pair, you can choose between RSA and ED25519. ED25519 is preferred for its security and performance benefits. However, RSA is still widely used and supported.

Setting a Passphrase

After running the ssh-keygen command, you will be prompted to set a passphrase. This adds an extra layer of security to your private key. You can choose to leave it empty, but setting a passphrase is recommended for enhanced security.

A public and private key are generated. Add the public SSH key to your GitLab account.

Locating Your SSH Key Files

To effectively manage your SSH keys, it’s crucial to know where they are stored on your system. This section will guide you through the default and custom storage locations, as well as how to verify the creation of your key files.

Adding Your SSH Key to the SSH Agent

Starting the SSH Agent

To start the SSH agent, open your terminal and run the following command:

eval $(ssh-agent -s)

This command initializes the SSH agent and outputs the process ID. Ensure the agent is running before proceeding to the next steps.

Adding the SSH Key to the Agent

Once the SSH agent is running, you can add your SSH key to the agent. Use the following command, replacing ~/.ssh/id_rsa with the path to your private key file if it’s different:

ssh-add ~/.ssh/id_rsa

If your private key is stored in a custom location, make sure to specify the correct path. This step allows the agent to manage your key securely.

Verifying the SSH Agent

To verify that your SSH key has been added to the agent, use the command:

ssh-add -l

This command lists all the keys currently managed by the SSH agent. If your key appears in the list, it has been successfully added.

Tip: If you encounter any issues, ensure your private key file has the correct permissions. You can set the appropriate permissions using:
chmod 400 ~/.ssh/id_rsa

Copying the Public SSH Key

To connect your system with GitLab, you need to copy the contents of your public SSH key. This process varies slightly depending on your operating system. Below are the steps for macOS, Linux, and Windows.

Finding the Public Key File

First, locate your public key file. By default, this file is named id_rsa.pub or id_ed25519.pub and is stored in the ~/.ssh directory. You can navigate to this directory using the terminal:

cd ~/.ssh

Using pbcopy on macOS

For macOS users, copying the public key to the clipboard is straightforward. Use the pbcopy command to copy the contents of your public key file:

pbcopy < ~/.ssh/id_rsa.pub

If you’re using an ED25519 key, the command would be:

tr -d '\n' < ~/.ssh/id_ed25519.pub | pbcopy

Manual Copy on Windows and Linux

On Windows, you can use Git Bash to copy the public key. Open Git Bash and run the following command:

cat ~/.ssh/id_rsa.pub | clip

For Linux users, ensure you have the xclip package installed. Then, use the following command to copy the public key:

xclip -sel clip < ~/.ssh/id_rsa.pub

Important: Make sure you copy the entire key, starting from ssh-rsa or ssh-ed25519 and ending with your comment. This ensures that the key will be recognized correctly by GitLab.

Once the mirror is set, you will get an option to copy the public key. Then, set that public key as a deploy key in the target repo. This will enable the mirroring to work seamlessly.

Adding the SSH Key to Your GitLab Account

Navigating to GitLab Settings

To add your SSH key to GitLab, first, log in to your GitLab account by visiting GitLab. Once logged in, click on the Settings option located in the top right drop-down menu, which appears when you select your profile icon.

Accessing the SSH Keys Tab

In the Settings menu, find and click on the SSH Keys tab. This section is specifically designed for managing your SSH keys.

Pasting the Public Key

After generating your SSH key, you need to copy the public key. Open the file containing your public key (usually named id_rsa.pub or id_ed25519.pub), and copy its contents. Then, paste the copied key into the provided Key box in the SSH Keys tab on GitLab. Finally, click the Add Key button to save your new SSH key.

Pro Tip: Ensure your public key is copied correctly without any extra spaces or newlines to avoid authentication issues.

Testing Your SSH Connection to GitLab

Using ssh -T Command

To verify that your SSH key was added correctly, you can use the ssh -T command. This command attempts to authenticate with the GitLab server using your SSH key. Replace gitlab.example.com with your GitLab instance’s hostname, for example, git@gitlab.com.

ssh -T git@gitlab.com

If everything is set up correctly, you should see a success message. This confirms that your SSH key is working properly.

Troubleshooting Connection Issues

If you encounter issues, there are a few steps you can take to troubleshoot:

  1. Check the SSH host keys fingerprint: Ensure you’re connecting to the correct server by verifying the server’s SSH host keys fingerprint. For GitLab.com, refer to the SSH host keys fingerprints documentation.

  2. Verify the SSH agent: Make sure your SSH agent is running and has your key added. You can check this with the following command:

    ssh-add -l
  3. Inspect your SSH config file: Ensure that your SSH config file (~/.ssh/config) is correctly configured to use the right key for your GitLab instance.

Ensuring Successful Authentication

After troubleshooting, try connecting again using the ssh -T command. If you continue to experience issues, consider the following:

  • Re-add your SSH key: Sometimes, re-adding your SSH key to the SSH agent can resolve issues. Use the command:

    ssh-add ~/.ssh/id_rsa
  • Check for typos: Ensure there are no typos in your SSH command or configuration files.

Tip: Regularly updating your SSH keys and maintaining a clean SSH config file can help prevent connection issues in the future.

Configuring SSH for Custom Key Locations

Editing the SSH Config File

To use a custom location for your SSH keys, you need to edit the SSH config file. This file is typically located at ~/.ssh/config. If it doesn’t exist, you can create it. Add the following configuration to specify your custom key location:

Host gitlab.com
  PreferredAuthentications publickey
  IdentityFile ~/.ssh/custom_key

Specifying Custom Key Paths

When specifying custom key paths, ensure that the path to your private key is correct. This is crucial for the SSH client to locate and use the key. For example, if your private key is stored in a directory named keys, your configuration would look like this:

Host gitlab.com
  PreferredAuthentications publickey
  IdentityFile ~/keys/custom_key

Testing the Configuration

After editing the SSH config file, it’s important to test the configuration to ensure everything is set up correctly. You can do this by running:

ssh -T git@gitlab.com

If everything is configured properly, you should see a success message. Always verify your configuration to avoid connection issues later.

For GitLab Premium users, configuring SSH for custom key locations can enhance security and streamline access management.

Maintaining and Managing Your SSH Keys

person using laptop with SSH key icon and GitLab logo

Regularly Updating Your Keys

To ensure the security of your GitLab repositories, it’s crucial to regularly update your SSH keys. This practice helps mitigate the risk of unauthorized access due to compromised or outdated keys. Aim to update your keys at least once a year or whenever you suspect a security breach.

Removing Old or Compromised Keys

Keeping your list of SSH keys clean and up-to-date is essential. Remove any old or compromised keys from your GitLab account to prevent unauthorized access. You can do this by navigating to your SSH Keys settings in GitLab and deleting the keys you no longer use.

Best Practices for Key Management

Adhering to best practices for SSH key management can significantly enhance your security posture. Here are some tips:

  • Use strong, unique passphrases for your keys.
  • Store your private keys in a secure location, such as a hardware security module (HSM) or a password manager.
  • Regularly audit your SSH keys and remove any that are no longer needed.
  • Consider using GitLab Ultimate for advanced security features and key management tools.

Proper SSH key management is not just a one-time setup but an ongoing process that requires regular attention and updates.


Creating an SSH key for GitLab is a straightforward process that significantly enhances the security and efficiency of your development workflow. By following the steps outlined in this guide, you can easily generate an SSH key, add it to your GitLab account, and start using it to securely interact with your repositories. Whether you’re cloning, fetching, pulling, or pushing code, SSH keys provide a seamless and secure method of authentication. Remember to keep your private key secure and only share your public key. With these best practices in place, you’ll be well on your way to a more secure and productive GitLab experience.

Frequently Asked Questions

What is an SSH Key?

An SSH key is a pair of cryptographic keys used to authenticate a user or device in an SSH protocol. It consists of a public key and a private key.

Why Use SSH Keys for GitLab?

SSH keys provide a secure way to access your GitLab repositories without needing to enter your username and password each time. They are more secure and convenient than traditional password-based authentication.

How do I generate an SSH Key on Windows?

To generate an SSH key on Windows, open Git Bash and use the command `ssh-keygen`. Follow the prompts to save the key and set a passphrase.

How do I add my SSH Key to GitLab?

First, copy the public SSH key. Then, log in to your GitLab account, navigate to the SSH Keys tab under settings, and paste the public key into the provided field.

Where are SSH Keys stored by default?

By default, SSH keys are stored in the `~/.ssh` directory on both Windows and Unix-based systems like macOS and Linux.

What is the difference between RSA and ED25519 keys?

RSA and ED25519 are types of cryptographic algorithms. RSA is older and widely supported, while ED25519 is newer, faster, and considered more secure.

How do I start the SSH agent?

To start the SSH agent, use the command `eval $(ssh-agent -s)` in your terminal. This will start the agent in the background.

How can I verify if my SSH Key is working with GitLab?

You can verify your SSH key by using the command `ssh -T [email protected]`. If everything is set up correctly, you should receive a success message.

You may also like...