Como criar um repositório Git remoto a partir de um local?

Eu tenho um repositório Git local. Gostaria de disponibilizá-lo em um servidor remoto habilitado para ssh. Como eu faço isso?

Eu acho que você cria um repositório vazio no lado remoto git init --bare, adiciona o lado remoto como rastreador push / pull do seu repositório local ( git remote add origin URL) e, em seguida, localmente, basta dizer git push origin master. Agora qualquer outro repositório pode pulldo repositório remoto.

Para configurar inicialmente qualquer servidor Git, você precisa exportar um repositório existente para um novo repositório bare - um repositório que não contém um diretório ativo. Isso geralmente é simples de fazer. Para clonar seu repositório para criar um novo repositório vazio, execute o comando clone com a --bareopção Por convenção, os diretórios bare repository terminam da seguinte .gitmaneira:

$ git clone --bare my_project my_project.git
Initialized empty Git repository in /opt/projects/my_project.git/

Este comando pega o repositório Git sozinho, sem um diretório ativo, e cria um diretório especificamente para ele sozinho.

Agora que você possui uma cópia simples do seu repositório, tudo o que você precisa fazer é colocá-lo em um servidor e configurar seus protocolos. Digamos que você configurou um servidor chamado git.example.comao qual tem acesso SSH e deseja armazenar todos os seus repositórios Git no /opt/gitdiretório Você pode configurar seu novo repositório, copiando-o sobre:

$ scp -r my_project.git [email protected]:/opt/git

Nesse ponto, outros usuários que têm acesso SSH ao mesmo servidor que possui acesso de leitura ao /opt/gitdiretório podem clonar seu repositório executando

$ git clone [email protected]:/opt/git/my_project.git

Se um usuário fizer SSH em um servidor e tiver acesso de gravação ao /opt/git/my_project.gitdiretório, ele também terá acesso automático por push. O Git adicionará automaticamente permissões de gravação de grupo a um repositório corretamente se você executar o comando git init com a --sharedopção

$ ssh [email protected]
$ cd /opt/git/my_project.git
$ git init --bare --shared

É muito fácil pegar um repositório Git, criar uma versão simples e colocá-lo em um servidor ao qual você e seus colaboradores tenham acesso SSH. Agora você está pronto para colaborar no mesmo projeto.

Uma observação para quem criou a cópia local no Windows e deseja criar um repositório remoto correspondente em um sistema de linha Unix, onde os arquivos de texto obtêm terminações LF em clones adicionais de desenvolvedores em sistemas semelhantes ao Unix, mas terminações CRLF no Windows.

Se você criou seu repositório do Windows antes de configurar a tradução de final de linha , há um problema. A configuração padrão do Git é sem tradução, portanto, seu conjunto de trabalho usa CRLF, mas seu repositório (ou seja, os dados armazenados em .git) também salvou os arquivos como CRLF.

Quando você pressiona o controle remoto, os arquivos salvos são copiados como estão, nenhuma conversão de final de linha ocorre. (A conversão de final de linha ocorre quando os arquivos são confirmados em um repositório, não quando os repositórios são enviados por push). Você acaba com o CRLF no seu repositório do tipo Unix, que não é o que você deseja.

Para obter o LF no repositório remoto, é necessário garantir que o LF esteja no repositório local primeiro, normalizando novamente o repositório do Windows . Isso não terá efeito visível no seu conjunto de trabalho do Windows, que ainda possui terminações CRLF; no entanto, quando você pressiona para o controle remoto, o controle remoto obtém o LF corretamente.

Não tenho certeza se existe uma maneira fácil de dizer quais terminações de linha você tem no seu repositório do Windows - acho que você pode testá-la definindo core.autocrlf = false e clonando (se o repositório tiver terminações LF, o clone terá LF também).

Há uma diferença interessante entre as duas soluções populares acima:

1. Se você criar o repositório vazio como este:

   cd / outside_of_any_repo
   mkdir my_remote.git
   cd my_remote.git
   git init --bare
   

e depois

cd  /your_path/original_repo
git remote add origin /outside_of_any_repo/my_remote.git
git push --set-upstream origin master

Então o git define a configuração em 'original_repo' com este relacionamento:

original_repo origin --> /outside_of_any_repo/my_remote.git/

com o último como o controle remoto a montante. E o controle remoto upstream não possui outros controles remotos em sua configuração.

2. No entanto, se você fizer o contrário:

   (de no diretório original_repo)
   cd ..
   git clone --bare original_repo /outside_of_any_repo/my_remote.git
   

então 'my_remote.git' termina com sua configuração com 'origin' apontando para 'original_repo' como um controle remoto, com um remote.origin.url igual ao caminho do diretório local, o que pode não ser apropriado se for movido para um servidor.

Embora seja fácil se livrar dessa referência "remota" mais tarde, se não for apropriado, 'original_repo' ainda precisa ser configurado para apontar para 'my_remote.git' como um remoto remoto (ou para onde quer que vá) para ser compartilhado). Portanto, tecnicamente, você pode chegar ao mesmo resultado com mais algumas etapas na abordagem nº 2. Porém, o nº 1 parece uma abordagem mais direta para a criação de um "repositório compartilhado básico" originário de um local, apropriado para a migração para um servidor, com menos etapas envolvidas. Acho que depende do papel que você deseja que o repo remoto desempenhe. (E sim, isso está em conflito com a documentação aqui .)

Advertência: eu aprendi o que foi dito acima (neste artigo, no início de agosto de 2019), fazendo um teste no meu sistema local com um repo real e, em seguida, fazendo uma comparação arquivo a arquivo entre os resultados. Mas! Ainda estou aprendendo, então poderia haver uma maneira mais correta. Mas meus testes me ajudaram a concluir que o nº 1 é o meu método preferido atualmente.

Um repositório remoto geralmente é um repositório simples - um repositório Git que não possui diretório ativo. Como o repositório é usado apenas como um ponto de colaboração, não há razão para fazer check-out de um instantâneo no disco; são apenas os dados do Git. Nos termos mais simples, um repositório vazio é o conteúdo do diretório .git do seu projeto e nada mais.

Você pode criar um repositório bare git com o seguinte código:

$ git clone --bare /path/to/project project.git

Uma opção para ter um repositório git remoto é usar o protocolo SSH:

Um protocolo de transporte comum para o Git quando a auto-hospedagem termina no SSH. Isso ocorre porque o acesso SSH aos servidores já está configurado na maioria dos lugares - e, se não for, é fácil. O SSH também é um protocolo de rede autenticado e, por ser onipresente, geralmente é fácil de configurar e usar.

Para clonar um repositório Git sobre SSH, você pode especificar um ssh://URL como este:

$ git clone ssh://[user@]server/project.git

Ou você pode usar a sintaxe mais curta do tipo scp para o protocolo SSH:

$ git clone [user@]server:project.git

Nos dois casos acima, se você não especificar o nome de usuário opcional, o Git assumirá o usuário no qual você está conectado.

Os prós

Os profissionais do SSH são muitos. Primeiro, o SSH é relativamente fácil de configurar - os daemons do SSH são comuns, muitos administradores de rede têm experiência com eles e muitas distribuições de SO são configuradas com eles ou têm ferramentas para gerenciá-los. Em seguida, o acesso via SSH é seguro - toda a transferência de dados é criptografada e autenticada. Por fim, como os protocolos HTTPS, Git e Local, o SSH é eficiente, tornando os dados o mais compactos possível antes de transferi-los.

Os contras

O aspecto negativo do SSH é que ele não suporta acesso anônimo ao seu repositório Git. Se você estiver usando SSH, as pessoas deverão ter acesso SSH à sua máquina, mesmo na capacidade de somente leitura, o que não torna o SSH propício a projetos de código aberto para os quais as pessoas podem simplesmente querer clonar seu repositório para examiná-lo. Se você o estiver usando somente dentro da sua rede corporativa, o SSH pode ser o único protocolo com o qual você precisa lidar. Se você deseja permitir acesso anônimo somente leitura aos seus projetos e também deseja usar o SSH, precisará configurar o SSH para fazer o push-over, mas algo mais para que outros possam buscar.

Para obter mais informações, consulte a referência: Git no servidor - os protocolos

Você precisa criar um diretório em um servidor remoto. Em seguida, use o comando "git init" para configurá-lo como um repositório. Isso deve ser feito para cada novo projeto que você possui (cada nova pasta)

Supondo que você já configurou e usou o git usando chaves ssh, escrevi um pequeno script Python, que, quando executado a partir de um diretório ativo, configurará um controle remoto e inicializará o diretório como um repositório git. Obviamente, você terá que editar o script (apenas uma vez) para informar o servidor e o caminho raiz para todos os repositórios.

Confira aqui - https://github.com/skbobade/ocgi

Normalmente, você pode configurar um repositório git usando o initcomando

git init

No seu caso, já existe um repositório disponível em um controle remoto. Dependendo de como você acessa seu repositório remoto (com nome de usuário dentro do URL ou uma chave ssh que lida com a verificação), use apenas o clonecomando:

git clone git@[my.url.com]:[git-repo-name].git

Também há outras maneiras de clonar o repositório. Dessa forma, você poderá chamá-lo se tiver uma configuração de chave ssh na sua máquina que verifique se você está puxando seu repositório. Existem outras combinações de URL, se você quiser incluir sua senha e nome de usuário para fazer login no seu repositório remoto.