Introdução
Neste laboratório, você aprenderá como determinar se um repositório Git está utilizando o Git Large File Storage (LFS). Exploraremos os principais indicadores de uso do LFS, começando com a análise do arquivo .gitattributes, que é crucial para configurar o rastreamento do LFS.
Em seguida, você usará o comando git lfs env para verificar o ambiente e as configurações do LFS dentro do repositório. Finalmente, testaremos com arquivos rastreados pelo LFS para confirmar que o LFS está gerenciando ativamente arquivos grandes conforme o esperado. Essa abordagem prática fornecerá as habilidades necessárias para identificar e entender a integração do LFS em seus projetos Git.
Verificar o Arquivo .gitattributes
Nesta etapa, exploraremos como o Git LFS usa um arquivo especial chamado .gitattributes para rastrear arquivos grandes. Este arquivo informa ao Git quais arquivos devem ser manipulados pelo LFS, em vez de serem armazenados diretamente no repositório Git.
Primeiro, vamos garantir que estamos no diretório do nosso projeto. Abra seu terminal e digite:
cd ~/project/my-time-machine
Agora, vamos criar um arquivo fictício que, posteriormente, diremos ao Git LFS para rastrear. Vamos chamá-lo de large_image.png.
echo "This is a large image file placeholder." > large_image.png
Este comando cria um arquivo chamado large_image.png e coloca algum texto dentro. Em um cenário real, este seria um arquivo binário grande, como uma imagem, vídeo ou arquivo compactado.
Em seguida, precisamos dizer ao Git LFS para rastrear este tipo de arquivo. Fazemos isso usando o comando git lfs track. Este comando também cria ou atualiza automaticamente o arquivo .gitattributes em seu repositório.
git lfs track "*.png"
Você deve ver uma saída semelhante a esta:
Tracking "*.png"
Este comando informa ao Git LFS para rastrear todos os arquivos com a extensão .png. Ele também adiciona uma entrada ao arquivo .gitattributes.
Agora, vamos olhar o conteúdo do arquivo .gitattributes para ver o que foi adicionado.
cat .gitattributes
Você deve ver uma saída semelhante a esta:
*.png filter=lfs diff=lfs merge=lfs -text
Esta linha no arquivo .gitattributes é a mágica que informa ao Git para usar o LFS para arquivos .png. Ela especifica que, para arquivos que correspondem ao padrão *.png, o Git deve aplicar o filtro lfs para diffing (comparação de diferenças), merging (mesclagem) e armazenamento. A parte -text garante que o Git não tente tratar arquivos binários como texto.
Entender o arquivo .gitattributes é fundamental para usar o Git LFS de forma eficaz. É assim que você configura quais tipos de arquivos grandes são gerenciados pelo LFS, mantendo seu repositório Git principal pequeno e rápido.
Executar git lfs env para Verificar o LFS
Nesta etapa, usaremos o comando git lfs env para verificar o ambiente do Git LFS e confirmar se ele está configurado corretamente em nosso repositório. Este comando fornece informações úteis sobre a instalação e configuração do Git LFS.
Certifique-se de ainda estar no diretório do seu projeto:
cd ~/project/my-time-machine
Agora, execute o comando git lfs env:
git lfs env
Você deve ver uma saída semelhante a esta (a saída exata pode variar ligeiramente dependendo da versão do Git LFS e da configuração do sistema):
git-lfs/3.x.x (Linux; zsh)
git version 2.34.1
Endpoint=
https://github.com/labex/my-time-machine.git/info/lfs (auth=none)
Endpoint (SSH)=
git@github.com:labex/my-time-machine.git/info/lfs (auth=none)
LocalWorkingDir=/home/labex/project/my-time-machine
LocalGitDir=/home/labex/project/my-time-machine/.git
LocalGitStorageDir=/home/labex/project/my-time-machine/.git/lfs
LocalMediaDir=/home/labex/project/my-time-machine/.git/lfs/objects
LocalRecentObjectsDir=/home/labex/project/my-time-machine/.git/lfs/objects/sha256/recent
LocalRecentObjectsLogDir=/home/labex/project/my-time-machine/.git/lfs/objects/sha256/recent/logs
LocalTmpDir=/home/labex/project/my-time-machine/.git/lfs/tmp
LocalTriggers=
Disk space utilization:
du -s -h .git/lfs
4.0K .git/lfs
Git LFS initialized.
Esta saída fornece muitas informações, incluindo:
- A versão do Git LFS que está sendo usada.
- A versão do Git que está sendo usada.
- Os endpoints do LFS (de onde os arquivos LFS seriam enviados/baixados, embora não estejamos usando um remoto neste laboratório).
- Os diretórios locais onde o Git LFS armazena seus dados dentro do diretório
.git. - Utilização do espaço em disco pelos objetos LFS (atualmente muito pequena, pois ainda não adicionamos nenhum arquivo grande).
- Confirmação de que o Git LFS está inicializado neste repositório.
Executar git lfs env é uma boa maneira de verificar rapidamente se o Git LFS está instalado e configurado corretamente em seu repositório atual. Ele ajuda você a entender onde o LFS está armazenando seus dados e confirma que os hooks (ganchos) e filtros necessários estão em vigor.
Testar com Arquivos Rastreáveis pelo LFS
Nesta etapa final, adicionaremos o arquivo rastreado pelo LFS à área de staging (preparação) do Git e o faremos commit. Isso demonstrará como o Git LFS lida com o arquivo de forma diferente dos arquivos regulares.
Primeiro, certifique-se de estar no diretório correto:
cd ~/project/my-time-machine
Já criamos o arquivo large_image.png e configuramos o Git LFS para rastrear arquivos .png nas etapas anteriores. Agora, vamos adicionar o arquivo à área de staging usando git add:
git add large_image.png
Este comando prepara o arquivo para o próximo commit. O Git LFS intercepta esta operação para large_image.png porque corresponde ao padrão em .gitattributes. Em vez de adicionar todo o conteúdo do arquivo ao índice do Git, o Git LFS adiciona um pequeno arquivo "ponteiro".
Vamos verificar o status para ver o arquivo preparado:
git status
Você deve ver uma saída indicando que large_image.png é um novo arquivo pronto para ser commited:
On branch master
Changes to be committed:
(use "git restore --staged <file>..." to unstage)
new file: .gitattributes
new file: large_image.png
Observe que .gitattributes também está preparado porque o modificamos na Etapa 1.
Agora, vamos fazer commit das alterações:
git commit -m "Add LFS tracked image placeholder"
Você deve ver uma saída semelhante a esta:
[master (root-commit) abcdefg] Add LFS tracked image placeholder
2 files changed, X insertions(+)
create mode 100644 .gitattributes
create mode 100644 large_image.png
A mensagem de commit confirma que tanto .gitattributes quanto large_image.png foram commited. No entanto, o conteúdo real de large_image.png não é armazenado diretamente no commit do Git. Em vez disso, o commit armazena o pequeno arquivo ponteiro, e o conteúdo do arquivo grande é gerenciado pelo Git LFS.
Para ver a diferença, vamos olhar o conteúdo do arquivo conforme armazenado no Git usando git show. Este comando mostra o conteúdo de um arquivo em um commit específico.
git show HEAD:large_image.png
Você deve ver uma saída semelhante a esta:
version https://git-lfs.github.com/spec/v1
oid sha256:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
size 31
Este é o conteúdo do arquivo ponteiro, não o texto real "This is a large image file placeholder.". Isso demonstra que o Git está armazenando uma referência ao arquivo grande, enquanto o Git LFS está gerenciando o conteúdo real do arquivo.
Este é o conceito central do Git LFS: manter o repositório Git principal leve, armazenando apenas ponteiros para arquivos grandes, enquanto o conteúdo do arquivo grande é armazenado separadamente.
Resumo
Neste laboratório, aprendemos como verificar se um repositório Git usa Git LFS. Começamos entendendo o papel do arquivo .gitattributes, que é crucial para configurar o Git LFS. Criamos um arquivo dummy (fictício) e usamos git lfs track para informar ao Git LFS que gerenciasse arquivos com uma extensão específica, observando como este comando atualiza automaticamente o arquivo .gitattributes com a configuração necessária. Em seguida, examinamos o conteúdo do arquivo .gitattributes para ver a entrada adicionada por git lfs track, entendendo o significado dos atributos filter=lfs, diff=lfs, merge=lfs e -text.
Também exploramos o comando git lfs env como outro método para verificar a presença e configuração do Git LFS dentro de um repositório. Este comando fornece informações detalhadas sobre o ambiente do Git LFS, incluindo a versão, as configurações do repositório e os padrões de arquivos rastreados, oferecendo uma visão geral abrangente de como o LFS está configurado. Finalmente, aprendemos como testar o rastreamento do LFS adicionando e commiting um arquivo que corresponde ao padrão configurado, confirmando que o Git LFS lida corretamente com o arquivo grande em vez de armazenar seu conteúdo completo no repositório Git principal.
