Git lfs

O Git se tornou o sistema de controle de versão de fato para desenvolvedores de software em todo o mundo. Este sistema de controle de versão distribuída e de código aberto é mais rápido que seus concorrentes. É fácil de usar para ramificar e mesclar código. No entanto, ele tem um problema de desempenho com grandes arquivos binários. O Git Large Arquive Storage (LFS) foi desenvolvido para resolver este problema.

O grande problema de arquivo em git

Tradicionalmente, certas empresas e instituições ficaram longe do Git devido à ineficiência em grande manuseio de arquivos binários. Desenvolvedores de videogames e empresas de mídia precisam lidar com texturas complexas, vídeos em movimento completo e arquivos de áudio de alta qualidade. Institutos de pesquisa precisam acompanhar grandes conjuntos de dados que podem ser gigabytes ou terabytes. Git tem dificuldade em manter esses arquivos grandes.

Para entender o problema, precisamos dar uma olhada em como o Git acompanha os arquivos. Sempre que houver um compromisso, Git cria um nó de objeto com um ponteiro para seus pais ou vários pais. O modelo de dados Git é conhecido como o gráfico aciclico direcionado (DAG). O modelo DAG garante que o relacionamento pai-filho nunca possa formar ciclos.

Podemos inspecionar o funcionamento interno do modelo DAG. Aqui está um exemplo de três commits em um repositório:

$ git log --oneeline
2BEB263 Commit C: Adicionado imagem1.JPEG
866178E Commit B: Add B.TXT
D48DD8B Commit A: Adicione um.TXT

Em Commit A e B, adicionamos um arquivo de texto a.txt e b.TXT. Então, no commit C, adicionamos um arquivo de imagem chamado Image1.JPEG. Podemos visualizar o DAG como seguinte:

Comprometer c comprometer b cometer um
2BEB263 -> 866178E -> D48DD8B

Se inspecionarmos o último compromisso com o seguinte comando:

$ git -arquivo -p 2BEB263
Árvore 7CC17BA5B041FB227B9AB5534D81BD836183A4E3
Pai 866178E37DF64D9F19FA77C00D5BA9D3D4FC68F5
Autor Zak H 1513259427 -0800
Companheiro Zak H 1513259427 -0800
Compricome C: Adicionado Image1.JPEG

Podemos ver que o comprometimento C (2BEB263) tem comet b (866178e) como pai. Agora, se inspecionarmos o objeto da árvore do Commit C (7CC17BA), podemos ver os Blobs (objetos grandes binários):

$ Git -File de gato -P 7CC17BA
100644 BLOB E69DE29BB2D1D6434B8B29AE775AD8C2E48C5391 A.TXT
100644 BLOB E69DE29BB2D1D6434B8B29AE775AD8C2E48C5391 B.TXT
100644 BLOB A44A66F9E06A8FAF324D3FF3E11C9FA6966BFB56 Imagem1.JPEG

Podemos verificar o tamanho da bolha da imagem:

$ Git -File de gato -S A44A66F9E
871680

O Git está acompanhando as mudanças nesta estrutura de árvore. Vamos fazer uma modificação para a imagem1.JPEG e verifique o histórico:

$ git log --oneeline
2E257DB Commits D: Imagem modificada1.JPEG
2BEB263 Commit C: Adicionado imagem1.JPEG
866178E Commit B: Add B.TXT
D48DD8B Commit A: Adicione um.TXT

Se verificarmos o objeto D confirmar (2E257DB):

$ Git -File de gato -P 2E257DB
Árvore 2405FAD67610ACF0F57B87AF36F535C1F4F9ED0D
Pai 2BEB263523725E1E8F9D96083140A4A5CD30B651
Autor Zak H 1513272250 -0800
Companheiro Zak H 1513272250 -0800
Commit D: Modified Image1.JPEG

E a árvore (2405fad) dentro dela:

$ Git -File de gato -P 2405fad
100644 BLOB E69DE29BB2D1D6434B8B29AE775AD8C2E48C5391 A.TXT
100644 BLOB E69DE29BB2D1D6434B8B29AE775AD8C2E48C5391 B.TXT
100644 BLOB CB4A0B67280A92412A81C60DF36A15150E713095 Imagem1.JPEG

Observe que o hash sha-1 para imagem1.JPEG mudou. Isso significa que criou um novo blob para imagem1.JPEG. Podemos verificar o tamanho da nova blob:

$ Git -File de gato -S CB4A0B6
1063696

Aqui está uma maneira de visualizar a estrutura de DAG acima:

Comprometer D comprometido c com comprometer b comprometer um
| | | |
2E257DB -> 2BEB263 -> 866178E -> D48DD8B
| | | |
Árvore4 árvore3 árvore2 árvore1
| | | |
Blobs Blobs Blobs Blobs
[/cce_c]
Cada objeto commit mantém sua própria árvore. Blobs são mantidos dentro daquela árvore. O Git otimiza o espaço, certificando -se de que ele armazena apenas as diferenças e use a compactação para armazenamento. Mas para alterações binárias de arquivos, o Git precisa armazenar arquivos inteiros nas bolhas, porque é difícil determinar as diferenças. Além disso, arquivos de imagem, vídeo e áudio já estão compactados. Como resultado, para cada instância de um arquivo binário modificado, a árvore acaba com uma bolha grande.
Vamos pensar em um exemplo em que fazemos várias alterações em um arquivo de imagem de 100 MB.
[cc width = "100%" altura = "100%" escapou = "true" tema = "Blackboard" Nowrap = "0"]
Commit C -> Commit B -> Comprometa um
| | |
Árvore3 Árvore2 Árvore1
| | |
BLOB3 BLOB2 BLOB1
300 MB 200MB 100MB
[/cce_c]
Toda vez que alteramos o arquivo, o Git precisa criar uma bolha de 100 MB. Portanto, somente após 3 compromissos, o repositório Git é de 300 MB. Você pode ver que o tamanho do repositório Git pode explodir rapidamente. Como o Git é um controle de versão distribuído, você vai baixar todo o repositório para a sua instância local e trabalhar muito com ramos. Então as grandes bolhas se tornam um gargalo de desempenho.
O Git LFS resolve o problema substituindo os Blobs por arquivos de ponteiro leve (PF) e criando um mecanismo para armazenar os Blobs em outros lugares.
[cc width = "100%" altura = "100%" escapou = "true" tema = "Blackboard" Nowrap = "0"]
Commit C -> Commit B -> Comprometa um
| | |
Árvore3 Árvore2 Árvore1
| | |
PF3 PF2 PF1
[/cce_c]
O Git localmente armazena as bolhas no cache Git LFS e remotamente as armazenará na loja Git LFS no Github ou Bitbucket.
[cc width = "100%" altura = "100%" escapou = "true" tema = "Blackboard" Nowrap = "0"]
PF1 -> BLOB1
PF2 -> BLOB2
PF3 -> BLOB3
[/cce_bash]
Agora, quando você estiver lidando com o repositório Git, os arquivos PF leves serão usados ​​para as operações de rotina. Os Blobs serão recuperados apenas quando necessário. Por exemplo, se você checkout Commit C, então o Git LFS procurará o ponteiro PF3 e baixará o BLOB3. Portanto, o repositório de trabalho será mais magro e o desempenho será melhor. Você não precisa se preocupar com os arquivos de ponteiro. O Git LFS os gerenciará nos bastidores.

Instalando e executando o Git LFS

Houve uma tentativa anterior de resolver o problema de arquivo grande git. Mas o Git LFS conseguiu porque é fácil de usar. Você só precisa instalar o LFS e dizer quais arquivos rastrear.
Você pode instalar o Git LFS usando os seguintes comandos:
[cc width = "100%" altura = "100%" escapou = "true" tema = "Blackboard" Nowrap = "0"]
$ sudo apt-get Install-Properties-Common
$ curl -s https: // packagecloud.io/install/repositórios/github/git-lfs/script.Deb.sh | Sudo Bash
$ sudo apt-get install git-lfs
$ git lfs install

Depois de instalar o GIT LFS, você pode rastrear os arquivos desejados:

$ git lfs faixa "*.jpeg "
Monitorando "*.jpeg "

A saída mostra que o Git LFS está rastreando os arquivos JPEG. Quando você começa a rastrear com LFS, você encontrará um .Arquivo Gitattributes que terá uma entrada mostrando os arquivos rastreados. O .arquivo gitattributes use a mesma notação que .Arquivo Gitignore. Aqui está como o conteúdo de .Gitattributes Looks:

$ cat .gitattributes
*.filtro jpeg = lfs diff = lfs mescla = lfs -text

Você também pode descobrir quais arquivos são rastreados usando o seguinte comando:

$ git lfs faixa
Listando padrões rastreados
*.JPEG (.gitattributes)

Se você quiser parar de rastrear um arquivo, pode usar o seguinte comando:

$ git lfs untrack "*.jpeg "
Upcheing "*.jpeg "

Para operações gerais do Git, você não precisa se preocupar com o LFS. Ele cuidará de todas as tarefas de back -end automaticamente. Depois de configurar o Git LFS, você pode trabalhar no repositório como qualquer outro projeto.

---

Um estudo mais aprofundado

Para tópicos mais avançados, consulte os seguintes recursos:

• Movendo o repositório Git LFS entre os hosts
• Excluindo arquivos Git LFS locais
• Removendo arquivos LFS Remote Git do servidor
• Site Git LFS
• Documentação Git LFS

Referências:

• git-lfs.Github.com: repo Github
• Github.com/git-lfs/git-lfs/árvore/mestre/docs: documentação do github para git lfs
• Atlassiano.com/git/tutoriais/git-lfs: tutoriais atlassianos
• YouTube.com: o que é git lfs
• YouTube.com: rastreando arquivos enormes com git lfs de tim pettersen, atlassian
• YouTube.com: Gerenciando arquivos enormes no armazenamento certo com Git LFS, YouTube
• YouTube.com: Git Large Argile Storage - Como trabalhar com arquivos grandes, YouTube
• Github.com/git-lfs/git-lfs/blob/master/instalação.MD: Guia de instalação