Connecting a local Git repository to GitHub allows you to synchronize your local project with a remote repository. After the connection is created, you can push your commits to GitHub and retrieve changes from the remote repository.
origin. You can connect a local repository to GitHub using
the Git remote command.
A local Git repository exists on your computer. A GitHub repository exists on a remote server. Connecting them creates a remote reference between the two repositories.
Local Git Repository
↓
origin
↓
GitHub RepositoryConnecting your local repository to GitHub allows you to work with a remote copy of your project.
Before connecting a local project to GitHub, you normally need:
First, verify that Git is installed:
git --versionExample output:
git version 2.x.xThe exact version depends on the Git installation on your computer.
Open the terminal or Git Bash and move into your project directory.
cd my-projectYou can verify the current location using:
pwdIf the project is not already a Git repository, initialize it:
git init
This creates the .git directory and turns the project
folder into a Git repository.
After initializing Git, check the repository:
git statusThis shows the current branch and the state of your project files.
Before committing project files, create a suitable
.gitignore file when necessary.
For example:
.env
node_modules/
*.logThis helps prevent files that should not be tracked from being added to the repository.
Add the project files to the staging area:
git add .You can check the staged files with:
git statusCreate a commit containing the staged project files:
git commit -m "Initial project"The commit creates a saved point in the local Git history.
Create a repository on GitHub for the local project.
For an existing local project, it is often convenient to create the remote repository without adding files that would conflict with the existing local history.
After creating the GitHub repository, copy its repository URL.
HTTPS example:
https://github.com/username/my-project.gitSSH example:
git@github.com:username/my-project.git
Use git remote add to connect the local repository:
git remote add origin https://github.com/username/my-project.gitHere:
origin is the remote name.Verify that the remote was added correctly:
git remote -vExample:
origin https://github.com/username/my-project.git (fetch)
origin https://github.com/username/my-project.git (push)Check which branch you are currently using:
git branch
If your branch is named main, you can push it using:
git push -u origin main
If your local branch has another name and you want to use
main, you can rename it:
git branch -M mainThen push it to GitHub:
git push -u origin main
The following command pushes the local main branch to
GitHub:
git push -u origin main
The -u option sets the upstream relationship between the
local branch and the remote branch.
After the upstream relationship has been configured, future changes can commonly be pushed using:
git pushA typical workflow is:
git add .
git commit -m "Update project"
git pushIf the remote repository has changes that you need locally, you can retrieve and integrate them with:
git pull origin mainIf the upstream branch is configured, you can often use:
git pullYou can download information from GitHub without directly integrating the changes into your current branch:
git fetch originAfter fetching, you can inspect the remote-tracking branches before deciding how to integrate the changes.
An HTTPS remote commonly looks like:
https://github.com/username/project.gitHTTPS is one way to configure Git operations with a GitHub repository. The authentication process depends on GitHub's current authentication requirements and your local credential configuration.
An SSH remote commonly looks like:
git@github.com:username/project.gitSSH can be used for Git authentication after an SSH key has been properly configured with GitHub.
If the remote URL is incorrect, you can change it:
git remote set-url origin https://github.com/username/new-project.gitThen verify the new URL:
git remote -vA local repository can have more than one remote.
git remote add origin https://github.com/user/my-project.git
git remote add upstream https://github.com/company/my-project.gitThis can be useful when working with a fork and an original project repository.
When pushing to GitHub, GitHub must be able to authenticate the Git operation.
Depending on your setup, this may involve credential management, authentication through HTTPS, or SSH keys.
Common problems when connecting a local repository to GitHub include:
Use commands such as git remote -v,
git status, and git branch to inspect the
local configuration.
cd my-project
git init
git add .
git commit -m "Initial project"
git branch -M main
git remote add origin https://github.com/username/my-project.git
git remote -v
git push -u origin mainThis is a common sequence for publishing an existing local project to a newly created GitHub repository.
git pull
# Make changes
git status
git add .
git commit -m "Update project"
git pushThis workflow can be used to retrieve remote changes, make local changes, commit them, and push the new commit to GitHub.
git init if necessary.git status.git remote add origin URL.git remote -v.Connecting a local Git repository to GitHub creates a remote relationship that allows your project to communicate with the GitHub repository.
Local Project
↓
git init
↓
git commit
↓
git remote add origin URL
↓
git push
↓
GitHubThe most important command for creating the connection is:
git remote add origin https://github.com/username/project.gitgit init initializes a local Git repository.git add . stages project files.git commit records changes in local Git history.git remote add origin URL adds the GitHub remote.git remote -v verifies the configured remote URL.git branch -M main can rename the current branch to main.git push -u origin main pushes the first main branch and sets upstream tracking.git push can be used for later pushes after upstream tracking is configured.git pull retrieves and integrates remote changes.git fetch retrieves remote information without directly integrating it.Question: Which command connects a local Git repository to a GitHub repository using the remote name origin?