Open In App
Related Articles

What is Git Push?

Like Article
Save Article
Report issue

Pre-requisite: Git

Using the git push command, you can upload your files available on your local machine to the remote repository. After git pushes the changes to the remote repository other developers can access the changes and they can contribute their changes by git pulling. Before pushing it to the remote repository you need to do a git commit to your local machine. 

Git Push Command 

Git push allows us to transfer files from the local repository to remote repository hosting services like GitHub, GitLab, etc. Other developers who want to work on the files can access them after being uploaded to a remote repository.

Git push


In the above diagram, we can observe If our local main branch is way back when compared to the central main repository after that git push origin main will publish the changes. git push is essential as same as the git merge.

git push <remote> <branch>
  1. The <remote>  option refers to the remote repository to which you want to push your files it will refer to its alias name where the name is mapped with the remote repository URL 
  2. The <branch> option represents the branch of the GitHub repository which you want to push.

Git Push Jenkins

Once you push your code to a remote repository Jenkins will automatically get triggered. This will happen because of the configuration of any feature in GitHub, like periodically build, poll scm, and webhooks. Here are some sample steps to git push Jenkins.

Step 1: First commit the code to the local repository and push the code into the remote repository by using the following command.

git push <Alias name of remote 
repository URL> and <branch name>

Step 2: Configure Jenkins in Git Hub by using WebHooks or any other feature. Whenever a new commit will happens in GitHub Jenkins build will automatically get triggered. To know more about how to integrate Jenkins with git you can refer to  Jenkins and git integration.

Git Push Force To Central Repository

Force pushing is not a good practice it involves the risk of overwriting the existing repositories with the currently pushing repository. It will cause data loss and raise conflicts with other developers’ work. Only in specific circumstances, such as when you need to delete or rewrite a string of commits that have already been sent to the remote repository, should you have to do a git force push. Here are the steps for force pushing: 

Step 1: Commit changes.

You need to commit all the changes to the local repository. Before force-pushing it to the remote repository for that you can use the below command.

git commit -m "Commit messege"

Step  2: Fetch and Rebase. 

Fetch the remote repository before force pushing by this we can ensure that the latest version of the repository is available, After fetching is completed rebase the local changes on top of the remote changes.

Fetch the repository.

git fetch <Repository URL or Alias name of Repository>

Rebase the changes.

git rebase <Alias name and Branch>

Step 3:git force push changes.

Once the fetching and rebasing are done, now you are ready to git force push to the remote repository. By using the following command we can do that.

git push --force <Alias name od repository> <branch name> 

Note: Instead of using “–force” you can also use the short form “-f “

Git Push And Syncing

With the help of git, more developers can work on a single project. Where they can contribute their changes  After they have done their contribution now they can push the changes to the remote repository from which other developers can pull that repository and be in sync.

Following are the steps to synchronize with changes that have been done:

Step 1: Commit to the local repository.

Before pushing it remote repository make the changes that you have done are correct and commit them to your local repository. After that, you can push the changes to the remote repository.

Step 2: Push changes to the remote repository.

After committing the changes that you have made to the repository. With the help of the subsequent command, you may now push the repository to the remote repository.  Together with the branch name, specify the name of the remote repository you want to push to.

git push <Alias name> <branch-name>

Step 3: Pull changes from the remote repository.

Git pull is vice-versa of Git push instead of pushing we will pull the remote repository and you can stay updated on the changes of others done.

git pull

Step 4: Resolve conflicts.

Git will remind you to resolve any conflicts between your modifications and those made by other collaborators if there are any. To fix the conflicts, you can manually change the conflicting files or utilize a merge tool.

Step 5: Re-push modifications to the remote repository.

You can push your modifications back to the remote repository after resolving the conflicts. By using the following command.

git push

By following the steps mentioned above by push and pull you can be synchronized with other collaborators.

Pushing To Bare Repositories

The only one which doesn’t consist of any particular working directory. The bare repository can be used by developers as a central repository in which they can push their changes and pull the updates. The bare repository only contains metadata and git objects.

Following are the steps to push into the bare repository:

Step 1: Create a bare repository.

The following command will help you to create a bare repository without a working directory.

git init --bare <directory>

Step 2: Clone the repository.

Clone the bare repository to the local machine. By using the following command.

git clone

Step 3: Make changes and Commit the changes.

After completion of cloning the repository know you can work on the changes required. After completion of working on your changes know you commit the changes to your local by using the following command.

git commit -m "Commit message"

Step 4: Push the changes.

After committing the changes to your local machine. Now it is time to push them to the bare repository by using the following command.

git push <Alias name of remote repository>  <Branch name>

By pushing the local repository to the central repository you are making it available for other developers who need to work on it.

Amended Force Push

Amended force push is a combination of commit and force push it will update the last commit and it will force push it to the remote repository. 

Following are the steps to perform Amended Force Push:

Step 1: Commit changes.

Commit the changes that you have done to the local repository by using amend option it will amend the most commit.

git commit --amend -m "New commit message"

Step 2: Force-push the amended commit.

Know Force pushes the local repository to the remote repository to make it available for others by using the following command.

git push --force-with-lease <Alias name> <Branch name> 

using  “–force-with-lease”  will force push only if the remote branch’s current commit matches the expected commit. It will prevent accidental overwriting of others’ changes.

Git Push Usage

Let’s say you developed a feature, and for that, you make changes in the local repository, now you may use the push command for uploading these changes to the remote repository like GitHub, so other team members and coordinators can see it and update their project work. The command is: 

git push <remote> <branch>

There is more add up to these, and these are:

  • git push <remote> –force: This command forces the push even if it results in a non-fast-forward merge.
  • git push <remote> –all: This command pushes all the local branches to the specified remote repo.

A simple way of using the push command should be:

git push -u origin master

Here git push is the command, -u is a flag and used to set origin as the upstream remote in the git config, the origin is the default name of your remote repository you can replace it with whatever name you want, you can use your repo name instead of origin. And the master is the branch name. Now if you execute git push -u origin master you will get an error, ‘origin’ does not appear to be a git repository because we don’t have a remote repository at this point in time. So, let’s create a remote repository on GitHub with the name Crio. This is an empty repo at now.

Create a new Repository.


To add this repo project to your GitHub account, use the git remote add command on the terminal, in the directory where your repository is currently stored at.

git remote add <remote-name><remote URL>

This command takes two arguments:

  1. A remote name, let’s say for example, “Origin”
  2. A remote URL, which is your repo address as shown below.


Now you can run the git remote add command and git push command to push your code work to your repository.

git remote add


We used crio here in place of origin which is the repo name coz we assign an origin to another repo and if you assign an origin to a certain repo, you cannot use it again.

git repository in GitHub


Now, the code is successfully pushed to the repository.

Last Updated : 15 May, 2023
Like Article
Save Article
Share your thoughts in the comments
Similar Reads