Criando um servidor GIT

gistfile1.txt

Referencias
https://blog.pantuza.com/tutoriais/criando-um-servidor-git

O git é uma ferramenta de linha de comandos para fazer controle de versões de código. Existem alguns sites na web, como o Github, que utilizam o git para criar uma serviço de gestão de projetos de código.  Se você tem uma empresa, ou um laboratório de universidade e precisa ter um repositório Git remote ao qual uma equipe ou diversos colaboradores precisam enviar código, esse tutorial irá te ajudar a habilitar um servidor Git remoto.
Caso goste de interfaces gráficas, uma alternativa seria configurar o Gitlab em sua empresa ou laboratório. Essa ferramenta é mais amigável e preparada para controlar o projeto com interações mais humanas. Esse tutorial irá habilitar apenas a interação via linha de comando utilizando o utilitário git.
Vamos dividir nosso tutorial em duas partes. A primeira será o nosso servidor. A segunda será o nosso cliente. Essa última se aplica a todos os usuários que desejam fazer uso do serviço.

SERVIDOR
Vamos começar assumindo que o seu servidor já possui o git instalado, certo? A primeira coisa que precisamos fazer no servidor é criar um usuário chamado git que será o proprietário dos nosso repositórios. Na prática, poderia ser qualquer usuário, mas pra não ter que criar um usuário, no servidor, para cada cliente, é interessante usar o usuário git. Para criar esse usuário utilizamos o comando useradd:

# Creates the git user
sudo useradd --comment "Git user" --home-dir /home/git --groups users --shell $(which git-shell) git

Vale comentar que nesse exemplo o grupo do nosso usuário git é users. Esse grupo é o grupo padrão para a distribuição OpenSUSE. Caso seu servidor seja de outra distribuição coloque o respectivo grupo. Caso não saiba qual é esse grupo, verifique o do seu usuário e utilize-o. 
Outro ponto importante nesse comando é a opção --shell sendo atribuída ao utilitário git-shell. Fazemos isso para proibir o usuário git de se logar no nosso servidor. Ele somente consegue executar operações do programa git. Nada além disso. Isso garante que mesmo que um hacker roube a senha desse usuário ele jamais ganharia um shell no servidor. 
Usuário criado, vamos criar o diretório home dele e dar as devidas permissões.

# Creates home directory for git user
sudo mkdir -p /home/git

# Give directory permissions to git user
sudo chown -R git:users /home/git

Criadas as permissões, vamos criar uma senha para o usuário git. Para isso iremos utilizar o comando passwd. Esse comando irá lhe pedir via prompt de comandos a nova senha:

# Set git user password
sudo passwd git

O programa git, utiliza internamente alguns protocolos para se comunicar com o servidor. Sua máquina cliente quando executa, por exemplo, um git clone git@github.com:pantuza/panfiles.git, ele está utilizando o protocolo ssh para clonar um repositório remoto. O protocolo HTTP também pode ser utilizado, mas não necessariamente essa comunicação estaria criptografada, autenticada e autorizada. O próprio Github assim como nosso servidor, preferencialmente, irão utilizar o protocolo ssh. 
Para tal, vamos então configurar o ssh do nosso servidor. O processo sshd é um deamon em nosso servidor com a responsabilidade de receber as conexões vindas das máquinas clientes e garantir que esteja m devidamente autorizadas a logar na máquina. Para configurá-lo, vamos editar o arquivo /etc/ssh/sshd_config. Nesse arquivo existe uma instrução chamada AllowUsers. Ele define quais usuários estão permitidos a se logar através do ssh. Iremos adicionar o usuário git a essa configuração:

# Authentication:
#LoginGraceTime 2m
#PermitRootLogin yes
#StrictModes yes
#MaxAuthTries 6
#MaxSessions 10
AllowUsers root git

Adicionada essa configuração, deve-se reiniciar o serviço no sistema operacional para que as modificações tenham efeito. Cada distribuição adota um gerenciador de serviços. A seguir são mostrados algumas formas de se reiniciar o ssh através do System D, do System V ou com o utilitário service:

# System D
sudo systemctl restart sshd.service

# System V
sudo /etc/init.d/sshd restart

# Service
sudo service sshd restart

Finalizada nossas configurações do servidor ssh. Isso já é suficiente para algum usuário fazer  git push e subir código para nosso servidor. No entanto, toda vez será necessário digitar a senha do usuário git. Nós não queremos isso. Temos então, que criar uma pasta e um arquivo dentro do diretório raiz de nosso usuário git para que o ssh possa controlar esse acesso sem senha. Para permiti-lo o ssh faz uso de chaves públicas e privadas. O arquivo que criaremos irá controlar as chaves dos usuário autorizados a acessar e modificar os repositórios. Abaixo vemos como fazê-lo:

# Creates ssh directory for user git
sudo mkdir -p /home/git/.ssh/

# Give git user permissions on directory
sudo chown -R git:users /home/git/.ssh

# Change directory permissions
sudo chmod 700 /home/git/.ssh

# Creates the authorized_keys file
sudo touch /home/git/.ssh/authorized_keys

# Give git user permissions on file
sudo chown -R git:users /home/git/.ssh/authorized_keys

# Change permission of the authorized_keys file
sudo chmod 600 /home/git/.ssh/authorized_keys

Além de criarmos o diretório .ssh e o arquivo authorized_keys, demos as devidas permissões a eles. Pronto! A partir daqui temos tudo configurado para que nossos usuário possam contribuir nos repositórios remotos.

CLIENTE
Vamos configurar agora nosso cliente para poder comunicar-se com o servidor git através do ssh. Basta criar nossa chave pública e privada na máquina local e entregar a chave pública para que o servidor possa armazená-la no arquivo authorized_keys que criamos. 
Antes de criar as chaves, é legal conferir se o servidor está corretamente configurado com o ssh. Vamos tentar logar no servidor com o usuário git:

$> ssh git@domain-server.com
git@domain-server.com's password: 
Last login: Fri Jun 30 20:24:10 2017 from 192.168.22.68
openSUSE Leap 42.1 x86-64

As "root" use the:
  - zypper command for package management
  - yast command for configuration management

Have a lot of fun... 
fatal: Interactive git shell is not enabled.
hint: ~/git-shell-commands should exist and have read and execute access.
Connection to domain-server.com closed.

Como pode ser visto, o login foi feito, mas o usuário não ganhou shell no servidor. Nosso servidor ssh está OK. Vamos criar nossas chaves pública e privada. Para isso utilizamos o utilitário ssh chamado ssh-keygen. Com ele vamos criar chaves RSA:

# Create ssh keys using RSA criptograph
ssh-keygen -t rsa -b 4096 -C your.name@mailserver.com

Esse comando irá gerar dois arquivo dentro do diretório /home/user/.ssh. Por padrão, esses arquivos irão chamar id_rsa.pub e id_rsa, mas eles podem ter outros nomes. Vamos copiar então o conteúdo do arquivo id_rsa.pub para o servidor e colocá-lo no final do arquivo /home/git/.ssh/authorized_keys.

# Copy local public key to remote server with a user that has shell
scp /home/local-user/.ssh/id_rsa.pub user-with-shell@remote-server.com:/home/user-with-shell/

# Appends the public key to git user authorized_keys file
cat /home/user-with-shell/id_rsa.pub >> /home/git/.ssh/authorized_keys

# Remove the copied public key file
rm /home/user-with-shell/id_rsa.pub

Esses comandos irão logar no servidor e copiar o arquivo da chave pública, adicionar o conteúdo desse arquivo no final do arquivo authorized_keys do usuário git e depois remover o arquivo copiado do servidor. Pronto! Seu usuário da máquina cliente está autorizado a logar no servidor com o usuário git sem ter que digitar a senha. Agora falta só criar um repositório de testes e usar. 

CRIANDO UM REPOSITÓRIO DO ZERO
A primeira coisa a se fazer é criar um repositório no servidor com a opção --bare do git. Isso irá criar um repositório com apenas as referências dos objetos e da árvore git. Vamos então logar no servidor e criar um novo repositório:

# Inside server, run
cd /home/git/
sudo mkdir test.git

# Initialize bare repositoy
cd test.git
sudo git init --bare

# Give git ownership to repository files because we created then with root
sudo chown -R git:users /home/git/test.git

No código acima utilizamos sudo para executar os comandos, pois o usuário git não tem permissões de executar shell. Assim, criamos o novo repositório e depois demos permissões para o usuário git, que efetivamente, será o usuário utilizado pelos clientes. Bom, então agora temos um repositório remoto chamado test.git. Basta voltar e configurar o repositório no cliente e subir alguns arquivos de código.
Na máquina cliente, vamos criar um diretório novo chamado test e vamos inicializar um repositório git dentro dele:

# Criar diretório para o novo repositório
mkdir test

# Inicializa o repositório
cd test
git init .

Precisamos agora dizer para esse repositório git local qual tem como remote nosso repositório remoto. Para isso utilizamos o comando git passando a URI do repositório no padrão ssh:

# Sets remote uri
git remote add origin git@remote-server.com:/home/git/test.git
Configurado o apontamento para o servidor remoto vamos criar algum arquivo, fazer o commit e depois push para o repositório remoto:

# Creates new source code file
touch source.py

# Adds new file to stage and commits it
git add source.py
git commit --message "First commit"

# Pushes to remote
git push origin master
Nesse momento, o git se conectou através do ssh e fez as devidas modificações no repositório remoto. Outros usuário ao executar git pull desse mesmo repositório receberão suas modificações.

CONCLUSÃO
Vimos então como configurar nosso servidor git remoto através do ssh e de um usuário git. Vimos também como gerar as chaves pública e privas utilizando criptografia RSA no cliente para logar sem ter que digitar senhas no servidor. Garantimos que o usuário git nunca possa executar comandos não git dentro do servidor e que ele tenha permissão de login. Criamos um repositório novo no servidor e configuramos um repositório local para apontar para ele.
Assim, a equipe da sua empresa, laboratório ou colaboradores pode trabalhar de maneira distribuída e segura remotamente em ambiente privado.