Recently I was in France with a colleague at an event organized by ETSI. In that occasion we needed to work on some code, but for some reasons we couldn’t use the company remote repositories.
Manually merging changes to a local copy we had was a time consuming and inefficient task, so I quickly set up a git repository on my machine that my colleague could access through the local network. Having a reference to do that operation in a short time may be very useful in situations similar to that one, but version tracking may be essential as well when working on personal projects or sketching code for new ideas. Setting up a git server is also a good idea to recycle some old hardware (I used to have an old notebook which worked as a printing server and git repository on my home network).
The following tutorial summarizes the steps required to setup a SSH server, use RSA keys, authorize users, and create a new git repository. This reference is first of all useful for me, but I hope that someone else will take advantage of this yet-another-git-setup-tutorial :).
There are many different ways of setting up a git repository. This tutorial shows a possible way for doing this quickly. Do not use this tutorial to set up a git repository in a production environment, where every configuration parameter (e.g.: for the SSH server) must be finely tuned and well understood.
Intended audience and assumptions
If you need to setup a git repository for personal use or for some reasons you don’t want to use a cloud service such as github, then this guide may help you. The steps here described will allow for the quick setup and use of a git repository on top of a fresh installation of an Ubuntu GNU/Linux distribution (I am using Ubuntu 12.10).
I assume that a git repository is created on the local machine inside the home folder of a new “git” user. In a more general configuration, where the git client and server are remote machines, you will just need to replace the loopback 127.0.0.1 address with the one of the server.
Some basic knowledge of the Unix command line interface is required.
SSH Server configuration
The machine that will host the git repository needs to be accessed by clients. A possible way to access a machine remotely is through SSH.
SSH supports both password and public/private keys authentication. In this tutorial I will use RSA keys.
Install and configure an SSH server on the machine that will host the git repository:
sudo apt-get install openssh-server
Edit the /etc/ssh/sshd_config file to tweak the SSH server settings at your preference. I generally disable Password Authentication (you may need to uncomment the line) and Challenge Response Authentication:
# Change to yes to enable challenge-response passwords (beware issues with # some PAM modules and threads) ChallengeResponseAuthentication no # Change to no to disable tunnelled clear text passwords PasswordAuthentication no
Start or restart the ssh daemon to accept the new configuration:
sudo /etc/init.d/ssh restart
Authorized Keys configuration
The public keys of the authorized entities who can login through ssh must be collected in the authorized_keys file under the ~/.ssh folder.
Create a git user on the machine that will host the repository (handle this as you prefer, it is not required to create a new user, but much cleaner):
sudo adduser git
Login as the git user, if you are on the same machine, just use
to change to git user, then cd to the home directory
Create a .ssh folder and set its permissions (see the ssh man (1) page for explanations on permissions of the .ssh folder and its content):
mkdir .ssh chmod 700 .ssh
Create an authorized_keys file under the ~/.ssh folder and append to it the public keys of the authorized git users:
A possible way to populate the authorized_keys file, from a user on the same machine as the “git” user would be (appends the public key of the current user at the end of the authorized_keys file of the “git” user, command issued from the home directory):
sudo bash -c "cat .ssh/id_rsa.pub >> ../git/.ssh/authorized_keys"
Set the proper permissions for the authorized_keys file:
chmod 600 .ssh/authorized_keys
Create a new git repository
Install git (if needed):
sudo apt-get install git
Initialize an empty git repository (I assume repositories are created in the home folder of the git user):
mkdir test_repo.git cd test_repo.git git init --bare
The server configuration is done.
Setup RSA keys on the client
The remaining part of the tutorial refers to operations to be done on the client who wants to access the git repository that we have prepared. In order to use the Secure SHell connection, the client needs a pair of public/private keys.
If you already have RSA keys, put them in ~/.ssh, otherwise you can create a new pair with:
ssh-keygen -t rsa -C "Comment Here (usually your email)"
Move the pair of generated keys (id_rsa and id_rsa.pub) into ~/.ssh
See the FILES section of the SSH man (1) page to set the proper permission to the ~/.ssh folder and its content. In a typical configuration, you may want to use:
chmod 700 .ssh/ chmod 400 .ssh/id_rsa chmod 400 .ssh/id_rsa.pub
Clone the git repository
Set the git user global configuration:
git config --global user.name "Your Name" git config --global user.email email@example.com
Create a new folder where you want to clone the repository, cd into that folder and initialize git:
mkdir foo cd foo git init
Configure the git client to access the test_repo.git repository (add the pointer to a remote called origin):
git remote add origin ssh://firstname.lastname@example.org/~/test_repo.git
Clone the repository (if someone has already committed some changes):
git clone ssh://email@example.com/~/test_repo.git
Create a new file and upload to the repository:
echo "Hello" > readme.txt git add readme.txt git commit -m "First commit"
Push the committed changes to the master branch:
git push origin master