Git LFS

Git se ha convertido en el sistema de control de versiones de facto para desarrolladores de software de todo el mundo. Este sistema de control de versiones distribuido de código abierto es más rápido que sus competidores. Es fácil de usar para ramificar y fusionar código. Sin embargo, tiene un problema de rendimiento con grandes archivos binarios. Se desarrolló un almacenamiento de archivos grande (LFS) de GIT para abordar este problema.

El problema de archivo grande en Git

Tradicionalmente, ciertas empresas e instituciones se han mantenido alejadas de GIT debido a la ineficiencia en el manejo de archivos binarios grandes. Los desarrolladores de videojuegos y las compañías de medios tienen que lidiar con texturas complejas, videos de movimiento completo y archivos de audio de alta calidad. Los institutos de investigación deben realizar un seguimiento de grandes conjuntos de datos que puedan ser gigabytes o terabytes. Git tiene dificultades para mantener estos archivos grandes.

Para comprender el problema, debemos ver cómo GIT realiza un seguimiento de los archivos. Cada vez que hay un compromiso, Git crea un nodo de objeto con un puntero a sus padres o múltiples padres. El modelo de datos GIT se conoce como el gráfico acíclico dirigido (DAG). El modelo DAG asegura que la relación entre padres a hijos nunca pueda formar ningún ciclo.

Podemos inspeccionar el funcionamiento interno del modelo DAG. Aquí hay un ejemplo de tres compromisos en un repositorio:

$ git log -enneline
2BEB263 Commit C: imagen agregada1.jpeg
866178e Commit B: Agregar B.TXT
D48DD8B COMISMA A: Agregue un.TXT

En la confirmación A y B, agregamos el archivo de texto a.txt y b.TXT. Luego, en Commit C, agregamos un archivo de imagen llamado Image1.jpeg. Podemos visualizar el DAG como lo siguiente:

Comprometer C Compromiso B Compromiso A
2BEB263 -> 866178E -> D48DD8B

Si inspeccionamos la última confirmación con el siguiente comando:

$ Git Cat -File -P 2Beb263
Árbol 7CC17BA5B041FB227B9AB534D81BD836183A4E3
Parent 866178e37df64d9f19fa77c00d5ba9d3d4fc68f5
Autor Zak H 1513259427 -0800
Comprador Zak H 1513259427 -0800
Commit C: imagen agregada1.jpeg

Podemos ver que Commit C (2BEB263) tiene Commit B (866178e) como el padre. Ahora, si inspeccionamos el objeto de árbol de Commit C (7CC17BA), podemos ver los blobs (objetos grandes binarios):

$ Git Cat -File -P 7CC17BA
100644 Blob E69DE29BB2D1D6434B8B29AE775AD8C2E48C5391 A.TXT
100644 Blob E69DE29BB2D1D6434B8B29AE775AD8C2E48C5391 B.TXT
100644 Blob A44A66F9E06A8FAF324D3FF3E11C9FA6966BFB56 Imagen1.jpeg

Podemos verificar el tamaño del blob de la imagen:

$ Git Cat -file -S A44A66F9E
871680

Git está haciendo un seguimiento de los cambios en esta estructura de árboles. Hagamos una modificación a la imagen1.JPEG y consulte el historial:

$ git log -enneline
2E257DB Conjunto D: Imagen modificado1.jpeg
2BEB263 Commit C: imagen agregada1.jpeg
866178e Commit B: Agregar B.TXT
D48DD8B COMISMA A: Agregue un.TXT

Si verificamos el objeto DIRME D (2E257DB):

$ Git Cat -File -P 2E257DB
Árbol 2405FAD67610ACF0F57B87AF36F535C1F4F9ED0D
Padre 2BEB263523725E1E8F9D96083140A4A5CD30B651
Autor Zak H 1513272250 -0800
Comprador ZAK H 1513272250 -0800
Commit D: imagen modificada1.jpeg

Y el árbol (2405fad) dentro de él:

$ Git Cat -File -P 2405FAD
100644 Blob E69DE29BB2D1D6434B8B29AE775AD8C2E48C5391 A.TXT
100644 Blob E69DE29BB2D1D6434B8B29AE775AD8C2E48C5391 B.TXT
100644 BLOB CB4A0B67280A92412A81C60DF36A15150E713095 Imagen1.jpeg

Observe que el hash SHA-1 para Image1.JPEG ha cambiado. Significa que ha creado un nuevo blob para Image1.jpeg. Podemos verificar el tamaño del nuevo blob:

$ Git Cat -file -S CB4A0B6
1063696

Aquí hay una forma de visualizar la estructura DAG anterior:

Comprometer D Compromiso C Compromiso B Compromiso A
| | | |
2E257DB -> 2BEB263 -> 866178E -> D48DD8B
| | | |
Tree4 Tree3 Tree2 Tree1
| | | |
Blobs BLOBS BLOBS BLOBS
[/cce_c]
Cada objeto de confirmación mantiene su propio árbol. Las manchas se mantienen dentro de ese árbol. Git optimiza el espacio asegurándose de que solo almacene las diferencias y use la compresión para el almacenamiento. Pero para los cambios de archivo binarios, Git tiene que almacenar archivos completos en las blobs porque es difícil determinar las diferencias. Además, los archivos de imagen, video y audio ya están comprimidos. Como resultado, para cada instancia de un archivo binario modificado, el árbol termina con una gran blob.
Pensemos en un ejemplo en el que realizamos múltiples cambios en un archivo de imagen de 100 MB.
[CC Width = "100%" Height = "100%" Escaped = "True" theme = "Blackboard" Nowrap = "0"]
Commit C -> Commit B -> Commit a
| | |
Tree3 Tree2 Tree1
| | |
Blob3 blob2 blob1
300 MB 200MB 100MB
[/cce_c]
Cada vez que cambiamos el archivo, Git tiene que crear un blob de 100 MB. Entonces, solo después de 3 compromisos, el repositorio de git es de 300 MB. Puede ver que el tamaño del repositorio de git puede explotar rápidamente. Debido a que Git es un control de versión distribuido, va a descargar todo el repositorio a su instancia local y trabajar mucho con sucursales. Entonces, las gotas grandes se convierten en un cuello de botella de rendimiento.
El GIT LFS resuelve el problema reemplazando los blobs con archivos de puntero livianos (PF) y creando un mecanismo para almacenar las manchas en otro lugar.
[CC Width = "100%" Height = "100%" Escaped = "True" theme = "Blackboard" Nowrap = "0"]
Commit C -> Commit B -> Commit a
| | |
Tree3 Tree2 Tree1
| | |
PF3 PF2 PF1
[/cce_c]
Git localmente almacena los blobs en el caché GIT LFS, y de forma remota las almacenará en la tienda GIT LFS en GitHub o Bitbucket.
[CC Width = "100%" Height = "100%" Escaped = "True" theme = "Blackboard" Nowrap = "0"]
PF1 -> Blob1
PF2 -> Blob2
PF3 -> Blob3
[/cce_bash]
Ahora, cuando esté tratando con el repositorio de git, los archivos PF livianos se utilizarán para las operaciones de rutina. Los blobs se recuperarán solo cuando sea necesario. Por ejemplo, si revisa Commit C, entonces Git LFS buscará el puntero PF3 y descargará Blob3. Entonces, el repositorio de trabajo será más delgado y el rendimiento será mejor. No tiene que preocuparse por los archivos de puntero. Git LFS los administrará detrás de escena.

Instalar y ejecutar Git LFS

Ha habido un intento previo de resolver el problema de archivos grandes de git. Pero Git LFS ha tenido éxito porque es fácil de usar. Solo tiene que instalar LFS y decirle qué archivos rastrear.
Puede instalar Git LFS usando los siguientes comandos:
[CC Width = "100%" Height = "100%" Escaped = "True" theme = "Blackboard" Nowrap = "0"]
$ sudo apt-get install software-properties-common
$ curl -s https: // packageCloud.io/install/repositories/github/git-lfs/script.debutante.sh | sudo Bash
$ sudo apt-get install git-lfs
$ git lfs instalación

Una vez que haya instalado GIT LFS, puede rastrear los archivos que desea:

$ git lfs pista "*.jpeg "
Seguimiento "*.jpeg "

La salida le muestra que Git LFS está rastreando los archivos JPEG. Cuando comience a rastrear con LFS, encontrará un .archivo gitattributes que tendrá una entrada que muestra los archivos rastreados. El .archivo gitattributes usa la misma notación que .archivo gitignore. Así es como el contenido de .mira de gitattributes:

$ gato .gitattributes
*.JPEG Filter = LFS Diff = LFS Merge = LFS -Text

También puede encontrar qué archivos se rastrean utilizando el siguiente comando:

$ git lfs pista
Listado de patrones rastreados
*.JPEG (.gitattributes)

Si desea dejar de rastrear un archivo, puede usar el siguiente comando:

$ git lfs noble "*.jpeg "
Sin contratar "*.jpeg "

Para las operaciones generales de git, no tiene que preocuparse por los LFS. Se encargará de todas las tareas de backend automáticamente. Una vez que haya configurado Git LFS, puede trabajar en el repositorio como cualquier otro proyecto.

---

Estudio adicional

Para obtener temas más avanzados, busque los siguientes recursos:

• Mover Repositorio de Git LFS entre hosts
• Eliminar archivos locales git lfs
• Eliminar archivos LFS Remote Git del servidor del servidor
• Sitio web de Git LFS
• Git LFS Documentation

Referencias:

• git-lfs.github.Com: Repo de Github
• github.COM/GIT-LFS/GIT-LFS/TREE/MASTER/DOCS: Documentación de Github para GIT LFS
• atlassiano.com/git/tutorials/git-lfs: tutoriales atlassian
• YouTube.com: ¿Qué es git lfs?
• YouTube.Com: Seguimiento de archivos enormes con Git LFS de Tim Pettersen, Atlassian
• YouTube.com: Administrar archivos enormes en el almacenamiento correcto con Git LFS, YouTube
• YouTube.com: Git Git Almacenamiento de archivos grandes: cómo trabajar con archivos grandes, YouTube
• github.com/git-lfs/git-lfs/blob/master/instalación.MD: Guía de instalación