Fatal could not read from remote repository ошибка

This tutorial shows you the two main origins and solutions to the error, «fatal: could not read from remote repository.» These are:

1. Git pushing to non-existing remote URL
2. Failing to config SSH keys properly

First, the tutorial briefly takes you through Git remote and creating an SSH connection between Git and GitHub. Next, the tutorial creates the error then shows you how to solve it step by step.

We use GitHub for the demos, but you can still follow along with a different website.

Git remote

Git tracks its connection to GitHub using the git remote command. For example, you can check the destination URLs using the git remote -v command.

steve@thisHostname:~/workingDir/pyFiles/.git$ git remote -v
origin  https://github.com/Stevealila/Python.git (fetch)
origin  https://github.com/Stevealila/Python.git (push)

origin is an alias for the https://github.com/Stevealila/Python.git URL. You can modify or update it.

The https part shows that the connection is via HTTPs, not SSH. github.com is the website, while Python is the name of the remote repository. (fetch) or (push) means we can get (clone or pull) or send (push) data through the remote URL, respectively.

Since getting or sending data to a remote may occur through multiple branches, you need to specify the (default is main) branch after the origin part.

git push origin main

You may ignore the origin main part if the remote only has one branch and the branch is checked out during the git push process.

git push

The key takeaway is that Git must know the path to fetching from or pushing changes to a remote repository. Otherwise, it may throw the error fatal: could not read from remote repository.

Before diving into practical examples, let me show you another common origin of the error.

ALSO READ: git HEAD~ vs HEAD^ vs HEAD@{} Explained with Examples

SSH Connection

Secure Shell (SSH) ensures two remote computers can connect and share data securely. In this case, your (local) computer and (remote) GitHub server want to share code.

But instead of asking you to input your username and password every time you want to push to the remote repository, SSH automatically completes the connection because the computers already remember each other after the initial connection.

So, you probably get the message, «fatal: could not read from remote repository.» because the remote machine cannot remember (authenticate) your local computer.

But how do you know if an SSH connection exists?

First, check the existence of the keys in the ~/.ssh folder of your local computer.

ls ~/.ssh

Better yet, you can generate a new one.

ssh-keygen -t ed25519 -C "<your GitHub email address>"

ssh-keygen is the command to generate a key.

The -t option specifies the type of encryption used to generate the key. I have used ed25519 algorithm. You can also try out rsa algorithm.

The -C option stands for comment.

Running the command outputs an SSH key pair: public and private. The public key ends in a .pub extension, while the private key lacks an extension.

You should inform your computer’s SSH agent about the new keys. The agent is the wallet that safely stores your various SSH keys. You can start up the SSH agent using the following commands.

eval "$(ssh-agent -s)"

Next, store your private key in the agent’s wallet using the following commands.

ssh-add ~/.ssh/id_ed25519

id_ed25519 is the private key we generated earlier. Its full path is ~/.ssh/id_ed25519. We add it to the activated SSH agent using the ssh-add command.

Note: You need to add a config file before using the command on MacOS.

Next, log in to GitHub and store the public the key under SSH (New) key text box. Use this path: Settings->SSH and GPG keys

Now that you have securely connected two remote machines, let’s invoke and solve the error fatal: could not read from remote repository.

ALSO READ: git tag usage explained for beginners [Easy Examples]

Source~1: Pushing to non-existing remote

Despite authenticating the local machine, Git and GitHub may fail to understand each other if you attempt to push to a remote repository that does not exist.

Let’s build a local repository and attempt to push the changes to a non-existing remote.

Steps

steve@thisHostname:~$ mkdir test_repo && cd test_repo
steve@thisHostname:~/test_repo$ git init
Initialized empty Git repository in /home/steve/test_repo/.git/

steve@thisHostname:~/test_repo$ cat >> example.py
print('Hello world')
steve@thisHostname:~/test_repo$ git status
On branch main
​
No commits yet
​
Untracked files:
  (use "git add <file>..." to include in what will be committed)
    example.py
​
nothing added to commit but untracked files present (use "git add" to track)

steve@thisHostname:~/test_repo$ git add .

steve@thisHostname:~/test_repo$ git commit -m "Testing 1, 2, 3"
[main (root-commit) aae3b47] Testing 1, 2, 3
 1 file changed, 1 insertion(+)
 create mode 100644 example.py
steve@thisHostname:~/test_repo$ git log
commit aae3b47090a9fc9cc561fee37fd3077864fe573b (HEAD -> main)
Author: Stevealila <stevealila25@gmail.com>
Date:   Tue Feb 7 10:43:37 2023 +0300
​
    Testing 1, 2, 3
​

We create test_repo directory and convert it to a Git repository using the git init command. We then create example.py file in the working directory before staging and committing the changes.

Problem

Two errors pop up on attempting to push changes to an unknown remote. One of the errors is fatal: Could not read from remote repository.

steve@thisHostname:~/test_repo$ git push origin main
fatal: 'origin' does not appear to be a git repository
fatal: Could not read from remote repository.
​
Please make sure you have the correct access rights
and the repository exists.
​

Solved

The solution is to create the repo

and set its URL as the local repository’s remote URL.

steve@thisHostname:~/test_repo$ git remote add origin https://github.com/Stevealila/test_repo.git
steve@thisHostname:~/test_repo$ git remote set-url origin git@github.com:Stevealila/test_repo.git
steve@thisHostname:~/test_repo$ git push origin main
Enumerating objects: 3, done.
Counting objects: 100% (3/3), done.
Writing objects: 100% (3/3), 237 bytes | 237.00 KiB/s, done.
Total 3 (delta 0), reused 0 (delta 0), pack-reused 0
To github.com:Stevealila/test_repo.git
 * [new branch]      main -> main
​

Now the connection goes through after adding or setting the remote connection.

ALSO READ: Git rename branch — local and remote (PROPERLY)

Source~2: Incorrectly linking through SSH keys

You may also get the error when you fail to connect the machines with the SSH keys correctly.

For example, you could be pushing to or cloning from the remote after connecting the machines with SSH for the first time.

The (local) machine asks, «Are you sure you want to continue connecting (yes/no/[fingerprint])?» You should input ‘yes’ followed by clicking the enter key. If you input ‘no’ or leave it blank, the connection fails and throws the error fatal: could not read from remote repository.

Problem

steve@thisHostname:~$ git clone git@github.com:Stevealila/Python.git pyFiles
Cloning into 'pyFiles'...
The authenticity of host 'github.com (140.82.121.4)' can't be established.
ED25519 key fingerprint is SHA256:+DiY3wvvV6TuJJhbpZisF/zLDA0zPMSvHdkr4UvCOqU.
​
This key is not known by any other names
Are you sure you want to continue connecting (yes/no/[fingerprint])? 
Host key verification failed.
fatal: Could not read from remote repository.
​
Please make sure you have the correct access rights
and the repository exists.

solved

steve@thisHostname:~$ git clone git@github.com:Stevealila/Python.git pyFiles
Cloning into 'pyFiles'...
The authenticity of host 'github.com (140.82.121.4)' can't be established.
ED25519 key fingerprint is SHA256:+DiY3wvvV6TuJJhbpZisF/zLDA0zPMSvHdkr4UvCOqU.
This key is not known by any other names
Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
Warning: Permanently added 'github.com' (ED25519) to the list of known hosts.
remote: Enumerating objects: 10, done.
remote: Counting objects: 100% (10/10), done.
remote: Compressing objects: 100% (6/6), done.
remote: Total 10 (delta 0), reused 4 (delta 0), pack-reused 0
Receiving objects: 100% (10/10), done.

The pull process goes through after we type ‘yes’.

Conclusion

You just learned the main causes of the error fatal: could not read from remote repository and how to solve them. Now it is your turn to apply the knowledge.

Fatal: could not read from remote repository. is a Git error message when it fails to connect to your “remote repository” due to a configuration error on your local machine. This article will explain what’s wrong with your compiler and how you can connect to your remote repository.

While you go through this article, you’ll learn more about Git and how it works behind the scenes. Now, you’ll need your terminal or command prompt to follow along, so launch either and let’s restore your connection.

Why Git Cannot Read From Your Remote Repository?

Git cannot read from your remote repository because your SSH key was removed from the SSH agent, or the remote URL is SSH in the Git configuration file. Other causes include a mismatch of your local and remote SSH keys, network access problems, or your SSH agent is not running.

The following can also prevent Git from reading from your remote repository:

• Mismatch of the local and remote SSH key
• You did not specify the remote URL location

– Your SSH Key Was Removed From the SSH Agent

If you’re connecting to your “Git repository” and your “SSH key” was removed from the SSH agent, Git cannot read from your remote repository. As a result, you’ll get an error because this key allows you to authenticate to the repository without typing your password every time.

So without it, the server hosting the remote repository cannot verify your identity during the connection, and like every system, it will stop you. Factors that can remove your SSH key from the agent include the following:

• Explicit removal using the “ssh-add -D” command.
• Manual deletion of the key file.
• Another program deleted the key without your knowledge.

– Your Remote URL Is SSH in the Configuration File

When the remote URL is SSH in the configuration file (“.git/config”), Git cannot connect to your remote repository if the repository owner did not configure SSH access. So, when you try any “git” operations like “git push”, the communication with the remote repository will break down because there is no medium to continue.

For example, the value of the “url” in the following indicates that you’ll like to connect to a GitHub repository using SSH. But you’ll get an error message that includes “access rights”, “correct access” if you did not configure SSH on your repository:

url = git@github.com:your_github_username/your_github_repository.git

– Another Program Is Using the git_SSH Environment Variable

When another computer program on your computer is using the GIT_SSH environment variable, Git will show you an error if you want to read from a remote repository. This type of situation occurs when Cygwin is your preferred terminal environment, and it works fine with SSH.

However, you installed Git on your Windows computer, and this Git installer changed the GIT_SSH variable to “Plink.exe”. The latter is the “PuTTY link” command line tool that will not work with SSH unless you configure it for SSH.

Now, this leads to a conflict on your computer because “Plink.exe” is now using the GIT_SSH variable that’s meant for your configured SSH client in Cygwin. As a result, your SSH client can’t use this environment variable for SSH connections, and you’ll get an error if you initiate an operation that will use SSH.

– Your SSH Agent Is Not Running

The SSH agent is “ssh-agent,” and if it’s not running, you cannot initiate any SSH connection to your remote repository. Here is why: this agent will store your SSH private key that’ll allow you to connect to your remote repository that’s configured for SSH connections. Now, if the agent is not running, you’ve lost the authentication link between your computer and the remote repository. So, when you try a “git push” or “git pull” operation, Git will show an error that it can’t read from your remote repository.

– Network Access Problems on Your Computer

Network access problems on your computer can cause a breakdown of communications between your computer and your remote repository. Your work environment can have network policies in place that can disrupt your Git operations in the name of security.

This can include the use of proxy servers that can decrypt your web traffic while it flows from your computer to the remote repository. The time frame for this operation by the proxy server can prevent Git from reading from your remote repository.

– Mismatch of the Local and Remote SSH Key

The SSH keys on your local machine and your remote repository should be the same for any successful SSH connection. If there is a mismatch (or the key does not exist at all), your Git client will not connect if you’ve configured it for SSH connections.

That’s because the standard way to connect via SSH is to create the key on your computer and upload the same key to your remote repository. Now, if the keys are different, the server that’s hosting your remote Git repository will show a “fatal cannot read error” for your incoming Git operations.

– You Did Not Specify the Remote URL Location

A remote URL location is where you’ll push and pull code from and if you don’t set it, the Git client will have no idea where you want to send your code. As a result, if you try to push your code from your local machine, you’ll get the “fatal read” error. For GitHub, it supports SSH URL and HTTPS URL for remote URL locations, but you’ll get an “correct access rights” error if you don’t set either on your local machine.

How Git Can Read From Your Remote Repository

Git can read from your remote repository if you add your SSH key to your SSH agent, update the remote URL in the configuration file, or remove the GIT_SSH environment variable. Starting your SSH agent or accessing the remote repository using a VPN also works.



Finally, you can update the remote SSH keys or set a remote URL for “git push” operations.

– Add Your SSH Key to Your SSH Agent

The addition of your SSH key to your SSH agent will allow your Git client to connect to your remote repository, and it also prevents the “fatal read error” when you do a “git push”. To add your SSH key to the SSH agent, do the following:

1. Open your terminal on Linux
2. Start the SSH agent using the following command: eval ssh-agent -s
3. Use “exec ssh-agent XXXX” on CentOS where XXXX is the name of your shell environment. For example: “exec ssh-agent fish”
4. Hit enter on your keyboard.
5. Type the following to add your SSH key: ssh-add ~/.ssh/id_rsa
6. Press enter on your keyboard to add the key.
7. Try your Git operations, and it should work.

If you’re on a Windows computer, do the following instead:

1. Download Git Bash from their official website.
2. Type and run the following: eval $(ssh-agent)
3. Use the following if the previous command does not work: eval “$(ssh-agent -s)”

– Update the Remote URL in the Configuration File

If you don’t have SSH configured on the remote repository, you should update the URL in the configuration file to HTTPS. You can change your remote URL to HTTPS using the following steps:

1. Open your terminal.
2. Navigate to your project folder
3. List the remote URLs using the following: git remote -v
4. Note the name of the remote URLs from the previous command.
5. Change the remote URL from Secure Socket Shell (SSH) to HTTPS using the following: git remote set-url origin https://github.com/your_GitHub_username/the_name_of_the_Git_repository.git
6. Confirm the changes using the following: git remote -v
7. Try your Git operations, and it should work.

Meanwhile, if you don’t want to use the command line, you can do the following to get the same results:

1. Open the Git configuration file (“.git/config”). On Windows, it’s a hidden file, and you’ll have to show hidden files via the control panel.
2. Change the value of the “url” from something like “git@github.com:your_GitHub_username/the_name_of_the_Git_repository.git” to “https://github.com/your_GitHub_username/the_name_of_the_Git_repository.git”

– Remove git_SSH Environment Variable

The removal of the GIT_SSH environment variable will prevent the “fatal” read error if your environment is Cygwin and another program is interfering. To remove the GIT_SSH environment variable, do the following:

1. Open your terminal or command prompt.
2. Type and run the following command: unset GIT_SSH
3. Restart your Git client and restart your computer.
4. Try a Git operation like “git push” in Cygwin, and it should work.

– Start Your SSH Agent

Your SSH agent is the most important thing when working with the remote repository that’s configured for SSH access. To start your SSH agent, do the following:

1. Open your terminal.
2. Type and run the following: eval ssh-agent -s
3. Try your Git operations and if you get an error, add your SSH key using the “ssh-add” program.

Please note, start the agent using the “eval” as we did above. If you don’t, Git will complain that it cannot connect to your authentication agent. That’s because using “eval” to start the agent will create an environment variable that allows SSH to find the SSH agent. However, if you start the agent as “ssh-agent”, it will start, but SSH will not find it.

– Access the Remote Repository Using a Vpn

If you’re in a corporate environment and you’re getting the “fatal cannot read from remote repository” error, setup a Virtual Private Network (VPN). With a VPN running on your computer, your computer traffic will go through it and connect to your GitHub repository.

– Update the Remote SSH Key

When you update the remote SSH key to match that on your local machine, Git will connect via SSH without an error. To do this update, do the following:

1. Open your terminal.
2. Type the following and replace “your_email_id@host.com” with your real email address: ssh-keygen -t rsa -C “your_email_id@host.com”.
3. Copy the generated RSA “public key” using the following command: cat ~/.ssh/id_rsa.pub
4. Go to your remote Git repository and paste the key. For GitHub, continue with the next steps.
5. Log in to your GitHub account.
6. Click your profile picture in the top-right corner and click on “Settings”.
7. Click on SSH and GPG keys in the “Access” section.
8. Click on “Add SSH key” and add a descriptive label for the new key.
9. Select the purpose of the key.
10. Paste the key that you copied from your computer and click on “Add SSH key”.

– Set a Remote URL for Git Push Operations

Before you can push to your remote repository, you need to set up a remote URL for the operation. There are methods that you can use, and the following steps detail the first method:

1. Open your terminal. On Windows, install GitBash.
2. Switch to your project directory using the terminal.
3. Type and run the following command: git remote set-url origin https://github.com/your_GitHub_username/your_GitHub_repository.git

The following steps detail the second method, and it’s a modification of the Git’s configuration file:

1. Open your terminal. On Windows, install GitBash.
2. Switch to your project directory using the terminal.
3. Move to the “.git” subdirectory.
4. Open the “config” file in your code editor.

Paste the following in the “config” file: [remote “origin”]

url = https://github.com/your_GitHub_username/your_GitHub_repository.git

1. fetch = +refs/heads/:refs/remotes/origin/

Conclusion

This article explained why Git could not read from your remote repository and what you can do to fix it. From our entire discussion, remember the following:

• If your SSH key is missing from the SSH agent, Git cannot read from your remote repository.
• When the SSH agent is not running, an attempt to connect to your remote Git repository using SSH will result in the “fatal read” error.
• You can fix the “fatal could not read from remote repository” error if you add your SSH key to your SSH agent or you switch to HTTPS in the Git configuration file.

Now, you know what it takes to connect to Git without a “fatal” or “permission denied” error. Share our article with your fellow developers and tell them about our site.

Before pushing content to the GitHub repository or pulling remote content to the local directory, it is required to connect the local machine with the remote server. If the repositories are not connected or provide a wrong URL, developers often encounter a “fatal: Could not read from remote repository” error.

This study will provide the solution of fixing the “git fatal” error.

To fix the above-stated error, first, navigate to the local repository and check the remote URL list. If the remote is not added, then open GitHub, move to the required repository, and copy its “HTTP” URL. Finally, add the copied URL to the list and connect the remote repository with the local repository using the “git remote add <remote> <URL>” command.

Step 1: Switch to Required Directory

First, type out the below-provided command and redirect to the local repository:

 
Step 2: Create File

Then, utilize the “touch” command to generate an empty file:

 

Step 3: Stage Changes

Track newly added changes to the staging index with the help of the “git add” command:

 

Step 4: Commit Changes

Next, run the following command to save the staging index changes:

$ git commit -m «New file added»

 

Step 5: Fetch Remote Origin

Then, download the content of the GitHub repository in the local repository using the below-stated command:

 

Note: It can be seen that there is an error, and the “origin” could not get fetched. So, to resolve this issue, follow the next steps.

Step 6: List Remote URL

Verify whether the local repository is connected to the remote server or not:

 
The below output indicates that the remote repository has not been connected to the local repository:

Step 7: Copy Remote URL

Open GitHub, choose a particular remote repository, and copy its “HTTPS” URL:

Step 8: Add Remote URL

Now, run the following command to link both repositories, such as remote and local:

$ git remote add origin https://github.com/laibayounas/newRepo.git

 

Step 9: Verify Added Remote URL

To ensure whether the remote URL has been added or not, use the following command:

 

Step 10: Fetch Remote Origin

Lastly, fetch the remote server content again to the Git local repository:

 
In the screenshot below, it can be observed that the remote content has been successfully downloaded to the local repository:

That’s all! We have provided the easiest solution for fixing the above-stated error.

Conclusion

In order to fix the “git: fatal: Could not read from remote repository” error, first, redirect to the local repository and check whether it is connected to the remote repository. If the remote URL is not added, then open GitHub, move to the desired remote repository, and copy its HTTP URL. Lastly, run the “git remote add <remote> <URL>” command to set the remote URL. This study explained the solution for the “git fatal” error.

About the author

I have done bachelors in Computer Science. Being passionate about learning new technologies, I am interested in exploring different programming languages and sharing my experience with the world.